retinal-thin-vessels 1.0__tar.gz

retinal_thin_vessels-1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 J-Linaris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

retinal_thin_vessels-1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: retinal_thin_vessels
+Version: 1.0
+Summary: A Python package for analyzing thin retinal vessels and creating vessels-thickness based weight maps
+Author-email: João Paulo Menezes Linaris <joaolinaris@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/J-Linaris/retinal_thin_vessels
+Project-URL: Repository, https://github.com/J-Linaris/retinal_thin_vessels
+Keywords: retina,retinal,retinal-vessels,vessel-segmentation,image-analysis,medical-imaging,deep-learning,weight-map,pytorch,thin-vessels,image-segmentation,binary-masks,binary-mask
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: torch
+Requires-Dist: scikit-image
+Requires-Dist: Pillow
+Dynamic: license-file
+
+# retinal_thin_vessels
+
+A Python package for computing the recall and precision scores specifically on thin vessels in retinal images, as detailed in the paper "Vessel-Width-Based Metrics and Weight Masks for Retinal Blood Vessel Segmentation", published in WUW-SIBGRAPI 2025. The package also includes a function for visualizing thickness-based filtered masks, the basic structure for computing the proposed metrics.
+
+## Package installation
+
+```bash
+pip install retinal_thin_vessels
+```
+
+## Usage Demonstration with DRIVE and CHASEDB1
+
+To ensure the metrics are reliable, it is important to visualize the specific thin-vessel mask used by the given functions in their calculations. Therefore, a core function, get_thin_vessels_mask(), is also provided. This function takes a standard segmentation mask and returns a new mask containing only the thin vessels.
+
+The following code demonstrates how to generate this filtered mask using images from two public datasets: DRIVE and CHASEDB1.
+
+```python
+from PIL import Image
+from retinal_thin_vessels.core import get_thin_vessels_mask
+from retinal_thin_vessels.metrics import recall_thin_vessels, precision_thin_vessels
+from sklearn.metrics import recall_score, precision_score
+```
+
+```python
+# Import the original segmentation masks
+seg_DRIVE = Image.open(f"tests/imgs/DRIVE_seg_example.png")
+seg_CDB1 = Image.open(f"tests/imgs/CHASEDB1_seg_example.png")
+
+# generates new masks containing only thin vessels
+thin_vessels_seg_DRIVE = get_thin_vessels_mask(seg_DRIVE)
+thin_vessels_seg_CDB1 = get_thin_vessels_mask(seg_CDB1)
+
+# Display the original segmentation mask and the resulting thin-vessel-only mask for comparison
+seg_DRIVE.show()
+img_DRIVE = Image.fromarray(thin_vessels_seg_DRIVE)
+img_DRIVE.show()
+
+seg_CDB1.show()
+img_CDB1 = Image.fromarray(thin_vessels_seg_CDB1)
+img_CDB1.show()
+```
+<img src="tests/imgs/DRIVE_seg_example.png" alt="DRIVE_thin_vessels_example" width=300/>
+<img src="tests/imgs/DRIVE_seg_thin_example.png" alt="DRIVE_thin_vessels_example" width=300/>
+<img src="tests/imgs/CHASEDB1_seg_example.png" alt="CHASEDB1_thin_vessels_example" width=300/>
+<img src="tests/imgs/CHASEDB1_seg_thin_example.png" alt="CHASEDB1_thin_vessels_example" width=300/>
+
+Furthermore, to demonstrate the metric calculation functions, you can run the code below. It compares the overall metrics (calculated with scikit-learn) to the thin-vessel-specific metrics calculated by this package.
+
+```python
+# Load the ground truth segmentation mask and a sample prediction
+pred = Image.open(f"tests/imgs/DRIVE_pred_example.png")
+seg_DRIVE = Image.open(f"tests/imgs/DRIVE_seg_example.png").resize((pred.size), Image.NEAREST)
+
+# Binarize images to a 0/1 format for scikit-learn compatibility
+seg_DRIVE = np.where(np.array(seg_DRIVE) > 0, 1, 0)
+pred = np.where(np.array(pred) > 0, 1, 0)
+
+# Compute and print the metrics
+print(f"Overall Recall score: {recall_score(seg_DRIVE.flatten(), pred.flatten())}")
+print(f"Recall score on thin vessels: {recall_thin_vessels(seg_DRIVE, pred)}")
+print("-" * 30)
+print(f"Overall Precision score: {precision_score(seg_DRIVE.flatten(), pred.flatten())}")
+print(f"Precision score on thin Vessels: {precision_thin_vessels(seg_DRIVE, pred)}")
+```
+
+If the program is running correctly with the provided sample images, the results should be similar to this:
+
+```bash
+Overall Recall score: 0.8553852359822509
+Recall score on thin vessels: 0.751244555071562
+------------------------------
+Overall Precision score: 0.8422369623068674
+Precision score on thin Vessels: 0.6527915897144481
+```

retinal_thin_vessels-1.0/README.md

@@ -0,0 +1,74 @@
+# retinal_thin_vessels
+
+A Python package for computing the recall and precision scores specifically on thin vessels in retinal images, as detailed in the paper "Vessel-Width-Based Metrics and Weight Masks for Retinal Blood Vessel Segmentation", published in WUW-SIBGRAPI 2025. The package also includes a function for visualizing thickness-based filtered masks, the basic structure for computing the proposed metrics.
+
+## Package installation
+
+```bash
+pip install retinal_thin_vessels
+```
+
+## Usage Demonstration with DRIVE and CHASEDB1
+
+To ensure the metrics are reliable, it is important to visualize the specific thin-vessel mask used by the given functions in their calculations. Therefore, a core function, get_thin_vessels_mask(), is also provided. This function takes a standard segmentation mask and returns a new mask containing only the thin vessels.
+
+The following code demonstrates how to generate this filtered mask using images from two public datasets: DRIVE and CHASEDB1.
+
+```python
+from PIL import Image
+from retinal_thin_vessels.core import get_thin_vessels_mask
+from retinal_thin_vessels.metrics import recall_thin_vessels, precision_thin_vessels
+from sklearn.metrics import recall_score, precision_score
+```
+
+```python
+# Import the original segmentation masks
+seg_DRIVE = Image.open(f"tests/imgs/DRIVE_seg_example.png")
+seg_CDB1 = Image.open(f"tests/imgs/CHASEDB1_seg_example.png")
+
+# generates new masks containing only thin vessels
+thin_vessels_seg_DRIVE = get_thin_vessels_mask(seg_DRIVE)
+thin_vessels_seg_CDB1 = get_thin_vessels_mask(seg_CDB1)
+
+# Display the original segmentation mask and the resulting thin-vessel-only mask for comparison
+seg_DRIVE.show()
+img_DRIVE = Image.fromarray(thin_vessels_seg_DRIVE)
+img_DRIVE.show()
+
+seg_CDB1.show()
+img_CDB1 = Image.fromarray(thin_vessels_seg_CDB1)
+img_CDB1.show()
+```
+<img src="tests/imgs/DRIVE_seg_example.png" alt="DRIVE_thin_vessels_example" width=300/>
+<img src="tests/imgs/DRIVE_seg_thin_example.png" alt="DRIVE_thin_vessels_example" width=300/>
+<img src="tests/imgs/CHASEDB1_seg_example.png" alt="CHASEDB1_thin_vessels_example" width=300/>
+<img src="tests/imgs/CHASEDB1_seg_thin_example.png" alt="CHASEDB1_thin_vessels_example" width=300/>
+
+Furthermore, to demonstrate the metric calculation functions, you can run the code below. It compares the overall metrics (calculated with scikit-learn) to the thin-vessel-specific metrics calculated by this package.
+
+```python
+# Load the ground truth segmentation mask and a sample prediction
+pred = Image.open(f"tests/imgs/DRIVE_pred_example.png")
+seg_DRIVE = Image.open(f"tests/imgs/DRIVE_seg_example.png").resize((pred.size), Image.NEAREST)
+
+# Binarize images to a 0/1 format for scikit-learn compatibility
+seg_DRIVE = np.where(np.array(seg_DRIVE) > 0, 1, 0)
+pred = np.where(np.array(pred) > 0, 1, 0)
+
+# Compute and print the metrics
+print(f"Overall Recall score: {recall_score(seg_DRIVE.flatten(), pred.flatten())}")
+print(f"Recall score on thin vessels: {recall_thin_vessels(seg_DRIVE, pred)}")
+print("-" * 30)
+print(f"Overall Precision score: {precision_score(seg_DRIVE.flatten(), pred.flatten())}")
+print(f"Precision score on thin Vessels: {precision_thin_vessels(seg_DRIVE, pred)}")
+```
+
+If the program is running correctly with the provided sample images, the results should be similar to this:
+
+```bash
+Overall Recall score: 0.8553852359822509
+Recall score on thin vessels: 0.751244555071562
+------------------------------
+Overall Precision score: 0.8422369623068674
+Precision score on thin Vessels: 0.6527915897144481
+```

retinal_thin_vessels-1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "retinal_thin_vessels"
+version = "1.0"
+authors = [
+    {name = "João Paulo Menezes Linaris", email = "joaolinaris@gmail.com"},
+]
+description = "A Python package for analyzing thin retinal vessels and creating vessels-thickness based weight maps"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["retina", "retinal", "retinal-vessels", "vessel-segmentation",
+        "image-analysis", "medical-imaging", "deep-learning",
+        "weight-map", "pytorch", "thin-vessels", "image-segmentation", "binary-masks",
+        "binary-mask"]
+classifiers = [
+    'Intended Audience :: Science/Research',
+    'Operating System :: POSIX :: Linux',        
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3.8',
+    'Programming Language :: Python :: 3.9',
+    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
+    'Programming Language :: Python :: 3.12',
+]
+
+dependencies = [
+    "numpy",
+    "torch",
+    "scikit-image",
+    "Pillow",      
+]
+
+[project.urls]
+Homepage = "https://github.com/J-Linaris/retinal_thin_vessels"
+Repository = "https://github.com/J-Linaris/retinal_thin_vessels"
+

retinal_thin_vessels-1.0/retinal_thin_vessels/__init__.py

@@ -0,0 +1,6 @@
+__all__ = [
+    "core",
+    "metrics",
+    "input_transformation",
+    "get_relation"
+]

retinal_thin_vessels-1.0/retinal_thin_vessels/core.py

@@ -0,0 +1,182 @@
+import numpy as np
+from skimage.morphology import medial_axis, area_closing
+from PIL import Image
+from retinal_thin_vessels.input_transformation import prepare_ground_truth, prepare_prediction
+from retinal_thin_vessels.external.DSE_skeleton_pruning.dsepruning.dsepruning import skel_pruning_DSE
+
+def __get_shift_tuples(value):
+    
+    # Sets the radius
+    radius = int(np.ceil(value))
+    
+    # Creates all combinations of shifts based on the raidus
+    x_shifts, y_shifts = np.meshgrid(np.arange(-radius, radius + 1), np.arange(-radius, radius + 1))
+    
+    # Stacks all shifts together on a list
+    shifts = np.column_stack((x_shifts.ravel(), y_shifts.ravel()))  
+    # shifts = [(dx, dy) for dx, dy in shifts if (dx, dy) != (0, 0)]  # Returns without (0,0)
+    
+    return  shifts
+
+def __get_filtered_mask(seg_mask, ceil=1.0):
+    """
+    Returns a [H,W] shaped numpy array containing the thin-vessels only
+    mask.
+    """
+
+    # Application of closing on the segmentation mask
+    closed_seg_mask = area_closing(seg_mask)
+
+    # Obtaining the skeleton
+    skeleton_medial_axis, distances = medial_axis(closed_seg_mask, return_distance=True)
+
+    # Skeleton pruning
+    skeleton_medial_axis = skel_pruning_DSE(skeleton_medial_axis, distances, np.ceil(distances.max()))
+    
+    # Compute the skeleton with the values of the distances
+    dist_skel = np.where(skeleton_medial_axis>0, distances, 0) 
+
+    # Get unique values of dist_skel excluding 0 (values of the radius of vessels)
+    values_dist_skel = np.unique(dist_skel)[1:] 
+
+    #~~~~~~~~~~~~~~~~~~~~~~~Segmentation mask recriation with thin vessels only~~~~~~~~~~~~~~~~~~
+
+    # Initializes the two necessary masks
+    filtered_seg_mask = np.zeros(dist_skel.shape)
+    reconstructed_seg_mask = np.zeros(dist_skel.shape)
+
+    height = len(dist_skel)
+    width = len(dist_skel[0])
+
+    # Reconstructs each mask using a sphere of varying radius
+    for value in values_dist_skel:
+        shifts = __get_shift_tuples(value)
+
+        for i in range(height):
+            for j in range(width):
+                
+                if dist_skel[i][j] == value :
+                    
+                    if value <= ceil: 
+                        for dx, dy in shifts:
+                            if 0 <= i+dx < height and 0 <= j+dy < width:
+                                filtered_seg_mask[i+dx][j+dy] = 255
+                    
+                    for dx, dy in shifts:
+                        if 0 <= i+dx < height and 0 <= j+dy < width:
+                            reconstructed_seg_mask[i+dx][j+dy] = 255
+
+    # Filtering to get exactly the shape of the vessels intead of something rounded
+    filtered_seg_mask = np.where((seg_mask>0) & (filtered_seg_mask>0), 255, 0).astype(np.uint8)
+    reconstructed_seg_mask = np.where((seg_mask>0) & (reconstructed_seg_mask>0), 255, 0).astype(np.uint8)
+
+    # Gets exactly the excluded vessels
+    excluded_vessels = np.where((seg_mask>0) & (reconstructed_seg_mask==0), 255, 0).astype(np.uint8)
+
+    # Concatenation of excluded_vessels seg mask with the thin vessels mask (we garantee they are small due to
+    # their exclusion in the prunning/closing process)
+    filtered_seg_mask = np.where((filtered_seg_mask>0) | (excluded_vessels>0), 255, 0).astype(np.uint8)
+    
+    return filtered_seg_mask
+
+
+def get_thin_vessels_mask(seg_mask, ceil=1.0, mask_type="ground_truth"):
+    """
+    Returns a numpy array containing the thin-vessels only mask.
+
+    The Input is expected to be a segmentation mask, therefore, the 
+    function accepts inputs with:
+
+    -> shape: (H,W); (1,H,W); (N,1,H,W)
+        
+    -> values: BINARY
+    
+    -> mask_type: "ground_truth" or "prediction" (affects how we 
+                  transform the provided mask beofre computing the 
+                  filtered one. If equal to "groun_truth", will
+                  apply a threshold of 0 for classifying pixels in the
+                  image)
+
+
+    Thin vessels are defined as those whose radius is less than or
+    equal to 'ceil'.
+    """
+
+    # Input value verification
+    accepted_mask_type_values = ["ground_truth", "prediction"]
+
+    if mask_type not in accepted_mask_type_values:
+        raise ValueError(f"Expected valid mask type. Accepted values: {accepted_mask_type_values}. Got: {mask_type}")
+    
+    # Input preparation
+    if mask_type == "ground_truth":
+        seg_mask = prepare_ground_truth(seg_mask)
+    else:
+        seg_mask = prepare_prediction(seg_mask)
+
+    input_dimension = seg_mask.ndim
+
+    # Get the filtered mask(s)
+    filtered_seg_mask = []
+    if input_dimension == 4:
+        
+        # Obtain each mask separately
+        for i in range(len(seg_mask)):
+            #[H,W] ---> [1,H,W]
+            unique_filtered_seg_mask = np.expand_dims(__get_filtered_mask(seg_mask[i][0], ceil), axis=0) 
+            
+            # Appends to the filtered_seg_mask vector (naturally, this vector will be [N,1,H,W])
+            filtered_seg_mask.append(unique_filtered_seg_mask)
+        
+        # Converts into a numpy array
+        filtered_seg_mask = np.array(filtered_seg_mask)
+
+    elif input_dimension == 3:
+        
+        # Obtains the mask using the reduced dimension mask
+        filtered_seg_mask = __get_filtered_mask(seg_mask[0], ceil)
+
+        # Expands the dimension again for maintaining consistency with input shape
+        filtered_seg_mask = np.expand_dims(filtered_seg_mask, axis=0)
+    
+    else:
+        # Obtains the mask
+        filtered_seg_mask = __get_filtered_mask(seg_mask, ceil)
+
+    return filtered_seg_mask
+
+def main():
+
+    # Loads the data
+    example_components_path = "../tests/imgs/"   
+    seg = Image.open(f"{example_components_path}DRIVE_seg_example.png")
+    
+    # Gets the filtered mask with only thin vessels
+
+    #-----> for a [N,1,H,W] shape input
+    seg_4_dims = np.expand_dims(np.expand_dims(np.array(seg), axis=0),axis=0)
+    seg_4_dims = np.concatenate((seg_4_dims,seg_4_dims,seg_4_dims), axis=0)
+
+    thin_vessels_seg = get_thin_vessels_mask(seg_4_dims)
+    print(f"Test 1: original shape: {seg_4_dims.shape} ---> filtered mask shape: {thin_vessels_seg.shape}")
+    
+    #-----> for a [1,H,W] shape input
+    seg_3_dims = np.expand_dims(np.array(seg), axis=0)
+    
+    thin_vessels_seg = get_thin_vessels_mask(seg_3_dims)
+    print(f"Test 2: original shape: {seg_3_dims.shape} ---> filtered mask shape: {thin_vessels_seg.shape}")
+
+    #-----> for a [H,W] shape input
+    thin_vessels_seg = get_thin_vessels_mask(seg)
+    print(f"Test 3: original shape: {np.array(seg).shape} ---> filtered mask shape: {thin_vessels_seg.shape}")
+
+    # Shows the filtered segmentation mask
+    print("Showing the filtered segmentation mask with thin vessels only.")
+    img = Image.fromarray(thin_vessels_seg)
+    img.show()
+
+    exit(0)
+
+
+if __name__ == "__main__":
+    main()

retinal_thin_vessels-1.0/retinal_thin_vessels/external/DSE_skeleton_pruning/dsepruning/__init__.py

@@ -0,0 +1 @@
+from dsepruning.dsepruning import skel_pruning_DSE

retinal_thin_vessels-1.0/retinal_thin_vessels/external/DSE_skeleton_pruning/dsepruning/dsepruning.py

@@ -0,0 +1,128 @@
+import sknw
+import numpy as np
+from skimage.draw import line
+from dsepruning.dse_helper import recnstrc_by_disk, get_weight
+# from .dse_helper import recnstrc_by_disk, get_weight -----> original (didn't work)
+
+def flatten(l):
+    return [item for sublist in l for item in sublist]
+
+def _remove_branch_by_DSE(G, recn, dist, max_px_weight, checked_terminal=set()):
+    deg = dict(G.degree())
+    terminal_points = [i for i, d in deg.items() if d == 1]
+    edges = list(G.edges())
+    # temporary branch reconstruction mask
+    branch_recn = np.zeros_like(recn, dtype=np.int32)
+    branch_recn = np.zeros_like(recn, dtype=np.int32)
+    for s, e in edges:
+        if s == e:
+            G.remove_edge(s, e)
+            continue
+        vals = flatten([[v] for v in G[s][e].values()])
+        for ix, val in enumerate(vals):
+            if s not in terminal_points and e not in terminal_points:
+                continue
+            if s in checked_terminal or e in checked_terminal:
+                continue
+            pts = val.get('pts').tolist()
+            pts.append(G.nodes[s]['o'].astype(np.int32).tolist())
+            pts.append(G.nodes[e]['o'].astype(np.int32).tolist())
+            recnstrc_by_disk(np.array(pts, dtype=np.int32), dist, branch_recn)
+            weight = get_weight(recn, branch_recn)
+            if s in terminal_points:
+                checked_terminal.add(s)
+                if weight < max_px_weight:
+                    G.remove_node(s)
+                    recn = recn - branch_recn
+            if e in terminal_points:
+                checked_terminal.add(e)
+                if weight < max_px_weight:
+                    G.remove_node(e)
+                    recn = recn - branch_recn
+    return G, recn
+
+def _remove_mid_node(G):
+    start_index = 0
+    while True:
+        nodes = [x for x in G.nodes() if G.degree(x) == 2]
+        if len(nodes) == start_index:
+            break
+        i = nodes[start_index]
+        nbs = list(G[i])
+        # assert len(nbs)==2, 'degree not match'
+        if len(nbs) != 2:
+            start_index = start_index + 1
+            continue
+
+        edge1 = G[i][nbs[0]][0]
+        edge2 = G[i][nbs[1]][0]
+
+        s1, e1 = edge1['pts'][0], edge1['pts'][-1]
+        s2, e2 = edge2['pts'][0], edge2['pts'][-1]
+        dist = np.array(list(map(np.linalg.norm, [s1-s2, e1-e2, s1-e2, s2-e1])))
+        if dist.argmin() == 0:
+            line = np.concatenate([edge1['pts'][::-1], [G.nodes[i]['o'].astype(np.int32)], edge2['pts']], axis=0)
+        elif dist.argmin() == 1:
+            line = np.concatenate([edge1['pts'], [G.nodes[i]['o'].astype(np.int32)], edge2['pts'][::-1]], axis=0)
+        elif dist.argmin() == 2:
+            line = np.concatenate([edge2['pts'], [G.nodes[i]['o'].astype(np.int32)], edge1['pts']], axis=0)
+        elif dist.argmin() == 3:
+            line = np.concatenate([edge1['pts'], [G.nodes[i]['o'].astype(np.int32)], edge2['pts']], axis=0)
+        G.add_edge(nbs[0], nbs[1], weight=edge1['weight']+edge2['weight'], pts=line)
+        G.remove_node(i)
+    return G
+
+def skel_pruning_DSE(skel, dist, min_area_px=100, return_graph=False):
+    """Skeleton pruning using dse
+    
+    Arguments:
+        skel {ndarray} -- skeleton obtained from skeletonization algorithm
+        dist {ndarray} -- distance transfrom map
+    
+    Keyword Arguments:
+        min_area_px {int} -- branch reconstruction weights, measured by pixel area. Branch reconstruction weights smaller than this threshold will be pruned. (default: {100})
+        return_graph {bool} -- return graph
+
+    Returns:
+        ndarray -- pruned skeleton map
+    """
+    graph = sknw.build_sknw(skel, multi=True)
+    dist = dist.astype(np.int32)
+    graph = _remove_mid_node(graph)
+    edges = list(set(graph.edges()))
+    pts = []
+    for s, e in edges:
+        vals = flatten([[v] for v in graph[s][e].values()])
+        for ix, val in enumerate(vals):
+            pts.extend(val.get('pts').tolist())
+        pts.append(graph.nodes[s]['o'].astype(np.int32).tolist())
+        pts.append(graph.nodes[e]['o'].astype(np.int32).tolist()) 
+    recnstrc = np.zeros_like(dist, dtype=np.int32)
+    recnstrc_by_disk(np.array(pts, dtype=np.int32), dist, recnstrc) 
+    num_nodes = len(graph.nodes())
+    checked_terminal = set()
+    while True:
+        # cannot combine with other pruning method because the reconstruction map is not updated in other approach
+        graph, recnstrc = _remove_branch_by_DSE(graph, recnstrc, dist, min_area_px, checked_terminal=checked_terminal)
+        if len(graph.nodes()) == num_nodes:
+            break
+        graph = _remove_mid_node(graph)
+        num_nodes = len(graph.nodes())
+    if return_graph:
+        return graph2im(graph, skel.shape), graph
+    else:
+        return graph2im(graph, skel.shape)      
+
+def graph2im(graph, shape):
+    mask = np.zeros(shape, dtype=bool)
+    for s,e in graph.edges():
+        vals = flatten([[v] for v in graph[s][e].values()])
+        for val in vals:
+            coords = val.get('pts')
+            coords_1 = np.roll(coords, -1, axis=0)
+            for i in range(len(coords)-1):
+                rr, cc = line(*coords[i], *coords_1[i])
+                mask[rr, cc] = True
+            mask[tuple(graph.nodes[s]['pts'].T.tolist())] = True
+            mask[tuple(graph.nodes[e]['pts'].T.tolist())] = True
+    return mask

retinal_thin_vessels-1.0/retinal_thin_vessels/external/DSE_skeleton_pruning/setup.py

@@ -0,0 +1,14 @@
+from setuptools import setup, Extension
+import numpy
+
+setup(
+    ext_modules=[
+        Extension(
+            'dsepruning.dse_helper',
+            ['dsepruning/dse_helper.pyx'],
+            include_dirs=[numpy.get_include()],
+            extra_compile_args=['-fopenmp'],
+            extra_link_args=['-fopenmp']
+        )
+    ]
+)

retinal_thin_vessels-1.0/retinal_thin_vessels/get_relation.py

@@ -0,0 +1,35 @@
+import numpy as np
+from skimage.morphology import medial_axis, area_closing
+from PIL import Image
+from retinal_thin_vessels.external.DSE_skeleton_pruning.dsepruning.dsepruning import skel_pruning_DSE
+
+def main():
+
+    seg_mask = np.array(Image.open("imgs/DRIVE_seg_example.png"))
+    print(seg_mask.shape)
+    exit(0)
+    # Application of closing on the segmentation mask
+    closed_seg_mask = area_closing(seg_mask)
+
+    # Obtaining the skeleton
+    skeleton_medial_axis, distances = medial_axis(closed_seg_mask, return_distance=True)
+
+    # Skeleton prunning
+    skeleton_medial_axis = skel_pruning_DSE(skeleton_medial_axis, distances, np.ceil(distances.max()))
+
+    # Compute the skeleton with the values of the distances
+    dist_skel = np.where(skeleton_medial_axis>0, distances, 0) 
+
+    # Get unique values of dist_skel excluding 0 (values of the radius of vessels)
+    values_dist_skel = np.unique(dist_skel)[1:] 
+
+    #~~~~~~~~~~~~~~~~~~~~~~~Segmentation mask recriation with thin vessels only~~~~~~~~~~~~~~~~~~
+
+    # Initializes the two necessary masks
+    filtered_seg_mask = np.zeros(dist_skel.shape)
+    reconstructed_seg_mask = np.zeros(dist_skel.shape)
+
+
+    exit(0)
+
+main()

retinal_thin_vessels-1.0/retinal_thin_vessels/input_transformation.py

@@ -0,0 +1,88 @@
+import torch
+import numpy as np
+from PIL import Image
+
+def _to_numpy(arr):
+    """
+    Converts torch.Tensor or PIL.Image 
+    to numpy array if needed.
+    """
+    if isinstance(arr, Image.Image):
+        arr = np.array(arr, copy=True)
+    elif isinstance(arr, torch.Tensor):
+        arr = arr.detach().cpu().numpy()
+    elif not isinstance(arr, np.ndarray):
+        raise TypeError(f"Unsupported input type: {type(arr)}")
+    return arr
+
+def _verify_input_validity(seg_mask, input_type="y_true"):
+    """
+    Inputs can be NumPy arrays, 
+    torch.Tensors, or PIL Images.
+
+    (1, H, W) or (N,1,H,W) or (H,W)
+    Inputs must have shape: (1, H, W), with values in {0, 1}, {0, 255}, 
+    or [0.0, 1.0] for probability maps.
+
+    Thin vessels are defined as those with radius less than or
+    equal to ceil.
+    """
+
+    seg_mask = _to_numpy(seg_mask)
+
+    # Ensures inputs have valid shape
+    if (int(seg_mask.ndim) not in [2,3,4]) or (seg_mask.ndim == 3 and seg_mask.shape[0] != 1) or (seg_mask.ndim == 4 and seg_mask.shape[1] != 1):
+        raise ValueError(f"Accepted shapes: (1, H, W) or (N,1,H,W) or (H,W). Got seg_mask: {seg_mask.shape} for {input_type}")
+
+    # Verifies the validity of the values in the passed array
+    input_values = np.unique(seg_mask)
+    
+    if len(input_values) != 2:
+        raise ValueError(f"Expected binary input for {input_type}. Got input values: {input_values}")
+    
+    # Binarize input if necessary
+    if (input_type == "y_true" and int(input_values[0]) != 0) or (input_type == "y_pred" and int(input_values[0]) != 0):
+            seg_mask = (seg_mask - seg_mask.min())/(seg_mask.max()-seg_mask.min())
+
+    return seg_mask
+
+def prepare_ground_truth(y_true):
+
+    # Verifies validity of y_true
+    y_true = _verify_input_validity(y_true, "y_true")
+
+    # # Removes the channel dimension for input of shape [1,H,W]
+    # if y_true.ndim == 3:
+    #     y_true = y_true[0] #[1,H,W] ---> [H,W]
+
+    # Ensures the values belong to {0,1}
+    y_true = (y_true > 0).astype(np.uint8)
+
+    return y_true
+
+def prepare_prediction(y_pred):
+
+    # Verifies validity of y_true
+    y_pred = _verify_input_validity(y_pred, "y_pred")
+
+    # # Removes the channel dimension for input of shape [1,H,W]
+    # if y_pred.ndim == 3:
+    #     y_pred = y_pred[0] #[1,H,W] ---> [H,W]
+    
+    # Ensures the values belong to {0,1}
+    y_pred = (y_pred > 0.5).astype(np.uint8)
+
+    return y_pred
+
+def prepare_input(y_true, y_pred):
+    
+    # Prepare both inputs
+    y_true, y_pred = prepare_ground_truth(y_true), prepare_prediction(y_pred)
+
+    # Ensures inputs have the same dimensions (Height and Width)
+    # if (y_true.shape[-1] != y_pred.shape[-1] or y_true.shape[-2] != y_pred.shape[-2]):
+    if y_true.shape != y_pred.shape:
+        raise ValueError(f"Expected both inputs to have the same dimensions. Got  y_true: {y_true.shape}, y_pred: {y_pred.shape}")
+
+
+    return y_true, y_pred

retinal_thin_vessels-1.0/retinal_thin_vessels/metrics.py

@@ -0,0 +1,172 @@
+import numpy as np
+from PIL import Image
+from retinal_thin_vessels.core import get_thin_vessels_mask
+from retinal_thin_vessels.input_transformation import prepare_input
+import time
+
+def __recall_thin_vessels_single_image(y_true, y_pred, ceil=1.0):
+
+    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Input preparation~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    
+    true_copy, pred_copy = prepare_input(y_true, y_pred)
+
+    new_seg_true = get_thin_vessels_mask(true_copy, ceil)
+
+    # Calculates Recall
+    tp = np.sum((new_seg_true > 0) & (pred_copy > 0))
+    fn = np.sum((new_seg_true > 0) & (pred_copy == 0))
+
+    return tp/(tp+fn)
+
+def __precision_thin_vessels_single_image(y_true, y_pred, ceil=1.0):
+
+    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Input preparation~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    true_copy, pred_copy = prepare_input(y_true, y_pred)
+
+    new_seg_pred = get_thin_vessels_mask(pred_copy, ceil)
+
+    # Calculates Precision
+    tp = np.sum((new_seg_pred > 0) & (true_copy > 0))
+    fp = np.sum((new_seg_pred > 0) & (true_copy == 0))
+
+    return tp/(tp+fp)
+
+def __f1_thin_vessels_single_image(y_true, y_pred, ceil=1.0):
+
+    r = __recall_thin_vessels_single_image(y_true, y_pred, ceil)
+    p = __precision_thin_vessels_single_image(y_true, y_pred, ceil)
+    f1 = 2*p*r/(p+r)
+
+    return f1
+
+def recall_thin_vessels(y_true, y_pred, ceil=1.0):
+    """
+    Returns the recall score on thin vessels given the predicted and
+    the ground-truth segmentation masks. Inputs can be NumPy arrays, 
+    torch.Tensors, or PIL Images.
+
+    Inputs must have shape: (1, H, W), with values in {0, 1}, {0, 255}, 
+    or [0.0, 1.0] for probability maps.
+
+    Thin vessels are defined as those whose radius is less than or
+    equal to 'ceil'.
+    """
+    # Prepares the input
+
+    y_true, y_pred = prepare_input(y_true, y_pred)
+    
+    # Computes the metric
+    inputs_dimension = y_true.ndim
+    num_imgs = len(y_true)
+
+    if inputs_dimension == 4:
+        recall = 0
+        for i in range(num_imgs):
+            recall+=__recall_thin_vessels_single_image(y_true[i][0], y_pred[i][0], ceil)
+        recall/=num_imgs
+    
+    else:
+        if inputs_dimension == 3:
+            y_true = y_true[0]
+            y_pred = y_pred[0]
+        
+        recall = __recall_thin_vessels_single_image(y_true, y_pred, ceil)
+    
+    return recall
+
+def precision_thin_vessels(y_true, y_pred, ceil=1.0):
+    """
+    Returns the precision score on thin vessels given the predicted and
+    the ground-truth segmentation masks. Inputs can be NumPy arrays, 
+    torch.Tensors, or PIL Images.
+
+    Inputs must have shape: (1, H, W), with values in {0, 1}, {0, 255}, 
+    or [0.0, 1.0] for probability maps.
+
+    Thin vessels are defined as those whose radius is less than or
+    equal to 'ceil'.
+    """
+
+    # Prepares the input
+    
+    y_true, y_pred = prepare_input(y_true, y_pred)
+
+    # Computes the metric
+    inputs_dimension = y_true.ndim
+    num_imgs = len(y_true)
+
+    if inputs_dimension == 4:
+        precision = 0
+        for i in range(num_imgs):
+            precision+=__precision_thin_vessels_single_image(y_true[i][0], y_pred[i][0], ceil)
+        precision/=num_imgs
+    
+    else:
+        if inputs_dimension == 3:
+            y_true = y_true[0]
+            y_pred = y_pred[0]
+        
+        precision = __precision_thin_vessels_single_image(y_true, y_pred, ceil)
+    
+    return precision
+
+
+def f1_thin_vessels(y_true, y_pred, ceil):
+    """
+    Returns the f1-score on thin vessels given the predicted and
+    the ground-truth segmentation masks. Inputs can be NumPy arrays, 
+    torch.Tensors, or PIL Images.
+
+    Inputs must have shape: (1, H, W), with values in {0, 1}, {0, 255}, 
+    or [0.0, 1.0] for probability maps.
+
+    Thin vessels are defined as those whose radius is less than or
+    equal to 'ceil'.
+    """
+    # Prepares the input
+    y_true, y_pred = prepare_input(y_true, y_pred)
+
+    # Computes the metric
+    inputs_dimension = y_true.ndim
+    num_imgs = len(y_true)
+
+    if inputs_dimension == 4:
+        f1 = 0
+        for i in range(num_imgs):
+            f1 += __f1_thin_vessels_single_image(y_true[i][0], y_pred[i][0], ceil)
+
+        f1 /= num_imgs
+    
+    else:
+        if inputs_dimension == 3:
+            y_true = y_true[0]
+            y_pred = y_pred[0]
+        
+        f1 = __f1_thin_vessels_single_image(y_true, y_pred, ceil)
+    
+    return f1
+
+
+def main():
+
+    example_components_path = "../tests/imgs/"   
+    seg = Image.open(f"{example_components_path}DRIVE_seg_example.png")
+    pred = Image.open(f"{example_components_path}DRIVE_pred_example.png")
+    
+    ti = time.time()
+    print(f"Precision on thin vessels: {precision_thin_vessels(seg.resize(pred.size, Image.NEAREST), pred)}")
+    tf = time.time()
+    delta = tf-ti
+    print(f"Running time for image of shape {seg.size}: {delta:.4f} sec")
+
+    ti = time.time()
+    print(f"Recall on thin vessels: {recall_thin_vessels(seg.resize(pred.size, Image.NEAREST), pred)}")
+    tf = time.time()
+    delta = tf-ti
+    print(f"Running time for image of shape {seg.size}: {delta:.4f} sec")
+    exit(0)
+
+
+if __name__ == "__main__":
+    main()

retinal_thin_vessels-1.0/retinal_thin_vessels.egg-info/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: retinal_thin_vessels
+Version: 1.0
+Summary: A Python package for analyzing thin retinal vessels and creating vessels-thickness based weight maps
+Author-email: João Paulo Menezes Linaris <joaolinaris@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/J-Linaris/retinal_thin_vessels
+Project-URL: Repository, https://github.com/J-Linaris/retinal_thin_vessels
+Keywords: retina,retinal,retinal-vessels,vessel-segmentation,image-analysis,medical-imaging,deep-learning,weight-map,pytorch,thin-vessels,image-segmentation,binary-masks,binary-mask
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: torch
+Requires-Dist: scikit-image
+Requires-Dist: Pillow
+Dynamic: license-file
+
+# retinal_thin_vessels
+
+A Python package for computing the recall and precision scores specifically on thin vessels in retinal images, as detailed in the paper "Vessel-Width-Based Metrics and Weight Masks for Retinal Blood Vessel Segmentation", published in WUW-SIBGRAPI 2025. The package also includes a function for visualizing thickness-based filtered masks, the basic structure for computing the proposed metrics.
+
+## Package installation
+
+```bash
+pip install retinal_thin_vessels
+```
+
+## Usage Demonstration with DRIVE and CHASEDB1
+
+To ensure the metrics are reliable, it is important to visualize the specific thin-vessel mask used by the given functions in their calculations. Therefore, a core function, get_thin_vessels_mask(), is also provided. This function takes a standard segmentation mask and returns a new mask containing only the thin vessels.
+
+The following code demonstrates how to generate this filtered mask using images from two public datasets: DRIVE and CHASEDB1.
+
+```python
+from PIL import Image
+from retinal_thin_vessels.core import get_thin_vessels_mask
+from retinal_thin_vessels.metrics import recall_thin_vessels, precision_thin_vessels
+from sklearn.metrics import recall_score, precision_score
+```
+
+```python
+# Import the original segmentation masks
+seg_DRIVE = Image.open(f"tests/imgs/DRIVE_seg_example.png")
+seg_CDB1 = Image.open(f"tests/imgs/CHASEDB1_seg_example.png")
+
+# generates new masks containing only thin vessels
+thin_vessels_seg_DRIVE = get_thin_vessels_mask(seg_DRIVE)
+thin_vessels_seg_CDB1 = get_thin_vessels_mask(seg_CDB1)
+
+# Display the original segmentation mask and the resulting thin-vessel-only mask for comparison
+seg_DRIVE.show()
+img_DRIVE = Image.fromarray(thin_vessels_seg_DRIVE)
+img_DRIVE.show()
+
+seg_CDB1.show()
+img_CDB1 = Image.fromarray(thin_vessels_seg_CDB1)
+img_CDB1.show()
+```
+<img src="tests/imgs/DRIVE_seg_example.png" alt="DRIVE_thin_vessels_example" width=300/>
+<img src="tests/imgs/DRIVE_seg_thin_example.png" alt="DRIVE_thin_vessels_example" width=300/>
+<img src="tests/imgs/CHASEDB1_seg_example.png" alt="CHASEDB1_thin_vessels_example" width=300/>
+<img src="tests/imgs/CHASEDB1_seg_thin_example.png" alt="CHASEDB1_thin_vessels_example" width=300/>
+
+Furthermore, to demonstrate the metric calculation functions, you can run the code below. It compares the overall metrics (calculated with scikit-learn) to the thin-vessel-specific metrics calculated by this package.
+
+```python
+# Load the ground truth segmentation mask and a sample prediction
+pred = Image.open(f"tests/imgs/DRIVE_pred_example.png")
+seg_DRIVE = Image.open(f"tests/imgs/DRIVE_seg_example.png").resize((pred.size), Image.NEAREST)
+
+# Binarize images to a 0/1 format for scikit-learn compatibility
+seg_DRIVE = np.where(np.array(seg_DRIVE) > 0, 1, 0)
+pred = np.where(np.array(pred) > 0, 1, 0)
+
+# Compute and print the metrics
+print(f"Overall Recall score: {recall_score(seg_DRIVE.flatten(), pred.flatten())}")
+print(f"Recall score on thin vessels: {recall_thin_vessels(seg_DRIVE, pred)}")
+print("-" * 30)
+print(f"Overall Precision score: {precision_score(seg_DRIVE.flatten(), pred.flatten())}")
+print(f"Precision score on thin Vessels: {precision_thin_vessels(seg_DRIVE, pred)}")
+```
+
+If the program is running correctly with the provided sample images, the results should be similar to this:
+
+```bash
+Overall Recall score: 0.8553852359822509
+Recall score on thin vessels: 0.751244555071562
+------------------------------
+Overall Precision score: 0.8422369623068674
+Precision score on thin Vessels: 0.6527915897144481
+```

retinal_thin_vessels-1.0/retinal_thin_vessels.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+retinal_thin_vessels/__init__.py
+retinal_thin_vessels/core.py
+retinal_thin_vessels/get_relation.py
+retinal_thin_vessels/input_transformation.py
+retinal_thin_vessels/metrics.py
+retinal_thin_vessels.egg-info/PKG-INFO
+retinal_thin_vessels.egg-info/SOURCES.txt
+retinal_thin_vessels.egg-info/dependency_links.txt
+retinal_thin_vessels.egg-info/requires.txt
+retinal_thin_vessels.egg-info/top_level.txt
+retinal_thin_vessels/external/DSE_skeleton_pruning/setup.py
+retinal_thin_vessels/external/DSE_skeleton_pruning/dsepruning/__init__.py
+retinal_thin_vessels/external/DSE_skeleton_pruning/dsepruning/dsepruning.py
+tests/tests.py

retinal_thin_vessels-1.0/retinal_thin_vessels.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

retinal_thin_vessels-1.0/retinal_thin_vessels.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+torch
+scikit-image
+Pillow

retinal_thin_vessels-1.0/retinal_thin_vessels.egg-info/top_level.txt

@@ -0,0 +1 @@
+retinal_thin_vessels

retinal_thin_vessels-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

retinal_thin_vessels-1.0/tests/tests.py

@@ -0,0 +1,57 @@
+from PIL import Image
+from retinal_thin_vessels.metrics import recall_thin_vessels, precision_thin_vessels
+from retinal_thin_vessels.core import get_thin_vessels_mask
+import numpy as np
+from sklearn.metrics import recall_score, precision_score
+
+def main():
+
+    example_components_path = "imgs/"   
+    # DRIVE IMAGES
+    seg = Image.open(f"{example_components_path}DRIVE_seg_example.png")
+    pred = Image.open(f"{example_components_path}DRIVE_pred_example.png")
+    
+    # # Gets the filtered mask with only thin vessels
+    # thin_vessels_seg = get_thin_vessels_mask(seg)
+    
+    # print("Showing the filtered segmentation mask with thin vessels only. DRIVE")
+    # img = Image.fromarray(thin_vessels_seg)
+    # # img.show()
+    # img.save("DRIVE_seg_thin_example.png")
+
+    # # CHASEDB1 IMAGES
+    # seg = Image.open(f"{example_components_path}CHASEDB1_seg_example.png")
+    
+    # # Gets the filtered mask with only thin vessels
+    # thin_vessels_seg = get_thin_vessels_mask(seg)
+    
+    # print("Showing the filtered segmentation mask with thin vessels only. CHASEDB1")
+    # img = Image.fromarray(thin_vessels_seg)
+    # # img.show()
+    # img.save("CHASEDB1_seg_thin_example.png")
+
+    print(np.array(seg.resize(pred.size, Image.NEAREST)).shape)
+    print(np.array(pred).shape)
+    print(np.unique(np.array(seg.resize(pred.size, Image.NEAREST)).astype(np.uint8)))
+    print(np.unique((np.array(pred)/255).astype(np.uint8)))
+
+    # Load the ground truth segmentation mask and a sample prediction
+    pred = Image.open(f"imgs/DRIVE_pred_example.png")
+    seg_DRIVE = seg.resize((pred.size), Image.NEAREST)
+
+    # Binarize images to a 0/1 format for scikit-learn compatibility
+    seg_DRIVE = np.where(np.array(seg_DRIVE) > 0, 1, 0)
+    pred = np.where(np.array(pred) > 0, 1, 0)
+
+    # Compute and print the metrics
+    print(f"Overall Recall score: {recall_score(seg_DRIVE.flatten(), pred.flatten())}")
+    print(f"Recall score on thin vessels: {recall_thin_vessels(seg_DRIVE, pred)}")
+    print("-" * 30)
+    print(f"Overall Precision score: {precision_score(seg_DRIVE.flatten(), pred.flatten())}")
+    print(f"Precision score on thin Vessels: {precision_thin_vessels(seg_DRIVE, pred)}")
+    
+    exit(0)
+
+
+if __name__ == "__main__":
+    main()