Upload 72 files

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+examples/all.jpg filter=lfs diff=lfs merge=lfs -text
+examples/DRIVE.tif filter=lfs diff=lfs merge=lfs -text
+examples/hrf.png filter=lfs diff=lfs merge=lfs -text
+examples/LES.png filter=lfs diff=lfs merge=lfs -text
+examples/tmp_upload.png filter=lfs diff=lfs merge=lfs -text
+examples/ukbb.png filter=lfs diff=lfs merge=lfs -text

AV/Tools/AVclassifiation.py

@@ -0,0 +1,202 @@
+import cv2
+import numpy as np
+import os
+# import natsort
+import pandas as pd
+from skimage.morphology import skeletonize, erosion, square,dilation
+from AV.Tools.BinaryPostProcessing import binaryPostProcessing3
+from PIL import Image
+from scipy.signal import convolve2d
+from collections import OrderedDict
+import time
+#########################################
+
+
+
+
+def Skeleton(a_or_v, a_and_v):
+    th = np.uint8(a_and_v)
+    # Distance transform for maximum diameter
+    vessels = th.copy()
+    dist = cv2.distanceTransform(a_or_v, cv2.DIST_L2, 3)  
+    thinned = np.uint8(skeletonize((vessels / 255))) * 255
+    return thinned, dist
+
+
+def cal_crosspoint(vessel):
+    # Removing bifurcation points by using specially designed kernels
+    # Can be optimized further! (not the best implementation)
+    thinned1, dist = Skeleton(vessel, vessel)
+    thh = thinned1.copy()
+    thh = thh / 255
+    kernel1 = np.array([[1, 1, 1], [1, 10, 1], [1, 1, 1]])
+
+    th = convolve2d(thh, kernel1, mode="same")
+    for u in range(th.shape[0]):
+        for j in range(th.shape[1]):
+            if th[u, j] >= 13.0:
+                cv2.circle(vessel, (j, u), 2 * int(dist[u, j]), (0, 0, 0), -1)
+    # thi = cv2.cvtColor(thi, cv2.COLOR_BGR2GRAY)
+    return vessel
+
+
+def AVclassifiation(out_path, PredAll1, PredAll2, VesselPredAll, DataSet=0, image_basename=''):
+    """
+    predAll1: predition results of artery
+    predAll2: predition results of vein
+    VesselPredAll: predition results of vessel
+    DataSet: the length of dataset
+    image_basename: the name of saved mask
+    """
+
+    ImgN = DataSet
+
+    for ImgNumber in range(ImgN):
+
+        height, width = PredAll1.shape[2:4]
+
+        VesselProb = VesselPredAll[ImgNumber, 0, :, :]
+
+        ArteryProb = PredAll1[ImgNumber, 0, :, :]
+        VeinProb = PredAll2[ImgNumber, 0, :, :]
+
+        VesselSeg = (VesselProb >= 0.1) & ((ArteryProb >0.2) | (VeinProb > 0.2))
+        # VesselSeg = (VesselProb >= 0.5) & ((ArteryProb >= 0.5) | (VeinProb >= 0.5))
+        crossSeg = (VesselProb >= 0.1) & ((ArteryProb >= 0.6) & (VeinProb >= 0.6))
+        VesselSeg = binaryPostProcessing3(VesselSeg, removeArea=100, fillArea=20)
+
+        vesselPixels = np.where(VesselSeg > 0)
+
+        ArteryProb2 = np.zeros((height, width))
+        VeinProb2 = np.zeros((height, width))
+        crossProb2 = np.zeros((height, width))
+        image_color = np.zeros((3, height, width), dtype=np.uint8)
+        for i in range(len(vesselPixels[0])):
+            row = vesselPixels[0][i]
+            col = vesselPixels[1][i]
+            probA = ArteryProb[row, col]
+            probV = VeinProb[row, col]
+            #probA,probV = softmax([probA,probV])
+            ArteryProb2[row, col] = probA
+            VeinProb2[row, col] = probV
+
+        test_use_vessel = np.zeros((height, width), np.uint8)
+        ArteryPred2 = ((ArteryProb2 >= 0.2) & (ArteryProb2 >= VeinProb2))
+        VeinPred2 = ((VeinProb2 >= 0.2) & (VeinProb2 >= ArteryProb2))
+
+        ArteryPred2 = binaryPostProcessing3(ArteryPred2, removeArea=100, fillArea=20)
+        VeinPred2 = binaryPostProcessing3(VeinPred2, removeArea=100, fillArea=20)
+
+        image_color[0, :, :] = ArteryPred2 * 255
+        image_color[2, :, :] = VeinPred2 * 255
+        image_color = image_color.transpose((1, 2, 0))
+
+        #Image.fromarray(image_color).save(os.path.join(out_path, f'{image_basename[ImgNumber].split(".")[0]}_ori.png'))
+
+        imgBin_vessel = ArteryPred2 + VeinPred2
+        imgBin_vessel[imgBin_vessel[:, :] == 2] = 1
+        test_use_vessel = imgBin_vessel.copy() * 255
+
+        vessel = cal_crosspoint(test_use_vessel)
+
+        contours_vessel, hierarchy_c = cv2.findContours(vessel, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+
+        # inter continuity
+        for vessel_seg in range(len(contours_vessel)):
+            C_vessel = np.zeros(vessel.shape, np.uint8)
+            C_vessel = cv2.drawContours(C_vessel, contours_vessel, vessel_seg, (255, 255, 255), cv2.FILLED)
+            cli = np.mean(VeinProb2[C_vessel == 255]) / np.mean(ArteryProb2[C_vessel == 255])
+            if cli < 1:
+                image_color[
+                    (C_vessel[:, :] == 255) & (test_use_vessel[:, :] == 255)] = [255, 0, 0]
+            else:
+                image_color[
+                    (C_vessel[:, :] == 255) & (test_use_vessel[:, :] == 255)] = [0, 0, 255]
+        loop=0
+        while loop<2:
+            # out vein continuity
+            vein = image_color[:, :, 2]
+            contours_vein, hierarchy_b = cv2.findContours(vein, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+
+            vein_size = []
+            for z in range(len(contours_vein)):
+                vein_size.append(contours_vein[z].size)
+            vein_size = np.sort(np.array(vein_size))
+            # image_color_copy = np.uint8(image_color).copy()
+            for vein_seg in range(len(contours_vein)):
+                judge_number = min(np.mean(vein_size),500)
+                # cv2.putText(image_color_copy, str(vein_seg), (int(contours_vein[vein_seg][0][0][0]), int(contours_vein[vein_seg][0][0][1])), 3, 1,
+                #             color=(255, 0, 0), thickness=2)
+                if contours_vein[vein_seg].size < judge_number:
+                    C_vein = np.zeros(vessel.shape, np.uint8)
+                    C_vein = cv2.drawContours(C_vein, contours_vein, vein_seg, (255, 255, 255), cv2.FILLED)
+                    max_diameter = np.max(Skeleton(C_vein, C_vein)[1])
+
+                    image_color_copy_vein = image_color[:, :, 2].copy()
+                    image_color_copy_arter = image_color[:, :, 0].copy()
+                    # a_ori = cv2.drawContours(a_ori, contours_b, k, (0, 0, 0), cv2.FILLED)
+                    image_color_copy_vein = cv2.drawContours(image_color_copy_vein, contours_vein, vein_seg,
+                                                             (0, 0, 0),
+                                                             cv2.FILLED)
+                    # image_color[(C_cross[:, :] == 255) & (image_color[:, :, 1] == 255)] = [255, 0, 0]
+                    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (
+                        4 * int(np.ceil(max_diameter)), 4 * int(np.ceil(max_diameter))))
+                    C_vein_dilate = cv2.dilate(C_vein, kernel, iterations=1)
+                    # cv2.imwrite(path_out_3, C_vein_dilate)
+                    C_vein_dilate_judge = np.zeros(vessel.shape, np.uint8)
+                    C_vein_dilate_judge[
+                        (C_vein_dilate[:, :] == 255) & (image_color_copy_vein == 255)] = 1
+                    C_arter_dilate_judge = np.zeros(vessel.shape, np.uint8)
+                    C_arter_dilate_judge[
+                        (C_vein_dilate[:, :] == 255) & (image_color_copy_arter == 255)] = 1
+                    if (len(np.unique(C_vein_dilate_judge)) == 1) & (
+                            len(np.unique(C_arter_dilate_judge)) != 1) & (np.mean(VeinProb2[C_vein == 255]) < 0.6):
+                        image_color[
+                            (C_vein[:, :] == 255) & (image_color[:, :, 2] == 255)] = [255, 0,
+                                                                                      0]
+
+            # out artery continuity
+            arter = image_color[:, :, 0]
+            contours_arter, hierarchy_a = cv2.findContours(arter, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+            arter_size = []
+            for z in range(len(contours_arter)):
+                arter_size.append(contours_arter[z].size)
+            arter_size = np.sort(np.array(arter_size))
+            for arter_seg in range(len(contours_arter)):
+                judge_number = min(np.mean(arter_size),500)
+
+                if contours_arter[arter_seg].size < judge_number:
+
+                    C_arter = np.zeros(vessel.shape, np.uint8)
+                    C_arter = cv2.drawContours(C_arter, contours_arter, arter_seg, (255, 255, 255), cv2.FILLED)
+                    max_diameter = np.max(Skeleton(C_arter, test_use_vessel)[1])
+
+                    image_color_copy_vein = image_color[:, :, 2].copy()
+                    image_color_copy_arter = image_color[:, :, 0].copy()
+                    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (
+                        4 * int(np.ceil(max_diameter)), 4 * int(np.ceil(max_diameter))))
+                    image_color_copy_arter = cv2.drawContours(image_color_copy_arter, contours_arter, arter_seg,
+                                                              (0, 0, 0),
+                                                              cv2.FILLED)
+                    C_arter_dilate = cv2.dilate(C_arter, kernel, iterations=1)
+                    # image_color[(C_cross[:, :] == 255) & (image_color[:, :, 1] == 255)] = [255, 0, 0]
+                    C_arter_dilate_judge = np.zeros(arter.shape, np.uint8)
+                    C_arter_dilate_judge[
+                        (C_arter_dilate[:, :] == 255) & (image_color_copy_arter[:, :] == 255)] = 1
+                    C_vein_dilate_judge = np.zeros(arter.shape, np.uint8)
+                    C_vein_dilate_judge[
+                        (C_arter_dilate[:, :] == 255) & (image_color_copy_vein[:, :] == 255)] = 1
+
+                    if (len(np.unique(C_arter_dilate_judge)) == 1) & (
+                            len(np.unique(C_vein_dilate_judge)) != 1) & (np.mean(ArteryProb2[C_arter == 255]) < 0.6):
+                        image_color[
+                            (C_arter[:, :] == 255) & (image_color[:, :, 0] == 255)] = [0,
+                                                                                       0,
+                                                                                       255]
+            loop=loop+1
+
+        # image_basename = os.path.basename(image_basename)
+        # Image.fromarray(image_color).save(os.path.join(out_path, f'{image_basename.split(".")[0]}.png'))
+        # Image.fromarray(np.uint8(VesselProb*255)).save(os.path.join(out_path, f'{image_basename.split(".")[0]}_vessel.png'))
+    return image_color
+        

AV/Tools/AVclassifiationMetrics.py

@@ -0,0 +1,465 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+# import natsort
+import pandas as pd
+from skimage import morphology
+from sklearn import metrics
+from Tools.BinaryPostProcessing import binaryPostProcessing3
+from PIL import Image
+from scipy.signal import convolve2d
+import time
+
+#########################################
+def softmax(x):
+    e_x = np.exp(x - np.max(x))
+    return e_x / e_x.sum()
+
+
+def Skeleton(a_or_v, a_and_v):
+    th = np.uint8(a_and_v)
+    # Distance transform for maximum diameter
+    vessels = th.copy()
+    dist = cv2.distanceTransform(a_or_v, cv2.DIST_L2, 3)  
+    thinned = np.uint8(morphology.skeletonize((vessels / 255))) * 255
+    return thinned, dist
+
+
+def cal_crosspoint(vessel):
+    # Removing bifurcation points by using specially designed kernels
+    # Can be optimized further! (not the best implementation)
+    thinned1, dist = Skeleton(vessel, vessel)
+    thh = thinned1.copy()
+    thh = thh / 255
+    kernel1 = np.array([[1, 1, 1], [1, 10, 1], [1, 1, 1]])
+
+    th = convolve2d(thh, kernel1, mode="same")
+    for u in range(th.shape[0]):
+        for j in range(th.shape[1]):
+            if th[u, j] >= 13.0:
+                cv2.circle(vessel, (j, u), 3 * int(dist[u, j]), (0, 0, 0), -1)
+    # thi = cv2.cvtColor(thi, cv2.COLOR_BGR2GRAY)
+    return vessel
+
+
+
+def AVclassifiation_pos_ve(out_path, PredAll1, PredAll2, VesselPredAll, DataSet=0, image_basename=''):
+    """
+    predAll1: predition results of artery
+    predAll2: predition results of vein
+    VesselPredAll: predition results of vessel
+    DataSet: the length of dataset
+    image_basename: the name of saved mask
+    """
+
+    ImgN = DataSet
+
+    for ImgNumber in range(ImgN):
+
+        height, width = PredAll1.shape[2:4]
+
+        VesselProb = VesselPredAll[ImgNumber, 0, :, :]
+
+        ArteryProb = PredAll1[ImgNumber, 0, :, :]
+        VeinProb = PredAll2[ImgNumber, 0, :, :]
+
+        VesselSeg = (VesselProb >= 0.1) & ((ArteryProb >= 0.2) | (VeinProb >= 0.2))
+        # VesselSeg = (VesselProb >= 0.5) & ((ArteryProb >= 0.5) | (VeinProb >= 0.5))
+        crossSeg = (VesselProb >= 0.1) & ((ArteryProb >= 0.6) & (VeinProb >= 0.6))
+        VesselSeg = binaryPostProcessing3(VesselSeg, removeArea=100, fillArea=20)
+
+        vesselPixels = np.where(VesselSeg > 0)
+
+        ArteryProb2 = np.zeros((height, width))
+        VeinProb2 = np.zeros((height, width))
+        crossProb2 = np.zeros((height, width))
+        image_color = np.zeros((3, height, width), dtype=np.uint8)
+        for i in range(len(vesselPixels[0])):
+            row = vesselPixels[0][i]
+            col = vesselPixels[1][i]
+            probA = ArteryProb[row, col]
+            probV = VeinProb[row, col]
+            ArteryProb2[row, col] = probA
+            VeinProb2[row, col] = probV
+
+        test_use_vessel = np.zeros((height, width), np.uint8)
+        ArteryPred2 = ((ArteryProb2 >= 0.2) & (ArteryProb2 > VeinProb2))
+        VeinPred2 = ((VeinProb2 >= 0.2) & (VeinProb2 > ArteryProb2))
+
+        ArteryPred2 = binaryPostProcessing3(ArteryPred2, removeArea=100, fillArea=20)
+        VeinPred2 = binaryPostProcessing3(VeinPred2, removeArea=100, fillArea=20)
+
+        image_color[0, :, :] = ArteryPred2 * 255
+        image_color[2, :, :] = VeinPred2 * 255
+        image_color = image_color.transpose((1, 2, 0))
+
+        imgBin_vessel = ArteryPred2 + VeinPred2
+        imgBin_vessel[imgBin_vessel[:, :] == 2] = 1
+        test_use_vessel = imgBin_vessel.copy() * 255
+
+        vessel = cal_crosspoint(test_use_vessel)
+
+        contours_vessel, hierarchy_c = cv2.findContours(vessel, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+
+        # inter continuity
+        for vessel_seg in range(len(contours_vessel)):
+            C_vessel = np.zeros(vessel.shape, np.uint8)
+            C_vessel = cv2.drawContours(C_vessel, contours_vessel, vessel_seg, (255, 255, 255), cv2.FILLED)
+            cli = np.mean(VeinProb2[C_vessel == 255]) / np.mean(ArteryProb2[C_vessel == 255])
+            if cli < 1:
+                image_color[
+                    (C_vessel[:, :] == 255) & (test_use_vessel[:, :] == 255)] = [255, 0, 0]
+            else:
+                image_color[
+                    (C_vessel[:, :] == 255) & (test_use_vessel[:, :] == 255)] = [0, 0, 255]
+
+
+        Image.fromarray(image_color).save(os.path.join(out_path, f'{image_basename[ImgNumber].split(".")[0]}.png'))
+
+
+def AVclassifiation(out_path, PredAll1, PredAll2, VesselPredAll, DataSet=0, image_basename=''):
+    """
+    predAll1: predition results of artery
+    predAll2: predition results of vein
+    VesselPredAll: predition results of vessel
+    DataSet: the length of dataset
+    image_basename: the name of saved mask
+    """
+
+    ImgN = DataSet
+
+    for ImgNumber in range(ImgN):
+
+        height, width = PredAll1.shape[2:4]
+
+        VesselProb = VesselPredAll[ImgNumber, 0, :, :]
+
+        ArteryProb = PredAll1[ImgNumber, 0, :, :]
+        VeinProb = PredAll2[ImgNumber, 0, :, :]
+
+        VesselSeg = (VesselProb >= 0.1) & ((ArteryProb >= 0.2) | (VeinProb >= 0.2))
+        # VesselSeg = (VesselProb >= 0.5) & ((ArteryProb >= 0.5) | (VeinProb >= 0.5))
+        crossSeg = (VesselProb >= 0.1) & ((ArteryProb >= 0.6) & (VeinProb >= 0.6))
+        VesselSeg = binaryPostProcessing3(VesselSeg, removeArea=100, fillArea=20)
+
+        vesselPixels = np.where(VesselSeg > 0)
+
+        ArteryProb2 = np.zeros((height, width))
+        VeinProb2 = np.zeros((height, width))
+        crossProb2 = np.zeros((height, width))
+        image_color = np.zeros((3, height, width), dtype=np.uint8)
+        for i in range(len(vesselPixels[0])):
+            row = vesselPixels[0][i]
+            col = vesselPixels[1][i]
+            probA = ArteryProb[row, col]
+            probV = VeinProb[row, col]
+            ArteryProb2[row, col] = probA
+            VeinProb2[row, col] = probV
+
+        test_use_vessel = np.zeros((height, width), np.uint8)
+        ArteryPred2 = ((ArteryProb2 >= 0.2) & (ArteryProb2 > VeinProb2))
+        VeinPred2 = ((VeinProb2 >= 0.2) & (VeinProb2 > ArteryProb2))
+
+        ArteryPred2 = binaryPostProcessing3(ArteryPred2, removeArea=100, fillArea=20)
+        VeinPred2 = binaryPostProcessing3(VeinPred2, removeArea=100, fillArea=20)
+
+        image_color[0, :, :] = ArteryPred2 * 255
+        image_color[2, :, :] = VeinPred2 * 255
+        image_color = image_color.transpose((1, 2, 0))
+
+        imgBin_vessel = ArteryPred2 + VeinPred2
+        imgBin_vessel[imgBin_vessel[:, :] == 2] = 1
+        test_use_vessel = imgBin_vessel.copy() * 255
+
+        vessel = cal_crosspoint(test_use_vessel)
+
+        contours_vessel, hierarchy_c = cv2.findContours(vessel, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+
+        # inter continuity
+        for vessel_seg in range(len(contours_vessel)):
+            C_vessel = np.zeros(vessel.shape, np.uint8)
+            C_vessel = cv2.drawContours(C_vessel, contours_vessel, vessel_seg, (255, 255, 255), cv2.FILLED)
+            cli = np.mean(VeinProb2[C_vessel == 255]) / np.mean(ArteryProb2[C_vessel == 255])
+            if cli < 1:
+                image_color[
+                    (C_vessel[:, :] == 255) & (test_use_vessel[:, :] == 255)] = [255, 0, 0]
+            else:
+                image_color[
+                    (C_vessel[:, :] == 255) & (test_use_vessel[:, :] == 255)] = [0, 0, 255]
+
+        # out vein continuity
+        vein = image_color[:, :, 2]
+        contours_vein, hierarchy_b = cv2.findContours(vein, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+
+        vein_size = []
+        for z in range(len(contours_vein)):
+            vein_size.append(contours_vein[z].size)
+        vein_size = np.sort(np.array(vein_size))
+        # image_color_copy = np.uint8(image_color).copy()
+        for vein_seg in range(len(contours_vein)):
+            judge_number = min(np.mean(vein_size),500)
+            # cv2.putText(image_color_copy, str(vein_seg), (int(contours_vein[vein_seg][0][0][0]), int(contours_vein[vein_seg][0][0][1])), 3, 1,
+            #             color=(255, 0, 0), thickness=2)
+            if contours_vein[vein_seg].size < judge_number:
+                C_vein = np.zeros(vessel.shape, np.uint8)
+                C_vein = cv2.drawContours(C_vein, contours_vein, vein_seg, (255, 255, 255), cv2.FILLED)
+                max_diameter = np.max(Skeleton(C_vein, C_vein)[1])
+
+                image_color_copy_vein = image_color[:, :, 2].copy()
+                image_color_copy_arter = image_color[:, :, 0].copy()
+                # a_ori = cv2.drawContours(a_ori, contours_b, k, (0, 0, 0), cv2.FILLED)
+                image_color_copy_vein = cv2.drawContours(image_color_copy_vein, contours_vein, vein_seg,
+                                                         (0, 0, 0),
+                                                         cv2.FILLED)
+                # image_color[(C_cross[:, :] == 255) & (image_color[:, :, 1] == 255)] = [255, 0, 0]
+                kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (
+                    4 * int(np.ceil(max_diameter)), 4 * int(np.ceil(max_diameter))))
+                C_vein_dilate = cv2.dilate(C_vein, kernel, iterations=1)
+                # cv2.imwrite(path_out_3, C_vein_dilate)
+                C_vein_dilate_judge = np.zeros(vessel.shape, np.uint8)
+                C_vein_dilate_judge[
+                    (C_vein_dilate[:, :] == 255) & (image_color_copy_vein == 255)] = 1
+                C_arter_dilate_judge = np.zeros(vessel.shape, np.uint8)
+                C_arter_dilate_judge[
+                    (C_vein_dilate[:, :] == 255) & (image_color_copy_arter == 255)] = 1
+                if (len(np.unique(C_vein_dilate_judge)) == 1) & (
+                        len(np.unique(C_arter_dilate_judge)) != 1) & (np.mean(VeinProb2[C_vein == 255]) < 0.5):
+                    image_color[
+                        (C_vein[:, :] == 255) & (image_color[:, :, 2] == 255)] = [255, 0,
+                                                                                  0]
+
+        # out artery continuity
+        arter = image_color[:, :, 0]
+        contours_arter, hierarchy_a = cv2.findContours(arter, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+        arter_size = []
+        for z in range(len(contours_arter)):
+            arter_size.append(contours_arter[z].size)
+        arter_size = np.sort(np.array(arter_size))
+        for arter_seg in range(len(contours_arter)):
+            judge_number = min(np.mean(arter_size),500)
+
+            if contours_arter[arter_seg].size < judge_number:
+
+                C_arter = np.zeros(vessel.shape, np.uint8)
+                C_arter = cv2.drawContours(C_arter, contours_arter, arter_seg, (255, 255, 255), cv2.FILLED)
+                max_diameter = np.max(Skeleton(C_arter, test_use_vessel)[1])
+
+                image_color_copy_vein = image_color[:, :, 2].copy()
+                image_color_copy_arter = image_color[:, :, 0].copy()
+                kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (
+                    4 * int(np.ceil(max_diameter)), 4 * int(np.ceil(max_diameter))))
+                image_color_copy_arter = cv2.drawContours(image_color_copy_arter, contours_arter, arter_seg,
+                                                          (0, 0, 0),
+                                                          cv2.FILLED)
+                C_arter_dilate = cv2.dilate(C_arter, kernel, iterations=1)
+                # image_color[(C_cross[:, :] == 255) & (image_color[:, :, 1] == 255)] = [255, 0, 0]
+                C_arter_dilate_judge = np.zeros(arter.shape, np.uint8)
+                C_arter_dilate_judge[
+                    (C_arter_dilate[:, :] == 255) & (image_color_copy_arter[:, :] == 255)] = 1
+                C_vein_dilate_judge = np.zeros(arter.shape, np.uint8)
+                C_vein_dilate_judge[
+                    (C_arter_dilate[:, :] == 255) & (image_color_copy_vein[:, :] == 255)] = 1
+
+                if (len(np.unique(C_arter_dilate_judge)) == 1) & (
+                        len(np.unique(C_vein_dilate_judge)) != 1) & (np.mean(VeinProb2[C_vein == 255]) < 0.5):
+                    image_color[
+                        (C_arter[:, :] == 255) & (image_color[:, :, 0] == 255)] = [0,
+                                                                                   0,
+                                                                                   255]
+
+        Image.fromarray(image_color).save(os.path.join(out_path, f'{image_basename[ImgNumber].split(".")[0]}.png'))
+
+
+
+def AVclassifiationMetrics_skeletonPixles(PredAll1,PredAll2,VesselPredAll,LabelAll1,LabelAll2,LabelVesselAll,DataSet=0, onlyMeasureSkeleton=False, strict_mode=True):
+    
+    """
+    predAll1: predition results of artery
+    predAll2: predition results of vein
+    VesselPredAll: predition results of vessel
+    LabelAll1: label of artery
+    LabelAll2: label of vein
+    LabelVesselAll: label of vessel
+    DataSet: the length of dataset
+    onlyMeasureSkeleton: measure skeleton
+    strict_mode: strict
+    """
+
+
+    ImgN = DataSet
+        
+    senList = []
+    specList = []
+    accList = []
+    f1List = []
+    ioulist = []
+    diceList = []
+
+
+
+    senList_sk = []
+    specList_sk = []
+    accList_sk = []
+    f1List_sk = []
+    ioulist_sk = []
+    diceList_sk = []
+
+    bad_case_count = 0
+    bad_case_index = []
+    
+    for ImgNumber in range(ImgN):
+        
+        height, width = PredAll1.shape[2:4]
+        
+    
+        VesselProb = VesselPredAll[ImgNumber, 0,:,:]
+        VesselLabel = LabelVesselAll[ImgNumber, 0, :, :]
+    
+    
+        ArteryLabel = LabelAll1[ImgNumber, 0, :, :]
+        VeinLabel = LabelAll2[ImgNumber, 0, :, :]
+    
+        ArteryProb = PredAll1[ImgNumber, 0,:,:]
+        VeinProb = PredAll2[ImgNumber, 0,:,:]
+        
+        if strict_mode:
+            VesselSeg = VesselLabel
+        else:
+            VesselSeg = (VesselProb >= 0.1) & ((ArteryProb >= 0.2) | (VeinProb >= 0.2))
+            VesselSeg= binaryPostProcessing3(VesselSeg, removeArea=100, fillArea=20)
+        
+        vesselPixels = np.where(VesselSeg>0)
+        
+        ArteryProb2 = np.zeros((height,width))
+        VeinProb2 = np.zeros((height,width))
+
+        for i in range(len(vesselPixels[0])):
+            row = vesselPixels[0][i]
+            col = vesselPixels[1][i]
+            probA = ArteryProb[row, col]
+            probV = VeinProb[row, col]
+            ArteryProb2[row, col] = probA
+            VeinProb2[row, col] = probV
+
+    
+        ArteryLabelImg2= ArteryLabel.copy()
+        VeinLabelImg2= VeinLabel.copy()
+        ArteryLabelImg2 [VesselSeg == 0] = 0
+        VeinLabelImg2 [VesselSeg == 0] = 0
+        ArteryVeinLabelImg = np.zeros((height, width,3), np.uint8)
+        ArteryVeinLabelImg[ArteryLabelImg2>0] = (255, 0, 0)
+        ArteryVeinLabelImg[VeinLabelImg2>0] = (0, 0, 255)
+        ArteryVeinLabelCommon = np.bitwise_and(ArteryLabelImg2>0, VeinLabelImg2>0)
+    
+        if strict_mode:
+            ArteryPred2 = ArteryProb2 > 0.5
+            VeinPred2 = VeinProb2 >= 0.5
+        else:
+            ArteryPred2 = (ArteryProb2 > 0.2) & (ArteryProb2>VeinProb2)
+            VeinPred2 = (VeinProb2 >= 0.2) &  (ArteryProb2<VeinProb2)
+
+        ArteryPred2= binaryPostProcessing3(ArteryPred2, removeArea=100, fillArea=20)
+        VeinPred2= binaryPostProcessing3(VeinPred2, removeArea=100, fillArea=20)
+
+        TPimg =  np.bitwise_and(ArteryPred2>0, ArteryLabelImg2>0) # 真实为动脉，预测为动脉
+        TNimg =  np.bitwise_and(VeinPred2>0, VeinLabelImg2>0) # 真实为静脉，预测为静脉
+        FPimg = np.bitwise_and(ArteryPred2>0, VeinLabelImg2>0) # 真实为静脉，预测为动脉
+        FPimg = np.bitwise_and(FPimg, np.bitwise_not(ArteryVeinLabelCommon))  # 真实为静脉，预测为动脉，且不属于动静脉共存区域
+    
+        FNimg = np.bitwise_and(VeinPred2>0, ArteryLabelImg2>0) # 真实为动脉，预测为静脉
+        FNimg = np.bitwise_and(FNimg, np.bitwise_not(ArteryVeinLabelCommon)) # 真实为动脉，预测为静脉，且不属于动静脉共存区域
+    
+    
+        if not onlyMeasureSkeleton:
+            TPa = np.count_nonzero(TPimg)
+            TNa = np.count_nonzero(TNimg)
+            FPa = np.count_nonzero(FPimg)
+            FNa = np.count_nonzero(FNimg)
+
+            sensitivity = TPa/(TPa+FNa)
+            specificity = TNa/(TNa + FPa)
+            acc = (TPa + TNa) /(TPa + TNa + FPa + FNa)
+            f1 = 2*TPa/(2*TPa + FPa + FNa)
+            dice = 2*TPa/(2*TPa + FPa + FNa)
+            iou = TPa/(TPa + FPa + FNa)
+            #print('Pixel-wise Metrics', acc, sensitivity, specificity)
+
+            senList.append(sensitivity)
+            specList.append(specificity)
+            accList.append(acc)
+            f1List.append(f1)
+            diceList.append(dice)
+            ioulist.append(iou)
+        # print('Avg Per:', np.mean(accList), np.mean(senList), np.mean(specList))
+    
+        ##################################################################################################
+        """Skeleton Performance Measurement"""
+        Skeleton = np.uint8(morphology.skeletonize(VesselSeg))
+        #np.save('./tmpfile/tmp_skeleton'+str(ImgNumber)+'.npy',Skeleton)
+
+        ArterySkeletonLabel = cv2.bitwise_and(ArteryLabelImg2, ArteryLabelImg2, mask=Skeleton)
+        VeinSkeletonLabel = cv2.bitwise_and(VeinLabelImg2, VeinLabelImg2, mask=Skeleton)
+    
+        ArterySkeletonPred = cv2.bitwise_and(ArteryPred2, ArteryPred2, mask=Skeleton)
+        VeinSkeletonPred = cv2.bitwise_and(VeinPred2, VeinPred2, mask=Skeleton)
+    
+
+        skeletonPixles = np.where(Skeleton >0)
+    
+        TPa_sk = 0
+        TNa_sk = 0
+        FPa_sk = 0
+        FNa_sk = 0
+        for i in range(len(skeletonPixles[0])):
+            row = skeletonPixles[0][i]
+            col = skeletonPixles[1][i]
+            if ArterySkeletonLabel[row, col] == 1 and ArterySkeletonPred[row, col] == 1:
+                TPa_sk = TPa_sk +1
+
+            elif VeinSkeletonLabel[row, col] == 1 and VeinSkeletonPred[row, col] == 1:
+                TNa_sk = TNa_sk + 1
+
+            elif ArterySkeletonLabel[row, col] == 1 and VeinSkeletonPred[row, col] == 1\
+                    and ArteryVeinLabelCommon[row, col] == 0:
+                FNa_sk = FNa_sk + 1
+
+            elif VeinSkeletonLabel[row, col] == 1 and ArterySkeletonPred[row, col] == 1\
+                    and ArteryVeinLabelCommon[row, col] == 0:
+                FPa_sk = FPa_sk + 1
+
+            else:
+                pass
+
+        if  (TPa_sk+FNa_sk)==0 and (TNa_sk + FPa_sk)==0 and (TPa_sk + TNa_sk + FPa_sk + FNa_sk)==0:
+            bad_case_count += 1
+            bad_case_index.append(ImgNumber)
+        sensitivity_sk = TPa_sk/(TPa_sk+FNa_sk)
+        specificity_sk = TNa_sk/(TNa_sk + FPa_sk)
+        acc_sk = (TPa_sk + TNa_sk) /(TPa_sk + TNa_sk + FPa_sk + FNa_sk)
+        f1_sk = 2*TPa_sk/(2*TPa_sk + FPa_sk + FNa_sk)
+        dice_sk = 2*TPa_sk/(2*TPa_sk + FPa_sk + FNa_sk)
+        iou_sk = TPa_sk/(TPa_sk + FPa_sk + FNa_sk)
+
+        senList_sk.append(sensitivity_sk)
+        specList_sk.append(specificity_sk)
+        accList_sk.append(acc_sk)
+        f1List_sk.append(f1_sk)
+        diceList_sk.append(dice_sk)
+        ioulist_sk.append(iou_sk)
+        #print('Skeletonal Metrics', acc_sk, sensitivity_sk, specificity_sk)
+    if onlyMeasureSkeleton:
+        print('Avg Skeleton Performance:', np.mean(accList_sk), np.mean(senList_sk), np.mean(specList_sk))
+        return np.mean(accList_sk), np.mean(specList_sk),np.mean(senList_sk), np.mean(f1List_sk), np.mean(diceList_sk), np.mean(ioulist_sk), bad_case_index
+    else:
+        print('Avg Pixel-wise Performance:', np.mean(accList), np.mean(senList), np.mean(specList))
+        return np.mean(accList), np.mean(specList),np.mean(senList),np.mean(f1List),np.mean(diceList),np.mean(ioulist)
+
+
+
+if __name__ == '__main__':
+
+
+    pro_path = r'F:\dw\RIP-AV\AV\log\DRIVE\running_result\ProMap_testset.npy'
+    ps = np.load(pro_path)
+    AVclassifiation(r'./', ps[:, 0:1, :, :], ps[:, 1:2, :, :], ps[:, 2:, :, :], DataSet=ps.shape[0], image_basename=[str(i)+'.png' for i in range(20)])

AV/Tools/BGR2RGB.py

@@ -0,0 +1,25 @@
+
+
+import cv2
+
+def BGR2RGB(Image):
+    """
+
+    :param Image:
+    :return: RGBImage
+    """
+
+    #the input image is BGR image from OpenCV
+    RGBImage = cv2.cvtColor(Image, cv2.COLOR_BGR2RGB)
+    return RGBImage
+
+
+def RGB2BGR(Image):
+    """
+
+    :param Image:
+    :return: BGRImage
+    """
+    #the input image is RGB image
+    BGRImage = cv2.cvtColor(Image, cv2.COLOR_RGB2BGR)
+    return BGRImage

AV/Tools/BinaryPostProcessing.py

@@ -0,0 +1,108 @@
+
+
+import numpy as np
+from skimage import morphology, measure
+from AV.Tools.Remove_small_holes import remove_small_holes
+import scipy.ndimage.morphology as scipyMorphology
+
+
+def binaryPostProcessing(BinaryImage, removeArea):
+    """
+    Post process the binary segmentation
+    :param BinaryImage:
+    :param removeArea:
+    :return: Img_BW
+    """
+
+    BinaryImage[BinaryImage > 0] = 1
+
+    ###9s
+    # Img_BW = pymorph.binary(BinaryImage)
+    # Img_BW = pymorph.areaopen(Img_BW, removeArea)
+    # Img_BW = pymorph.areaclose(Img_BW, 50)
+    # Img_BW = np.uint8(Img_BW)
+
+    ###2.5 s
+    # Img_BW = np.uint8(BinaryImage)
+    # Img_BW = ITK_LabelImage(Img_BW, removeArea)
+    # Img_BW[Img_BW >0] = 1
+
+    Img_BW = BinaryImage.copy()
+    BinaryImage_Label = measure.label(Img_BW)
+    for i, region in enumerate(measure.regionprops(BinaryImage_Label)):
+        if region.area < removeArea:
+            Img_BW[BinaryImage_Label == i + 1] = 0
+        else:
+            pass
+
+    Img_BW = morphology.binary_closing(Img_BW, morphology.disk(3))
+    Img_BW = remove_small_holes(Img_BW, 50)
+    Img_BW = np.uint8(Img_BW)
+
+    return Img_BW
+
+
+################Three parameters
+def binaryPostProcessing3(BinaryImage, removeArea, fillArea):
+    """
+    Post process the binary image
+    :param BinaryImage:
+    :param removeArea:
+    :param fillArea:
+    :return: Img_BW
+    """
+
+    BinaryImage[BinaryImage>0]=1
+
+    ####takes 0.9s, result is good
+    Img_BW = BinaryImage.copy()
+    BinaryImage_Label = measure.label(Img_BW)
+    for i, region in enumerate(measure.regionprops(BinaryImage_Label)):
+        if region.area < removeArea:
+            Img_BW[BinaryImage_Label == i + 1] = 0
+        else:
+            pass
+
+    # ####takes 0.01s, result is bad
+    # temptime = time.time()
+    # Img_BW = morphology.remove_small_objects(BinaryImage, removeArea)
+    # print "binaryPostProcessing3, ITK_LabelImage time:", time.time() - temptime
+
+
+    Img_BW = morphology.binary_closing(Img_BW, morphology.square(3))
+    # Img_BW = remove_small_holes(Img_BW, fillArea)
+
+    Img_BW_filled = scipyMorphology.binary_fill_holes(Img_BW)
+    Img_BW_dif = np.uint8(Img_BW_filled) - np.uint8(Img_BW)
+    Img_BW_difLabel = measure.label(Img_BW_dif)
+    FilledImg = np.zeros(Img_BW.shape)
+    for i, region in enumerate(measure.regionprops(Img_BW_difLabel)):
+        if region.area < fillArea:
+            FilledImg[Img_BW_difLabel == i + 1] = 1
+        else:
+            pass
+        Img_BW[FilledImg > 0] = 1
+
+    Img_BW = np.uint8(Img_BW)
+    return Img_BW
+
+
+def removeSmallBLobs(BinaryImage, removeArea):
+    """
+    Post process the binary image
+    :param BinaryImage:
+    :param removeArea:
+    """
+
+    BinaryImage[BinaryImage>0]=1
+
+    ####takes 0.9s, result is good
+    Img_BW = BinaryImage.copy()
+    BinaryImage_Label = measure.label(Img_BW)
+    for i, region in enumerate(measure.regionprops(BinaryImage_Label)):
+        if region.area < removeArea:
+            Img_BW[BinaryImage_Label == i + 1] = 0
+        else:
+            pass
+    return np.uint8(Img_BW)
+

AV/Tools/FakePad.py

@@ -0,0 +1,115 @@
+
+
+from __future__ import division
+
+import cv2
+import numpy as np
+from skimage import morphology
+np.seterr(divide='ignore', invalid='ignore')
+
+"""This is the profiled code, very fast, takes 0.25s"""
+def fakePad(Image, Mask, iterations=50):
+    """
+    add an extra padding around the front mask
+    :param Image:
+    :param Mask:
+    :param iterations:
+    :return: DilatedImg
+    """
+
+    if len(Image.shape) == 3: ##for RGB Image
+        """for RGB Images"""
+
+        Mask0 = Mask.copy()
+        height, width = Mask0.shape[:2]
+        Mask0[0, :] = 0  # np.zeros(width)
+        Mask0[-1, :] = 0  # np.zeros(width)
+        Mask0[:, 0] = 0  # np.zeros(height)
+        Mask0[:, -1] = 0  # np.zeros(height)
+
+        # Erodes the mask to avoid weird region near the border.
+        structureElement1 = morphology.disk(5)
+        Mask0 = cv2.morphologyEx(Mask0, cv2.MORPH_ERODE, structureElement1, iterations=1)
+
+        # DilatedImg = Img_green_reverse * Mask
+        DilatedImg = cv2.bitwise_and(Image, Image, mask=Mask0)
+        OldMask = Mask0.copy()
+
+        filter = np.ones((3, 3))
+        filterRows, filterCols = np.where(filter > 0)
+        filterRows = filterRows - 1
+        filterCols = filterCols - 1
+
+        structureElement2 = morphology.diamond(1)
+        for i in range(0, iterations):
+            NewMask = cv2.morphologyEx(OldMask, cv2.MORPH_DILATE, structureElement2, iterations=1)
+            pixelIndex = np.where(NewMask - OldMask)  # [rows, cols]
+            imgValues = np.zeros((len(pixelIndex[0]), len(filterRows), 3))
+            for k in range(len(filterRows)):
+                filterRowIndexes = pixelIndex[0] - filterRows[k]
+                filterColIndexes = pixelIndex[1] - filterCols[k]
+
+                selectMask0 = np.bitwise_and(np.bitwise_and(filterRowIndexes < height, filterRowIndexes >= 0),
+                                             np.bitwise_and(filterColIndexes < width, filterColIndexes >= 0))
+                selectMask1 = OldMask[filterRowIndexes[selectMask0], filterColIndexes[selectMask0]] > 0
+                selectedPositions = [filterRowIndexes[selectMask0][selectMask1],
+                                     filterColIndexes[selectMask0][selectMask1]]
+                imgValues[np.arange(len(pixelIndex[0]))[selectMask0][selectMask1], k, :] = DilatedImg[
+                                                                                           selectedPositions[0],
+                                                                                           selectedPositions[1], :]
+
+            DilatedImg[pixelIndex[0], pixelIndex[1], :] = np.sum(imgValues, axis=1) // np.sum(imgValues > 0, axis=1)
+
+            OldMask = NewMask
+
+        return DilatedImg
+
+    ########################################################################
+
+    else:   #for green channel only
+        """for green channel only"""
+
+        Mask0 = Mask.copy()
+        height, width = Mask0.shape
+        Mask0[0, :] = 0  # np.zeros(width)
+        Mask0[-1, :] = 0  # np.zeros(width)
+        Mask0[:, 0] = 0  # np.zeros(height)
+        Mask0[:, -1] = 0  # np.zeros(height)
+
+        # Erodes the mask to avoid weird region near the border.
+        structureElement1 = morphology.disk(5)
+        Mask0 = cv2.morphologyEx(Mask0, cv2.MORPH_ERODE, structureElement1, iterations=1)
+
+        # DilatedImg = Img_green_reverse * Mask
+        DilatedImg = cv2.bitwise_and(Image, Image, mask=Mask0)
+
+        OldMask = Mask0.copy()
+
+        filter = np.ones((3, 3))
+        filterRows, filterCols = np.where(filter > 0)
+        filterRows = filterRows - 1
+        filterCols = filterCols - 1
+
+        structureElement2 = morphology.diamond(1)
+        for i in range(0, iterations):
+            NewMask = cv2.morphologyEx(OldMask, cv2.MORPH_DILATE, structureElement2, iterations=1)
+            pixelIndex = np.where(NewMask - OldMask)  # [rows, cols]
+
+            imgValues = np.zeros((len(pixelIndex[0]), len(filterRows)))
+            for k in range(len(filterRows)):
+                filterRowIndexes = pixelIndex[0] - filterRows[k]
+                filterColIndexes = pixelIndex[1] - filterCols[k]
+
+                selectMask0 = np.bitwise_and(np.bitwise_and(filterRowIndexes < height, filterRowIndexes >= 0),
+                                             np.bitwise_and(filterColIndexes < width, filterColIndexes >= 0))
+                selectMask1 = OldMask[filterRowIndexes[selectMask0], filterColIndexes[selectMask0]] > 0
+                selectedPositions = [filterRowIndexes[selectMask0][selectMask1], filterColIndexes[selectMask0][selectMask1]]
+                imgValues[np.arange(len(pixelIndex[0]))[selectMask0][selectMask1], k] = DilatedImg[selectedPositions[0], selectedPositions[1]]
+
+            DilatedImg[pixelIndex[0], pixelIndex[1]] = np.sum(imgValues, axis=1) / np.sum(imgValues > 0, axis=1)
+
+            OldMask = NewMask
+
+        return DilatedImg
+
+

AV/Tools/Float2Uint.py

@@ -0,0 +1,18 @@
+
+
+import numpy as np
+
+def float2Uint(Image_float):
+    """
+    Transfer float image to np.uint8 type
+    :param Image_float:
+    :return:LnGray
+    """
+
+    MaxLn = np.max(Image_float)
+    MinLn = np.min(Image_float)
+    # LnGray = 255*(Image_float - MinLn)//(MaxLn - MinLn + 1e-6)
+    LnGray = 255 * ((Image_float - MinLn) / float((MaxLn - MinLn + 1e-6)))
+    LnGray = np.array(LnGray, dtype = np.uint8)
+
+    return LnGray

AV/Tools/Hemelings_eval.py

@@ -0,0 +1,119 @@
+import numpy as np
+from skimage.morphology import skeletonize, erosion
+from sklearn.metrics import f1_score, accuracy_score,classification_report,confusion_matrix
+import cv2
+from Tools.BinaryPostProcessing import binaryPostProcessing3
+
+def evaluation_code(prediction, groundtruth, mask=None,use_mask=False):
+    '''
+    Function to evaluate the performance of AV predictions with a given ground truth
+    - prediction: should be an image array of [dim1, dim2, img_channels = 3] with arteries in red and veins in blue
+    - groundtruth: same as above
+    '''
+    encoded_pred = np.zeros(prediction.shape[:2], dtype=int)
+    encoded_gt = np.zeros(groundtruth.shape[:2], dtype=int)
+    
+    # convert white pixels to green pixels (which are ignored)
+    white_ind = np.where(np.logical_and(groundtruth[:,:,0] == 255, groundtruth[:,:,1] == 255, groundtruth[:,:,2] == 255))
+    if white_ind[0].size != 0:
+        groundtruth[white_ind] = [0,255,0]
+        
+    # translate the images to arrays suited for sklearn metrics
+    # --- original -------
+    arteriole = np.where(np.logical_and(groundtruth[:,:,0] == 255, groundtruth[:,:,1] == 0)); encoded_gt[arteriole] = 1
+    venule = np.where(np.logical_and(groundtruth[:,:,2] == 255, groundtruth[:,:,1] == 0)); encoded_gt[venule] = 2
+    arteriole = np.where(prediction[:,:,0] == 255); encoded_pred[arteriole] = 1
+    venule = np.where(prediction[:,:,2] == 255); encoded_pred[venule] = 2
+    # --------------------
+
+    # disk and cup
+    if use_mask:
+        groundtruth = cv2.bitwise_and(groundtruth, groundtruth, mask=mask)
+        prediction = cv2.bitwise_and(prediction, prediction, mask=mask)
+
+        encoded_pred = cv2.bitwise_and(encoded_pred, encoded_pred, mask=mask)
+        encoded_gt = cv2.bitwise_and(encoded_gt, encoded_gt, mask=mask)
+
+    # retrieve the indices for the centerline pixels present in the prediction
+    center = np.where(np.logical_and(
+        np.logical_or((skeletonize(groundtruth[:,:,0] > 0)),(skeletonize(groundtruth[:,:,2] > 0))),
+        encoded_pred[:,:] > 0))
+    
+    encoded_pred_center = encoded_pred[center]
+    encoded_gt_center = encoded_gt[center]
+    
+    # retrieve the indices for the centerline pixels present in the groundtruth
+    center_comp = np.where(
+        np.logical_or(skeletonize(groundtruth[:,:,0] > 0),skeletonize(groundtruth[:,:,2] > 0)))
+    
+    encoded_pred_center_comp = encoded_pred[center_comp]
+    encoded_gt_center_comp = encoded_gt[center_comp]
+    
+    # retrieve the indices for discovered centerline pixels - limited to vessels wider than two pixels (for DRIVE)
+    center_eroded = np.where(np.logical_and(
+        np.logical_or(skeletonize(erosion(groundtruth[:,:,0] > 0)),skeletonize(erosion(groundtruth[:,:,2] > 0))),
+        encoded_pred[:,:] > 0))
+                             
+    encoded_pred_center_eroded = encoded_pred[center_eroded]
+    encoded_gt_center_eroded = encoded_gt[center_eroded]
+    
+    # metrics over full image
+    cur1_acc = accuracy_score(encoded_gt.flatten(),encoded_pred.flatten())
+    cur1_F1 = f1_score(encoded_gt.flatten(),encoded_pred.flatten(),average='weighted')
+    # cls_report = classification_report(encoded_gt.flatten(), encoded_pred.flatten(), target_names=['class_1', 'class_2', 'class_3'])
+    # print('Full image')
+    # print('Accuracy: {}\nF1: {}\n'.format(cur1_acc, cur1_F1))
+    # print('Class report:')
+    # print(cls_report)
+    metrics1 = [cur1_acc, cur1_F1]
+    
+    # metrics over discovered centerline pixels
+    cur2_acc = accuracy_score(encoded_gt_center.flatten(),encoded_pred_center.flatten())
+    cur2_F1 = f1_score(encoded_gt_center.flatten(),encoded_pred_center.flatten(),average='weighted')
+    # print('Discovered centerline pixels')
+    # print('Accuracy: {}\nF1: {}\n'.format(cur2_acc, cur2_F1))
+    metrics2 = [cur2_acc, cur2_F1]
+    
+    # metrics over discovered centerline pixels - limited to vessels wider than two pixels
+    cur3_acc = accuracy_score(encoded_gt_center_eroded.flatten(),encoded_pred_center_eroded.flatten())
+    cur3_F1 = f1_score(encoded_gt_center_eroded.flatten(),encoded_pred_center_eroded.flatten(),average='weighted')
+    # print('Discovered centerline pixels of vessels wider than two pixels')
+    # print('Accuracy: {}\nF1: {}\n'.format(cur3_acc, cur3_F1))
+    metrics3 = [cur3_acc, cur3_F1]
+    
+    # metrics over all centerline pixels in ground truth
+    cur4_acc = accuracy_score(encoded_gt_center_comp.flatten(),encoded_pred_center_comp.flatten())
+    cur4_F1 = f1_score(encoded_gt_center_comp.flatten(),encoded_pred_center_comp.flatten(),average='weighted')
+    # print('Centerline pixels')
+    # print('Accuracy: {}\nF1: {}\n'.format(cur4_acc, cur4_F1))
+    # confusion matrix
+    out = confusion_matrix(encoded_gt_center_comp,encoded_pred_center_comp)#.ravel()
+    sens = 0
+    sepc = 0
+    
+    if out.shape[0] == 2:
+        tn, fp,fn,tp = out.ravel()
+        # print(tn, fp,fn,tp)
+    else:
+        tn = out[1,1]
+        fp = out[1,2]
+        fn = out[2,1]
+        tp = out[2,2]
+
+    # sens = tpr
+    spec = tp/ (tp+fn)
+    # spec = TNR
+    sens = tn/(fp+tn)
+
+    metrics4 = [cur4_acc, cur4_F1, sens, spec]
+    
+
+    # finally, compute vessel detection rate
+    vessel_ind = np.where(encoded_gt>0)
+    vessel_gt = encoded_gt[vessel_ind]
+    vessel_pred = encoded_pred[vessel_ind]
+    
+    detection_rate = accuracy_score(vessel_gt.flatten(),vessel_pred.flatten())
+    # print('Amount of vessels detected: ' + str(detection_rate))
+    
+    return [metrics1,metrics2,metrics3,metrics4,detection_rate]#,encoded_pred,encoded_gt,center,center_comp,center_eroded#,encoded_pred_center_comp,encoded_gt_center_comp

AV/Tools/Im2Double.py

@@ -0,0 +1,15 @@
+
+
+import numpy as np
+
+def im2double(im):
+    """
+    Transfer np.uint8 to float type
+    :param im:
+    :return: output image
+    """
+
+    min_val = np.min(im.ravel())
+    max_val = np.max(im.ravel())
+    out = (im.astype('float') - min_val) / (max_val - min_val)
+    return out

AV/Tools/ImageResize.py

@@ -0,0 +1,214 @@
+import os.path
+
+import cv2
+import numpy as np
+from skimage import measure
+
+def imageResize(Image, downsizeRatio):
+
+    ##This program resize the original image
+    ##Input: original image and downsizeRatio (user defined parameter: 0.75, 0.5 or 0.2)
+    ##Output: the resized image according to the given ratio
+
+    if  downsizeRatio < 1:#len(ImgFileList)
+        ImgResized = cv2.resize(Image, dsize=None, fx=downsizeRatio, fy=downsizeRatio)
+    else:
+        ImgResized = Image
+
+    ImgResized = np.uint8(ImgResized)
+    return ImgResized
+
+
+def creatMask(Image, threshold = 10):
+    ##This program try to creat the mask for the filed-of-view
+    ##Input original image (RGB or green channel), threshold (user set parameter, default 10)
+    ##Output: the filed-of-view mask
+
+    if len(Image.shape) == 3: ##RGB image
+        gray = cv2.cvtColor(Image, cv2.COLOR_BGR2GRAY)
+        Mask0 = gray >= threshold
+
+    else:  #for green channel image
+        Mask0 = Image >= threshold
+
+
+    # ######get the largest blob, this takes 0.18s
+    cvVersion = int(cv2.__version__.split('.')[0])
+
+    Mask0 = np.uint8(Mask0)
+
+    contours, hierarchy = cv2.findContours(Mask0, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+
+    areas = [cv2.contourArea(c) for c in contours]
+    max_index = np.argmax(areas)
+    Mask = np.zeros(Image.shape[:2], dtype=np.uint8)
+    cv2.drawContours(Mask, contours, max_index, 1, -1)
+
+    ResultImg = Image.copy()
+    if len(Image.shape) == 3:
+        ResultImg[Mask ==0] = (255,255,255)
+    else:
+        ResultImg[Mask==0] = 255
+
+    return ResultImg, Mask
+
+def shift_rgb(img, *args):
+
+
+
+
+    result_img = np.empty_like(img)
+    shifts = args
+    max_value = 255
+    # print(shifts)
+    for i, shift in enumerate(shifts):
+        lut = np.arange(0, max_value + 1).astype("float32")
+        lut += shift
+
+        lut = np.clip(lut, 0, max_value).astype(img.dtype)
+        if len(img.shape)==2:
+            print(f'=========grey image=======')
+            result_img = cv2.LUT(img,lut)
+        else:
+            result_img[..., i] = cv2.LUT(img[...,i],lut)
+
+    return result_img
+def cropImage_bak(Image, Mask):
+    Image = Image.copy()
+    Mask = Mask.copy()
+
+    leftLimit, rightLimit, upperLimit, lowerLimit = getLimit(Mask)
+
+
+
+    if len(Image.shape) == 3:
+        ImgCropped = Image[upperLimit:lowerLimit, leftLimit:rightLimit, :]
+        MaskCropped = Mask[upperLimit:lowerLimit, leftLimit:rightLimit]
+
+        ImgCropped[:20, :, :] = 0
+        ImgCropped[-20:, :, :] = 0
+        ImgCropped[:, :20, :] = 0
+        ImgCropped[:, -20:, :] = 0
+        MaskCropped[:20, :] = 0
+        MaskCropped[-20:, :] = 0
+        MaskCropped[:, :20] = 0
+        MaskCropped[:, -20:] = 0
+    else: #len(Image.shape) == 2:
+        ImgCropped = Image[upperLimit:lowerLimit, leftLimit:rightLimit]
+        MaskCropped = Mask[upperLimit:lowerLimit, leftLimit:rightLimit]
+        ImgCropped[:20, :] = 0
+        ImgCropped[-20:, :] = 0
+        ImgCropped[:, :20] = 0
+        ImgCropped[:, -20:] = 0
+        MaskCropped[:20, :] = 0
+        MaskCropped[-20:, :] = 0
+        MaskCropped[:, :20] = 0
+        MaskCropped[:, -20:] = 0
+
+
+    cropLimit = [upperLimit, lowerLimit, leftLimit, rightLimit]
+
+    return ImgCropped, MaskCropped, cropLimit
+
+
+
+########################################################
+###new function to get the limit for cropping.
+###try to get higher speed than np.where, but not working.
+
+def getLimit(Mask):
+
+    Mask1 = Mask > 0
+    colSums = np.sum(Mask1, axis=1)
+    rowSums = np.sum(Mask1, axis=0)
+    maxColSum = np.max(colSums)
+    maxRowSum = np.max(rowSums)
+
+    colList = np.where(colSums >= 0.01*maxColSum)[0]
+    rowList = np.where(rowSums >= 0.01*maxRowSum)[0]
+
+    leftLimit0 = np.min(rowList)
+    rightLimit0 = np.max(rowList)
+    upperLimit0 = np.min(colList)
+    lowerLimit0 = np.max(colList)
+
+    margin = 50
+    leftLimit = np.clip(leftLimit0-margin, 0, Mask.shape[1])
+    rightLimit = np.clip(rightLimit0+margin, 0, Mask.shape[1])
+    upperLimit = np.clip(upperLimit0 - margin, 0, Mask.shape[0])
+    lowerLimit = np.clip(lowerLimit0 + margin, 0, Mask.shape[0])
+
+
+    return leftLimit, rightLimit, upperLimit, lowerLimit
+
+
+
+
+
+def cropImage(Image, Mask):
+    ##This program will crop the filed of view based on the mask
+    ##Input: orginal image, origimal Mask  (the image needs to be RGB resized image)
+    ##Output: Cropped image, Cropped Mask, the cropping limit
+
+    height, width = Image.shape[:2]
+
+    rowsMask0, colsMask0 = np.where(Mask > 0)
+    minColIndex0, maxColIndex0 = np.argmin(colsMask0), np.argmax(colsMask0)
+    minCol, maxCol = colsMask0[minColIndex0], colsMask0[maxColIndex0]
+
+    minRowIndex0, maxRowIndex0 = np.argmin(rowsMask0), np.argmax(rowsMask0)
+    minRow, maxRow = rowsMask0[minRowIndex0], rowsMask0[maxRowIndex0]
+
+    upperLimit = np.maximum(0, minRow - 50)   #20
+    lowerLimit = np.minimum(maxRow + 50, height)   #20
+    leftLimit = np.maximum(0, minCol - 50)   #lowerLimit = np.minimum(maxCol + 50, width)   #20
+    rightLimit = np.minimum(maxCol + 50, width)
+
+    if len(Image.shape) == 3:
+        ImgCropped = Image[upperLimit:lowerLimit, leftLimit:rightLimit, :]
+        MaskCropped = Mask[upperLimit:lowerLimit, leftLimit:rightLimit]
+
+        ImgCropped[:20, :, :] = 0
+        ImgCropped[-20:, :, :] = 0
+        ImgCropped[:, :20, :] = 0
+        ImgCropped[:, -20:, :] = 0
+        MaskCropped[:20, :] = 0
+        MaskCropped[-20:, :] = 0
+        MaskCropped[:, :20] = 0
+        MaskCropped[:, -20:] = 0
+    elif len(Image.shape) == 2:
+        ImgCropped = Image[upperLimit:lowerLimit, leftLimit:rightLimit]
+        MaskCropped = Mask[upperLimit:lowerLimit, leftLimit:rightLimit]
+        ImgCropped[:20, :] = 0
+        ImgCropped[-20:, :] = 0
+        ImgCropped[:, :20] = 0
+        ImgCropped[:, -20:] = 0
+        MaskCropped[:20, :] = 0
+        MaskCropped[-20:, :] = 0
+        MaskCropped[:, :20] = 0
+        MaskCropped[:, -20:] = 0
+    else:
+        pass
+
+
+    cropLimit = [upperLimit, lowerLimit, leftLimit, rightLimit]
+
+    return ImgCropped, MaskCropped, cropLimit
+
+
+if __name__ == '__main__':
+    if not os.path.exists(os.path.join('../data','AV_DRIVE','test','mask')):
+        os.makedirs(os.path.join('../data','AV_DRIVE','test','mask'))
+
+    for file in os.listdir(os.path.join('../data','AV_DRIVE','test','images')):
+        # suffix file name
+        if file.endswith('.jpg') or file.endswith('.png'):
+            # read image
+            img = cv2.imread(os.path.join('../data','AV_DRIVE','test','images',file))
+
+
+            _,mask = creatMask(img)
+
+
+            # save mask
+            cv2.imwrite(os.path.join('../data','AV_DRIVE','test','mask',file),mask)

AV/Tools/Remove_small_holes.py

@@ -0,0 +1,88 @@
+
+
+import numpy as np
+import functools
+import warnings
+from scipy import ndimage as ndi
+from skimage import morphology
+
+
+def remove_small_holes(ar, min_size=64, connectivity=1, in_place=False):
+    """Remove continguous holes smaller than the specified size.
+    Parameters
+    ----------
+    ar : ndarray (arbitrary shape, int or bool type)
+        The array containing the connected components of interest.
+    min_size : int, optional (default: 64)
+        The hole component size.
+    connectivity : int, {1, 2, ..., ar.ndim}, optional (default: 1)
+        The connectivity defining the neighborhood of a pixel.
+    in_place : bool, optional (default: False)
+        If `True`, remove the connected components in the input array itself.
+        Otherwise, make a copy.
+    Raises
+    ------
+    TypeError
+        If the input array is of an invalid type, such as float or string.
+    ValueError
+        If the input array contains negative values.
+    Returns
+    -------
+    out : ndarray, same shape and type as input `ar`
+        The input array with small holes within connected components removed.
+    Examples
+    --------
+    # >>> from skimage import morphology
+    # >>> a = np.array([[1, 1, 1, 1, 1, 0],
+    # ...               [1, 1, 1, 0, 1, 0],
+    # ...               [1, 0, 0, 1, 1, 0],
+    # ...               [1, 1, 1, 1, 1, 0]], bool)
+    # >>> b = morphology.remove_small_holes(a, 2)
+    # >>> b
+    # array([[ True,  True,  True,  True,  True, False],
+    #        [ True,  True,  True,  True,  True, False],
+    #        [ True, False, False,  True,  True, False],
+    #        [ True,  True,  True,  True,  True, False]], dtype=bool)
+    # >>> c = morphology.remove_small_holes(a, 2, connectivity=2)
+    # >>> c
+    # array([[ True,  True,  True,  True,  True, False],
+    #        [ True,  True,  True, False,  True, False],
+    #        [ True, False, False,  True,  True, False],
+    #        [ True,  True,  True,  True,  True, False]], dtype=bool)
+    # >>> d = morphology.remove_small_holes(a, 2, in_place=True)
+    # >>> d is a
+    # True
+    # Notes
+    # -----
+    # If the array type is int, it is assumed that it contains already-labeled
+    # objects. The labels are not kept in the output image (this function always
+    # outputs a bool image). It is suggested that labeling is completed after
+    # using this function.
+    # """
+    # _check_dtype_supported(ar)
+
+    #Creates warning if image is an integer image
+    # if ar.dtype != bool:
+    #     warnings.warn("Any labeled images will be returned as a boolean array. "
+    #                   "Did you mean to use a boolean array?", UserWarning)
+
+    if in_place:
+        out = ar
+    else:
+        out = ar.copy()
+
+    #Creating the inverse of ar
+    if in_place:
+        out = np.logical_not(out,out)
+    else:
+        out = np.logical_not(out)
+
+    #removing small objects from the inverse of ar
+    out = morphology.remove_small_objects(out, min_size, connectivity, in_place)
+
+    if in_place:
+        out = np.logical_not(out,out)
+    else:
+        out = np.logical_not(out)
+
+    return out

AV/Tools/Standardize.py

@@ -0,0 +1,45 @@
+
+
+from __future__ import division
+import numpy as np
+import cv2
+
+def standardize(img,mask,wsize):
+    """
+    Convert the image values to standard images.
+    :param img:
+    :param mask:
+    :param wsize:
+    :return:
+    """
+
+    if  wsize == 0:
+        simg=globalstandardize(img,mask)
+    else:
+        img[mask == 0]=0
+        img_mean=cv2.blur(img, ksize=wsize)
+        img_squared_mean = cv2.blur(img*img, ksize=wsize)
+        img_std = np.sqrt(img_squared_mean - img_mean*img_mean)
+        simg=(img - img_mean) / img_std
+        simg[img_std == 0]=0
+        simg[mask == 0]=0
+    return simg
+
+def globalstandardize(img,mask):
+
+    usedpixels = np.double(img[mask == 1])
+    m=np.mean(usedpixels)
+    s=np.std(usedpixels)
+    simg=np.zeros(img.shape)
+    simg[mask == 1]=(usedpixels - m) / s
+    return simg
+
+def getmean(x):
+    usedx=x[x != 0]
+    m=np.mean(usedx)
+    return m
+
+def getstd(x):
+    usedx=x[x != 0]
+    s=np.std(usedx)
+    return s

AV/Tools/centerline_evaluation.py

@@ -0,0 +1,160 @@
+import numpy as np
+import cv2
+import os
+import natsort
+from Tools.Hemelings_eval import evaluation_code
+import pandas as pd
+
+def getFolds(ImgPath, LabelPath, k_fold_idx,k_fold, trainset=True):
+	print(f'ImgPath: {ImgPath}')
+	print(f'LabelPath: {LabelPath}')
+	print(f'k_fold_idx: {k_fold_idx}')
+	print(f'k_fold: {k_fold}')
+	print(f'trainset: {trainset}')
+	for dirpath,dirnames,filenames in os.walk(ImgPath):
+		ImgDirAll = filenames
+		break
+
+	for dirpath,dirnames,filenames in os.walk(LabelPath):
+		LabelDirAll = filenames
+		break
+	ImgDir = []
+	LabelDir = []
+	
+	ImgDir_testset = []
+	LabelDir_testset = []
+
+	if k_fold >0:
+		ImgDirAll = natsort.natsorted(ImgDirAll)
+		LabelDirAll = natsort.natsorted(LabelDirAll)
+		num_fold = len(ImgDirAll) // k_fold
+		for i in range(k_fold):
+			start_idx = i * num_fold
+			end_idx = (i+1) * num_fold
+			# if i == k_fold_idx:
+			ImgDir_testset.extend(ImgDirAll[start_idx:end_idx])
+			LabelDir_testset.extend(LabelDirAll[start_idx:end_idx])
+			#continue
+			ImgDir.extend(ImgDirAll[start_idx:end_idx])
+			LabelDir.extend(LabelDirAll[start_idx:end_idx])
+	if not trainset:
+		return ImgDir_testset, LabelDir_testset
+	return ImgDir, ImgDir
+
+def centerline_eval(ProMap, config):
+	if config.dataset_name == 'hrf':
+		ImgPath = os.path.join(config.trainset_path,'test', 'images')
+		LabelPath = os.path.join(config.trainset_path,'test', 'ArteryVein_0410_final')
+	elif config.dataset_name == 'DRIVE':
+		dataroot = './data/AV_DRIVE/test'
+		LabelPath = os.path.join(dataroot, 'av')
+	else: #if config.dataset_name == 'INSPIRE':
+		dataroot = './data/INSPIRE_AV'
+		LabelPath = os.path.join(dataroot, 'label')
+		DF_disc = pd.read_excel('./Tools/DiskParameters_INSPIRE_resize.xls', sheet_name=0)
+	if config.dataset_name == 'hrf':
+		k_fold_idx = config.k_fold_idx
+		k_fold = config.k_fold
+
+		ImgList0 , LabelList0 = getFolds(ImgPath, LabelPath, k_fold_idx,k_fold, trainset=False)
+	overall_value = [[0,0] for i in range(3)]
+	overall_value.append([0,0,0,0])
+	overall_value.append(0)
+	img_num = ProMap.shape[0]
+	for i in range(img_num):
+		arteryImg = ProMap[i, 0, :, :]
+		veinImg   = ProMap[i, 1, :, :]
+		vesselImg = ProMap[i, 2, :, :]
+
+		idx = str(i+1)
+		idx = idx.zfill(2)
+		if config.dataset_name == 'hrf':
+			imgName = ImgList0[i] 
+		elif config.dataset_name == 'DRIVE':
+			imgName = idx + '_test.png'
+		else:
+			imgName = 'image'+ str(i+1) + '_ManualAV.png'
+		gt_path = os.path.join(LabelPath , imgName)
+		print(gt_path)
+		gt = cv2.imread(gt_path)
+		gt = cv2.cvtColor(gt, cv2.COLOR_BGR2RGB)
+		if config.dataset_name == 'hrf':
+			gt = cv2.resize(gt, (1200,800))
+		gt_vessel = gt[:,:,0]+gt[:,:,2] 
+
+		h, w = arteryImg.shape
+
+		ArteryPred = np.float32(arteryImg)
+		VeinPred   = np.float32(veinImg)
+		VesselPred = np.float32(vesselImg)
+		AVSeg1 = np.zeros((h, w, 3))
+		vesselSeg = np.zeros((h, w))
+		th = 0
+		vesselPixels = np.where(gt_vessel)#(VesselPred>th) #
+
+		for k in np.arange(len(vesselPixels[0])):
+			row = vesselPixels[0][k]
+			col = vesselPixels[1][k]
+			if ArteryPred[row, col] >= VeinPred[row, col]:
+				AVSeg1[row, col] = (255, 0, 0)
+			else:
+				AVSeg1[row, col] = ( 0, 0, 255)
+
+		AVSeg1 = np.float32(AVSeg1)
+		AVSeg1 = np.uint8(AVSeg1)
+
+		if config.dataset_name == 'INSPIRE':
+			discCenter = (DF_disc.loc[i, 'DiskCenterRow'], DF_disc.loc[i, 'DiskCenterCol'])
+			discRadius = DF_disc.loc[i, 'DiskRadius']
+			MaskDisc = np.ones((h, w), np.uint8)
+			cv2.circle(MaskDisc, center=(discCenter[1], discCenter[0]), radius= discRadius, color=0, thickness=-1)
+			out = evaluation_code(AVSeg1, gt, mask=MaskDisc,use_mask=True)
+		else:
+			out = evaluation_code(AVSeg1, gt)
+
+		for j in range(len(out)):
+			if j == 4:
+				overall_value[j] += out[j]
+				continue
+			if j == 3:
+				overall_value[j][0] += out[j][0]
+				overall_value[j][1] += out[j][1]
+				overall_value[j][2] += out[j][2]
+				overall_value[j][3] += out[j][3]
+				continue
+
+			overall_value[j][0] += out[j][0]
+			overall_value[j][1] += out[j][1]
+
+	# print("overall_value:", overall_value)
+	for j in range(len(overall_value)):
+		if j == 4:
+			overall_value[j] /= img_num
+			continue
+		if j == 3:
+			overall_value[j][0] /= img_num
+			overall_value[j][1] /= img_num
+			overall_value[j][2] /= img_num
+			overall_value[j][3] /= img_num
+			continue
+		overall_value[j][0] /= img_num
+		overall_value[j][1] /= img_num
+	# print
+	metrics_names = ['full image', 'discovered centerline pixels', 'vessels wider than two pixels', 'all centerline', 'vessel detection rate']
+	filewriter = ""
+	print("--------------------------Centerline---------------------------------")
+	filewriter += "--------------------------Centerline---------------------------------\n"
+	for j in range(len(overall_value)):
+		if j == 4:
+			print("{} - Ratio:{}".format(metrics_names[j], overall_value[j]))
+			filewriter += "{} - Ratio:{}\n".format(metrics_names[j], overall_value[j])
+			continue
+		if j == 3:
+			print("{} - Acc: {} , F1:{}, Sens:{}, Spec:{}".format(metrics_names[j], overall_value[j][0],overall_value[j][1],overall_value[j][2],overall_value[j][3]))
+			filewriter += "{} - Acc: {} , F1:{}, Sens:{}, Spec:{}\n".format(metrics_names[j], overall_value[j][0],overall_value[j][1],overall_value[j][2],overall_value[j][3])
+			continue
+
+		print("{} - Acc: {} , F1:{}".format(metrics_names[j], overall_value[j][0],overall_value[j][1]))
+		filewriter += "{} - Acc: {} , F1:{}\n".format(metrics_names[j], overall_value[j][0],overall_value[j][1])
+	
+	return filewriter

AV/Tools/data_augmentation.py

@@ -0,0 +1,94 @@
+import numpy as np
+import tensorlayer as tl
+
+def data_augmentation1_5(*args):
+    # image3 = np.expand_dims(image3,-1)
+    args = tl.prepro.rotation_multi(args, rg=180, is_random=True,
+                                                        fill_mode='reflect')
+    args = np.squeeze(args).astype(np.float32)
+
+    return args
+
+def data_augmentation3_5(*args):
+    # image3 = np.expand_dims(image3,-1)
+    args = tl.prepro.shift_multi(args, wrg=0.10, hrg=0.10, is_random=True,
+                                                     fill_mode='reflect')
+    args = np.squeeze(args).astype(np.float32)
+
+    return args
+
+def data_augmentation4_5(*args):
+
+    args = tl.prepro.swirl_multi(args,is_random=True)
+    args = np.squeeze(args).astype(np.float32)
+
+    return args
+
+def data_augmentation2_5(*args):
+    # image3 = np.expand_dims(image3,-1)
+    args = tl.prepro.zoom_multi(args, zoom_range=[0.5, 2.5], is_random=True,
+                                                    fill_mode='reflect')
+    args = np.squeeze(args).astype(np.float32)
+
+    return args
+
+def data_aug5_old(data_mat, label_mat, label_data_centerness, choice):
+    data_mat = np.transpose(data_mat, (1, 2, 0))
+    label_mat = np.transpose(label_mat, (1, 2, 0))
+    label_data_centerness = np.transpose(label_data_centerness, (1, 2, 0))
+
+    if choice == 0:
+        data_mat = data_mat
+        label_mat = label_mat
+        label_data_centerness = label_data_centerness
+
+    elif choice == 1:
+        data_mat = np.fliplr(data_mat)
+        label_mat = np.fliplr(label_mat)
+        label_data_centerness = np.fliplr(label_data_centerness)
+
+    elif choice == 2:
+        data_mat = np.flipud(data_mat)
+        label_mat = np.flipud(label_mat)
+        label_data_centerness = np.flipud(label_data_centerness)
+
+    elif choice == 3:
+        data_mat, label_mat, label_data_centerness= data_augmentation1_5(data_mat, label_mat, label_data_centerness)
+    elif choice == 4:
+        data_mat, label_mat, label_data_centerness= data_augmentation2_5(data_mat, label_mat, label_data_centerness)
+    elif choice == 5:
+        data_mat, label_mat, label_data_centerness= data_augmentation3_5(data_mat, label_mat, label_data_centerness)
+    elif choice == 6:
+        data_mat, label_mat, label_data_centerness= data_augmentation4_5(data_mat, label_mat, label_data_centerness)
+
+    data_mat = np.transpose(data_mat, (2, 0, 1))
+    label_mat = np.transpose(label_mat, (2, 0, 1))
+    label_data_centerness = np.transpose(label_data_centerness, (2, 0, 1))
+
+
+    return data_mat, label_mat, label_data_centerness
+
+# data augmentation for variable number of input
+def data_aug5(*args,choice):
+    datas=[np.transpose(item, (1, 2, 0)) for item in args]
+
+    if choice==1:
+        datas=[np.fliplr(item) for item in datas]
+    elif choice==2:
+        datas = [np.flipud(item) for item in datas]
+    elif choice==3:
+        datas = data_augmentation1_5(*datas)
+    elif choice==4:
+        datas = data_augmentation2_5(*datas)
+    elif choice==5:
+        datas = data_augmentation3_5(*datas)
+    elif choice==6:
+        datas = data_augmentation4_5(*datas)
+
+    datas = [np.transpose(item, (2, 0, 1)) for item in datas]
+
+    return tuple(datas)
+
+
+
+

AV/Tools/evalution_vessel.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+###################################################
+#
+#   Script to
+#   - Calculate prediction of the test dataset
+#   - Calculate the parameters to evaluate the prediction
+#
+##################################################
+
+#Python
+import numpy as np
+from sklearn.metrics import roc_curve
+from sklearn.metrics import roc_auc_score,f1_score,jaccard_score
+from sklearn.metrics import confusion_matrix
+from sklearn.metrics import precision_recall_curve
+
+from lib.extract_patches2 import pred_only_FOV
+
+
+def evalue(preImg, gtruth_masks, test_border_masks):
+
+    #predictions only inside the FOV
+    y_scores, y_true = pred_only_FOV(preImg,gtruth_masks, test_border_masks)  #returns data only inside the FOV
+
+    #Area under the ROC curve
+    fpr, tpr, thresholds = roc_curve((y_true), y_scores)
+    AUC_ROC = roc_auc_score(y_true, y_scores)
+    # test_integral = np.trapz(tpr,fpr) #trapz is numpy integration
+
+    #Precision-recall curve
+    precision, recall, thresholds = precision_recall_curve(y_true, y_scores)
+    precision = np.fliplr([precision])[0]  #so the array is increasing (you won't get negative AUC)
+    recall = np.fliplr([recall])[0]  #so the array is increasing (you won't get negative AUC)
+
+
+    #Confusion matrix
+    threshold_confusion = 0.5
+
+    y_pred = np.empty((y_scores.shape[0]))
+    for i in range(y_scores.shape[0]):
+        if y_scores[i]>=threshold_confusion:
+            y_pred[i]=1
+        else:
+            y_pred[i]=0
+    confusion = confusion_matrix(y_true, y_pred)
+
+    accuracy = 0
+    if float(np.sum(confusion))!=0:
+        accuracy = float(confusion[0,0]+confusion[1,1])/float(np.sum(confusion))
+
+    specificity = 0
+    if float(confusion[0,0]+confusion[0,1])!=0:
+        specificity = float(confusion[0,0])/float(confusion[0,0]+confusion[0,1])
+
+    sensitivity = 0
+    if float(confusion[1,1]+confusion[1,0])!=0:
+        sensitivity = float(confusion[1,1])/float(confusion[1,1]+confusion[1,0])
+
+    precision = 0
+    if float(confusion[1,1]+confusion[0,1])!=0:
+        precision = float(confusion[1,1])/float(confusion[1,1]+confusion[0,1])
+   
+    #Jaccard similarity index
+    #jaccard_index = jaccard_similarity_score(y_true, y_pred, normalize=True)
+
+    
+    #F1 score
+    F1_score = f1_score(y_true, y_pred, labels=None, average='binary', sample_weight=None)
+    iou_score = jaccard_score(y_true, y_pred)
+    dice_score = 2*iou_score/(1+iou_score)
+
+    
+    return AUC_ROC,accuracy,specificity,sensitivity,F1_score,dice_score,iou_score
+
+

AV/Tools/global2patch_AND_patch2global.py

@@ -0,0 +1,106 @@
+# -*- encoding: utf-8 -*-
+# author Victorshengw
+
+
+import os
+import numpy as np
+from torchvision import transforms
+from torch.autograd import Variable
+import  torch
+from PIL import Image
+
+
+def get_patch_info(shape, p_size):
+    '''
+    shape: origin image size, (x, y)
+    p_size: patch size (square)
+    return: n_x, n_y, step_x, step_y
+    '''
+    x = shape[0]
+    y = shape[1]
+    if x==p_size and y==p_size:
+        return 1, 1, 0, 0
+
+    n = m = 1
+    while x > n * p_size:
+        n += 1
+    while p_size - 1.0 * (x - p_size) / (n - 1) < p_size/4:
+        n += 1
+    while y > m * p_size:
+        m += 1
+    while p_size - 1.0 * (y - p_size) / (m - 1) < p_size/4:
+        m += 1
+    return n, m, (x - p_size) * 1.0 / (n - 1), (y - p_size) * 1.0 / (m - 1)
+
+
+
+def global2patch(images, p_size):
+    '''
+    image/label => patches
+    p_size: patch size
+    return: list of PIL patch images; coordinates: images->patches; ratios: (h, w)
+    '''
+    patches = []; coordinates = []; templates = []; sizes = []; ratios = [(0, 0)] * len(images); patch_ones = np.ones(p_size)
+    for i in range(len(images)):
+        w, h = images[i].size
+        size = (h, w)
+        sizes.append(size)
+        ratios[i] = (float(p_size[0]) / size[0], float(p_size[1]) / size[1])
+        template = np.zeros(size)
+        n_x, n_y, step_x, step_y = get_patch_info(size, p_size[0])
+        patches.append([images[i]] * (n_x * n_y))
+        coordinates.append([(0, 0)] * (n_x * n_y))
+        for x in range(n_x):
+            if x < n_x - 1: top = int(np.round(x * step_x))
+            else: top = size[0] - p_size[0]
+            for y in range(n_y):
+                if y < n_y - 1: left = int(np.round(y * step_y))
+                else: left = size[1] - p_size[1]
+                template[top:top+p_size[0], left:left+p_size[1]] += patch_ones
+                coordinates[i][x * n_y + y] = (1.0 * top / size[0], 1.0 * left / size[1])
+                patches[i][x * n_y + y] = transforms.functional.crop(images[i], top, left, p_size[0], p_size[1])
+
+                # patches[i][x * n_y + y].show()
+        templates.append(Variable(torch.Tensor(template).expand(1, 1, -1, -1)))
+    return patches, coordinates, templates, sizes, ratios
+
+def patch2global(patches, n_class, sizes, coordinates, p_size,flag = 0):
+    '''
+    predicted patches (after classify layer) => predictions
+    return: list of np.array
+    '''
+    patches = np.array(torch.detach(patches).cpu().numpy())
+    predictions = [ np.zeros((n_class, size[0], size[1])) for size in sizes]
+
+    for i in range(len(sizes)):
+        for j in range(len(coordinates[i])):
+            top, left = coordinates[i][j]
+            top = int(np.round(top * sizes[i][0])); left = int(np.round(left * sizes[i][1]))
+
+            patches_tmp = np.zeros(patches[j][:,:,:].shape)
+            whole_img_tmp = predictions[i][:, top: top + p_size[0], left: left + p_size[1]]
+            #俩小块儿最大(max)的成为最终的prediction
+            #patches[j][:,:,:] 就是每个要贴到大图中的小块儿，whole_img_tmp是整个目标大图中对应patches_tmp的那一小块儿，然后将这俩及逆行比较，谁大就取谁
+            if flag == 0:
+                patches_tmp[patches[j][:, :, :] > whole_img_tmp] = patches[j][:,:,:][patches[j][:, :, :] > whole_img_tmp]  # 要贴上去的小块中的值大于大图中的值 patches[j][:, :, :] > whole_img_tmp
+                patches_tmp[patches[j][:, :, :] < whole_img_tmp] = whole_img_tmp[patches[j][:, :, :] < whole_img_tmp]  # 要贴上去的小块中的值小于于大图中的值 patches[j][:, :, :] < whole_img_tmp
+                predictions[i][:, top: top + p_size[0], left: left + p_size[1]] += patches_tmp
+            else:
+
+
+                predictions[i][:, top: top + p_size[0], left: left + p_size[1]] += patches[j][:, :, :]
+
+
+    return predictions
+
+
+if __name__ == '__main__':
+    images = []
+
+    img = Image.open(os.path.join(r"../train_valid/003DRIVE/image", f"01.png"))
+    images.append(img)
+    # print(len(images))  = 3
+    p_size = (224,224)
+    patches, coordinates, templates, sizes, ratios = global2patch(images, p_size)
+    # predictions = patch2global(patches, 3, sizes, coordinates, p_size)
+    # print(type(predictions))

AV/Tools/utils_test.py

@@ -0,0 +1,353 @@
+import cv2
+import numpy as np
+
+def paint_border_overlap(img, patch_h, patch_w, stride_h, stride_w):
+    img_h = img.shape[0]  #height of the full image
+    img_w = img.shape[1] #width of the full image
+    leftover_h = (img_h-patch_h)%stride_h  #leftover on the h dim
+    leftover_w = (img_w-patch_w)%stride_w  #leftover on the w dim
+    if (leftover_h != 0):  #change dimension of img_h
+        tmp_full_imgs = np.zeros((img_h+(stride_h-leftover_h),img_w, 3))
+        tmp_full_imgs[0:img_h,0:img_w, :] = img
+        img = tmp_full_imgs
+    if (leftover_w != 0):   #change dimension of img_w
+        tmp_full_imgs = np.zeros((img.shape[0], img_w+(stride_w - leftover_w), 3))
+        tmp_full_imgs[0:img.shape[0], 0:img_w, :] = img
+        img = tmp_full_imgs
+    return img
+
+def paint_border_overlap_trad(img, patch_h, patch_w, stride_h, stride_w):
+    img_h = img.shape[0]  #height of the full image
+    img_w = img.shape[1] #width of the full image
+    leftover_h = (img_h-patch_h)%stride_h  #leftover on the h dim
+    leftover_w = (img_w-patch_w)%stride_w  #leftover on the w dim
+    if (leftover_h != 0):  #change dimension of img_h
+        tmp_full_imgs = np.zeros((img_h+(stride_h-leftover_h),img_w, 2))
+        tmp_full_imgs[0:img_h,0:img_w, :] = img
+        img = tmp_full_imgs
+    if (leftover_w != 0):   #change dimension of img_w
+        tmp_full_imgs = np.zeros((img.shape[0], img_w+(stride_w - leftover_w), 2))
+        tmp_full_imgs[0:img.shape[0], 0:img_w, :] = img
+        img = tmp_full_imgs
+    return img
+
+def pred_only_FOV_AV(data_imgs1,data_imgs2,data_masks1,data_masks2,original_imgs_border_masks,threshold_confusion):
+    assert (len(data_imgs1.shape)==4 and len(data_masks1.shape)==4)  #4D arrays
+    assert (data_imgs1.shape[0]==data_masks1.shape[0])
+    assert (data_imgs1.shape[2]==data_masks1.shape[2])
+    assert (data_imgs1.shape[3]==data_masks1.shape[3])
+    assert (data_imgs1.shape[1]==1 and data_masks1.shape[1]==1)  #check the channel is 1
+    height = data_imgs1.shape[2]
+    width = data_imgs1.shape[3]
+    new_pred_imgs1 = []
+    new_pred_masks1 = []
+    new_pred_imgs2 = []
+    new_pred_masks2 = []
+    for i in range(data_imgs1.shape[0]):  #loop over the full images
+        for x in range(width):
+            for y in range(height):
+                if inside_FOV_DRIVE_AV(i,x,y,data_imgs1,data_imgs2,original_imgs_border_masks,threshold_confusion)==True:
+                    new_pred_imgs1.append(data_imgs1[i,:,y,x])
+                    new_pred_masks1.append(data_masks1[i,:,y,x])
+                    new_pred_imgs2.append(data_imgs2[i,:,y,x])
+                    new_pred_masks2.append(data_masks2[i,:,y,x])
+    new_pred_imgs1 = np.asarray(new_pred_imgs1)
+    new_pred_masks1 = np.asarray(new_pred_masks1)
+    new_pred_imgs2 = np.asarray(new_pred_imgs2)
+    new_pred_masks2 = np.asarray(new_pred_masks2)
+    return new_pred_imgs1, new_pred_masks1,new_pred_imgs2, new_pred_masks2
+
+def pred_only_FOV_AV(data_imgs1,data_imgs2,data_masks1,data_masks2,original_imgs_border_masks,threshold_confusion):
+    assert (len(data_imgs1.shape)==4 and len(data_masks1.shape)==4)  #4D arrays
+    assert (data_imgs1.shape[0]==data_masks1.shape[0])
+    assert (data_imgs1.shape[2]==data_masks1.shape[2])
+    assert (data_imgs1.shape[3]==data_masks1.shape[3])
+    assert (data_imgs1.shape[1]==1 and data_masks1.shape[1]==1)  #check the channel is 1
+    height = data_imgs1.shape[2]
+    width = data_imgs1.shape[3]
+    new_pred_imgs1 = []
+    new_pred_masks1 = []
+    new_pred_imgs2 = []
+    new_pred_masks2 = []
+    for i in range(data_imgs1.shape[0]):  #loop over the full images
+
+
+        for x in range(width):
+            for y in range(height):
+                if inside_FOV_DRIVE_AV(i,x,y,data_masks1,data_masks2,original_imgs_border_masks,threshold_confusion)==True:
+                    new_pred_imgs1.append(data_imgs1[i,:,y,x])
+                    new_pred_masks1.append(data_masks1[i,:,y,x])
+                    new_pred_imgs2.append(data_imgs2[i,:,y,x])
+                    new_pred_masks2.append(data_masks2[i,:,y,x])
+    new_pred_imgs1 = np.asarray(new_pred_imgs1)
+    new_pred_masks1 = np.asarray(new_pred_masks1)
+    new_pred_imgs2 = np.asarray(new_pred_imgs2)
+    new_pred_masks2 = np.asarray(new_pred_masks2)
+    return new_pred_imgs1, new_pred_masks1,new_pred_imgs2, new_pred_masks2
+
+
+
+def inside_FOV_DRIVE_AV(i, x, y,data_imgs1,data_imgs2, DRIVE_masks,threshold_confusion):
+    assert (len(DRIVE_masks.shape)==4)  #4D arrays
+    assert (DRIVE_masks.shape[1]==1)  #DRIVE masks is black and white
+    # DRIVE_masks = DRIVE_masks/255.  #NOOO!! otherwise with float numbers takes forever!!
+
+    if (x >= DRIVE_masks.shape[3] or y >= DRIVE_masks.shape[2]): #my image bigger than the original
+        return False
+
+    if (DRIVE_masks[i,0,y,x]>0)&((data_imgs1[i,0,y,x]>threshold_confusion)|(data_imgs2[i,0,y,x]>threshold_confusion)):  #0==black pixels
+        # print DRIVE_masks[i,0,y,x]  #verify it is working right
+        return True
+    else:
+        return False
+
+def extract_ordered_overlap_trad(img, patch_h, patch_w,stride_h,stride_w,ratio):
+    img_h = img.shape[0]  #height of the full image
+    img_w = img.shape[1] #width of the full image
+    assert ((img_h-patch_h)%stride_h==0 and (img_w-patch_w)%stride_w==0)
+    N_patches_img = ((img_h-patch_h)//stride_h+1)*((img_w-patch_w)//stride_w+1)  #// --> division between integers
+    patches = np.empty((N_patches_img, patch_h//ratio, patch_w//ratio, 2))
+    iter_tot = 0   #iter over the total number of patches (N_patches)
+    for h in range((img_h-patch_h)//stride_h+1):
+        for w in range((img_w-patch_w)//stride_w+1):
+            patch = img[h*stride_h:(h*stride_h)+patch_h, w*stride_w:(w*stride_w)+patch_w, :]
+            patch = cv2.resize(patch,(patch_h//ratio, patch_w//ratio))
+            patches[iter_tot]=patch
+            iter_tot +=1   #total
+    assert (iter_tot==N_patches_img)
+    return patches  #array with all the img divided in patches
+
+def make_pad(Patches,pad,sign='',normalize=True):
+    # h,w,3
+    mean = [0.485, 0.456, 0.406]
+    std = [0.229, 0.224, 0.225]
+    if pad<=0:
+        return Patches
+    p = np.zeros((256,256,3),dtype=np.float32)
+    if sign=='img' and normalize:
+        p[:,:,0] = (p[:,:,0] - mean[0]) / std[0]
+        p[:,:,1] = (p[:,:,1] - mean[1]) / std[1]
+        p[:,:,2] = (p[:,:,2] - mean[2]) / std[2]
+    p[:Patches.shape[0],:Patches.shape[1],:] = Patches
+    return p
+
+def extract_ordered_overlap_big(img, patch_h=256, patch_w=256, stride_h=256, stride_w=256):
+    img_h = img.shape[0]  #height of the full image
+    img_w = img.shape[1] #width of the full image
+
+    big_patch_h = int(patch_h * 1.5)
+    big_patch_w = int(patch_w * 1.5)
+    assert ((img_h-patch_h)%stride_h==0 and (img_w-patch_w)%stride_w==0)
+    N_patches_img = ((img_h-patch_h)//stride_h+1)*((img_w-patch_w)//stride_w+1)  #// --> division between integers
+    patches = np.empty((N_patches_img, patch_h, patch_w, 3) )
+    patches_big = np.empty((N_patches_img, patch_h, patch_w, 3))
+    img_big = np.zeros((img_h+(big_patch_h-patch_h), img_w+(big_patch_w-patch_w), 3))
+
+    img_big[(big_patch_h-patch_h)//2:(big_patch_h-patch_h)//2+img_h, (big_patch_w-patch_w)//2:(big_patch_w-patch_w)//2+img_w, :] = img
+
+    iter_tot = 0   #iter over the total number of patches (N_patches)
+    for h in range((img_h-patch_h)//stride_h+1):
+        for w in range((img_w-patch_w)//stride_w+1):
+            patch = img[h*stride_h:(h*stride_h)+patch_h, w*stride_w:(w*stride_w)+patch_w, :]
+            #patch = cv2.resize(patch,(256, 256))
+            patches[iter_tot] = patch
+            if np.unique(patch).shape[0] == 1:
+                patches_big[iter_tot] = patch
+            else:
+                patch_big = img_big[h*stride_h:h*stride_h+big_patch_h, w*stride_w:w*stride_w+big_patch_w, :]
+                # print(patch_big.shape)
+                patch_big = cv2.resize(patch_big,(patch_h, patch_w))
+                patches_big[iter_tot] = patch_big
+
+            iter_tot += 1  # total
+    assert (iter_tot == N_patches_img)
+    return patches, patches_big  # array with all the img divided in patches
+
+def extract_ordered_overlap_big_v2(img, patch_h=256, patch_w=256, stride_h=256, stride_w=256):
+    img_h = img.shape[0]  #height of the full image
+    img_w = img.shape[1] #width of the full image
+    assert ((img_h-patch_h)%stride_h==0 and (img_w-patch_w)%stride_w==0)
+    N_patches_img = ((img_h-patch_h)//stride_h+1)*((img_w-patch_w)//stride_w+1)  #// --> division between integers
+    patches = np.empty((N_patches_img, 256, 256, 3))
+    patches_big = np.empty((N_patches_img, 256, 256, 3))
+
+    iter_tot = 0   #iter over the total number of patches (N_patches)
+    for h in range((img_h-patch_h)//stride_h+1):
+        for w in range((img_w-patch_w)//stride_w+1):
+            patch = img[h*stride_h:(h*stride_h)+patch_h, w*stride_w:(w*stride_w)+patch_w, :]
+            pad = max(0,256-patch_h)
+            patch = make_pad(patch,pad,normalize=False)
+            #patch = cv2.resize(patch,(256, 256))
+            patches[iter_tot]=patch
+
+            # patch_big = img[max(0,h*stride_h-patch_h//4):min((h*stride_h)+patch_h+patch_h//4,img_h),max(0,w*stride_w-patch_w//4):min((w*stride_w)+patch_w+patch_w//4,img_w), :]
+            if h==0 and w==0:
+                patch_big = img[0:patch_h+patch_h//2, 0:patch_w+patch_w//2, :]
+
+            elif h==0 and w!=0 and w!=((img_w-patch_w)//stride_w):
+                patch_big = img[0:0+patch_h+patch_h//2, w*stride_w-patch_w//4:(w*stride_w)+patch_w+patch_w//4, :]
+            elif h==0 and w==((img_w-patch_w)//stride_w):
+                patch_big = img[0:0+patch_h+patch_h//2, (w)*stride_w-patch_w//2:(w*stride_w)+patch_w, :]
+            elif h!=0 and h!=((img_h-patch_h)//stride_h) and w==0:
+                patch_big = img[h*stride_h-patch_h//4:(h*stride_h)+patch_h+patch_h//4, 0:0+patch_w+patch_w//2, :]
+
+            elif h==((img_h-patch_h)//stride_h) and w==0:
+                patch_big = img[(h)*stride_h-patch_h//2:(h*stride_h)+patch_h, 0:patch_w+patch_w//2, :]
+            elif h==((img_h-patch_h)//stride_h) and w!=0 and w!=((img_w-patch_w)//stride_w):
+                patch_big = img[h*stride_h-patch_h//2:(h*stride_h)+patch_h, w*stride_w-patch_w//4:(w*stride_w)+patch_w+patch_w//4, :]
+            elif h==((img_h-patch_h)//stride_h) and w==((img_w-patch_w)//stride_w):
+                patch_big = img[h*stride_h-patch_h//2:(h*stride_h)+patch_h, (w)*stride_w-patch_w//2:(w*stride_w)+patch_w, :]
+            elif h!=0 and h!=((img_h-patch_h)//stride_h) and w==((img_w-patch_w)//stride_w):
+                patch_big = img[h*stride_h-patch_h//4:(h*stride_h)+patch_h+patch_h//4, (w)*stride_w-patch_w//2:(w*stride_w)+patch_w, :]
+            else:
+                patch_big = img[h*stride_h-patch_h//4:(h*stride_h)+patch_h+patch_h//4,w*stride_w-patch_w//4:(w*stride_w)+patch_w+patch_w//4, :]
+            # print(patch_big.shape)
+            patch_big = cv2.resize(patch_big,(256, 256))
+
+            patches_big[iter_tot]=patch_big
+
+            iter_tot +=1   #total
+    assert (iter_tot==N_patches_img)
+    return patches,patches_big  #array with all the img divided in patches
+
+
+def extract_ordered_overlap_big_v1(img, patch_h, patch_w,stride_h,stride_w):
+    img_h = img.shape[0]  #height of the full image
+    img_w = img.shape[1] #width of the full image
+    assert ((img_h-patch_h)%stride_h==0 and (img_w-patch_w)%stride_w==0)
+    N_patches_img = ((img_h-patch_h)//stride_h+1)*((img_w-patch_w)//stride_w+1)  #// --> division between integers
+    patches = np.empty((N_patches_img, patch_h, patch_w, 3))
+    patches_big = np.empty((N_patches_img, patch_h, patch_w, 3))
+
+    iter_tot = 0   #iter over the total number of patches (N_patches)
+    for h in range((img_h-patch_h)//stride_h+1):
+        for w in range((img_w-patch_w)//stride_w+1):
+            patch = img[h*stride_h:(h*stride_h)+patch_h, w*stride_w:(w*stride_w)+patch_w, :]
+            #patch = cv2.resize(patch,(256, 256))
+            patches[iter_tot]=patch
+            if h==0 and w==0:
+                patch_big = img[h*stride_h:(h*stride_h)+patch_h+stride_h, w*stride_w:(w*stride_w)+patch_w+stride_w, :]
+            elif h==0 and w!=0 and w!=((img_w-patch_w)//stride_w):
+                patch_big = img[h*stride_h:(h*stride_h)+patch_h+stride_h, int((w-0.5)*stride_w):(w*stride_w)+patch_w+stride_w//2, :]
+            elif h==0 and w==((img_w-patch_w)//stride_w):
+                patch_big = img[h*stride_h:(h*stride_h)+patch_h+stride_h, (w-1)*stride_w:(w*stride_w)+patch_w, :]
+            elif h!=0 and h!=((img_h-patch_h)//stride_h) and w==0:
+                patch_big = img[int((h-0.5)*stride_h):(h*stride_h)+patch_h+stride_h//2, w*stride_w:(w*stride_w)+patch_w+stride_w, :]
+
+            elif h==((img_h-patch_h)//stride_h) and w==0:
+                patch_big = img[(h-1)*stride_h:(h*stride_h)+patch_h, w*stride_w:(w*stride_w)+patch_w+stride_w, :]
+            elif h==((img_h-patch_h)//stride_h) and w!=0 and w!=((img_w-patch_w)//stride_w):
+                patch_big = img[(h-1)*stride_h:(h*stride_h)+patch_h, int((w-0.5)*stride_w):(w*stride_w)+patch_w+stride_w//2, :]
+            elif h==((img_h-patch_h)//stride_h) and w==((img_w-patch_w)//stride_w):
+                patch_big = img[(h-1)*stride_h:(h*stride_h)+patch_h, (w-1)*stride_w:(w*stride_w)+patch_w, :]
+            elif h!=0 and h!=((img_h-patch_h)//stride_h) and w==((img_w-patch_w)//stride_w):
+                patch_big = img[int((h-0.5)*stride_h):(h*stride_h)+patch_h+stride_h//2, (w-1)*stride_w:(w*stride_w)+patch_w, :]
+            else:
+                patch_big = img[int((h-0.5)*stride_h):(h*stride_h)+patch_h+stride_h//2, int((w-0.5)*stride_w):(w*stride_w)+patch_w+stride_w//2, :]
+
+            patch_big = cv2.resize(patch_big,(256, 256))
+
+            patches_big[iter_tot]=patch_big
+
+            iter_tot +=1   #total
+    assert (iter_tot==N_patches_img)
+    return patches,patches_big  #array with all the img divided in patches
+
+
+
+
+
+def pred_to_imgs(pred,mode="original"):
+     assert (len(pred.shape)==3)  #3D array: (Npatches,height*width,2)
+     assert (pred.shape[2]==2 )  #check the classes are 2
+     pred_images = np.empty((pred.shape[0],pred.shape[1]))  #(Npatches,height*width)
+     if mode=="original":
+         for i in range(pred.shape[0]):
+             for pix in range(pred.shape[1]):
+                 pred_images[i,pix]=pred[i,pix,1]
+     elif mode=="threshold":
+         for i in range(pred.shape[0]):
+             for pix in range(pred.shape[1]):
+                 if pred[i,pix,1]>=0.5:
+                     pred_images[i,pix]=1
+                 else:
+                     pred_images[i,pix]=0
+     else:
+         print("mode " +str(mode) +" not recognized, it can be 'original' or 'threshold'")
+         exit()
+     pred_images = np.reshape(pred_images,(pred_images.shape[0],1,48,48))
+     return pred_images
+
+def recompone_overlap(pred_patches, img_h, img_w, stride_h, stride_w):
+    assert (len(pred_patches.shape)==4)  #4D arrays
+    #assert (pred_patches.shape[1]==2 or pred_patches.shape[1]==3)  #check the channel is 1 or 3
+    patch_h = pred_patches.shape[2]
+    patch_w = pred_patches.shape[3]
+    N_patches_h = (img_h-patch_h)//stride_h+1
+    N_patches_w = (img_w-patch_w)//stride_w+1
+    N_patches_img = N_patches_h * N_patches_w
+    #assert (pred_patches.shape[0]%N_patches_img==0)
+    #N_full_imgs = pred_patches.shape[0]//N_patches_img
+    full_prob = np.zeros((pred_patches.shape[1], img_h,img_w,))  #itialize to zero mega array with sum of Probabilities
+    full_sum = np.zeros((pred_patches.shape[1], img_h,img_w))
+
+    k = 0 #iterator over all the patches
+    for h in range(N_patches_h):
+        for w in range(N_patches_w):
+            full_prob[:, h*stride_h:(h*stride_h)+patch_h, w*stride_w:(w*stride_w)+patch_w]+=pred_patches[k]
+            full_sum[:, h*stride_h:(h*stride_h)+patch_h, w*stride_w:(w*stride_w)+patch_w]+=1
+            k+=1
+    assert(k==pred_patches.shape[0])
+    assert(np.min(full_sum)>=1.0)  #at least one
+    final_avg = full_prob/full_sum
+    #print(final_avg.shape)
+    # assert(np.max(final_avg)<=1.0) #max value for a pixel is 1.0
+    # assert(np.min(final_avg)>=0.0) #min value for a pixel is 0.0
+    return final_avg
+
+
+def Normalize(Patches):
+    mean = [0.485, 0.456, 0.406]
+    std = [0.229, 0.224, 0.225]
+
+    # mean = [0.3261, 0.2287, 0.1592]
+    # std = [0.2589, 0.1882, 0.1369]
+
+
+    Patches[:,0,:,:] = (Patches[:,0,:,:] - mean[0]) / std[0]
+    Patches[:,1,:,:] = (Patches[:,1,:,:] - mean[1]) / std[1]
+    Patches[:,2,:,:] = (Patches[:,2,:,:] - mean[2]) / std[2]
+    return Patches
+
+def Normalize_patch(Patches):
+    mean = [0.485, 0.456, 0.406]
+    std = [0.229, 0.224, 0.225]
+
+    Patches[0,:,:] = (Patches[0,:,:] - mean[0]) / std[0]
+    Patches[1,:,:] = (Patches[1,:,:] - mean[1]) / std[1]
+    Patches[2,:,:] = (Patches[2,:,:] - mean[2]) / std[2]
+    return Patches
+
+def sigmoid(x):
+  return np.exp((x)) / (1 + np.exp(x))
+
+def inside_FOV_DRIVE(x, y, DRIVE_masks):
+    # DRIVE_masks = DRIVE_masks/255.  #NOOO!! otherwise with float numbers takes forever!!
+    if (x >= DRIVE_masks.shape[1] or y >= DRIVE_masks.shape[0]): #my image bigger than the original
+        return False
+
+    if (DRIVE_masks[y,x]>0):  #0==black pixels
+        return True
+    else:
+        return False
+
+
+def kill_border(pred_img, border_masks):
+    height = pred_img.shape[1]
+    width = pred_img.shape[2]
+    for x in range(width):
+        for y in range(height):
+            if inside_FOV_DRIVE(x,y, border_masks)==False:
+                pred_img[:,y,x]=0.0
+    return pred_img
+

AV/Tools/warmup.py

@@ -0,0 +1,69 @@
+
+
+import torch
+from torch.optim.lr_scheduler import StepLR, ExponentialLR
+
+class GradualWarmupScheduler(torch.optim.lr_scheduler._LRScheduler):
+    """ Gradually warm-up(increasing) learning rate in optimizer.
+    Proposed in 'Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour'.
+
+    Args:
+        optimizer (Optimizer): Wrapped optimizer.
+        multiplier: target learning rate = base lr * multiplier if multiplier > 1.0. if multiplier = 1.0, lr starts from 0 and ends up with the base_lr.
+        total_epoch: target learning rate is reached at total_epoch, gradually
+        after_scheduler: after target_epoch, use this scheduler(eg. ReduceLROnPlateau)
+    """
+
+    def __init__(self, optimizer, multiplier, total_epoch, after_scheduler=None):
+        self.multiplier = multiplier
+        if self.multiplier < 1.:
+            raise ValueError('multiplier should be greater thant or equal to 1.')
+        self.total_epoch = total_epoch
+        self.after_scheduler = after_scheduler
+        self.finished = False
+        super(GradualWarmupScheduler, self).__init__(optimizer)
+
+    def get_lr(self):
+        if self.last_epoch > self.total_epoch:
+            if self.after_scheduler:
+                if not self.finished:
+                    self.after_scheduler.base_lrs = [base_lr * self.multiplier for base_lr in self.base_lrs]
+                    self.finished = True
+                return self.after_scheduler.get_last_lr()
+            return [base_lr * self.multiplier for base_lr in self.base_lrs]
+
+        if self.multiplier == 1.0:
+            return [base_lr * (float(self.last_epoch) / self.total_epoch) for base_lr in self.base_lrs]
+        else:
+            return [base_lr * ((self.multiplier - 1.) * self.last_epoch / self.total_epoch + 1.) for base_lr in self.base_lrs]
+
+
+    def step(self, epoch=None, metrics=None):
+
+        if self.finished and self.after_scheduler:
+            if epoch is None:
+                self.after_scheduler.step()
+            else:
+                self.after_scheduler.step()
+            self._last_lr = self.after_scheduler.get_last_lr()
+        else:
+            return super(GradualWarmupScheduler, self).step(epoch)
+
+
+if __name__ == '__main__':
+    model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
+    optim = torch.optim.Adam(model, 0.0002)
+
+    # scheduler_warmup is chained with schduler_steplr
+    scheduler_steplr = StepLR(optim, step_size=80, gamma=0.1)
+    scheduler_warmup = GradualWarmupScheduler(optim, multiplier=2, total_epoch=10, after_scheduler=scheduler_steplr)
+
+    # this zero gradient update is needed to avoid a warning message, issue #8.
+    optim.zero_grad()
+    optim.step()
+
+    for epoch in range(1, 20):
+        scheduler_warmup.step(epoch)
+        print(epoch, optim.param_groups[0]['lr'])
+
+        optim.step()

AV/config/config_test_general.py

@@ -0,0 +1,134 @@
+import torch
+import os
+
+# Check GPU availability
+use_cuda = torch.cuda.is_available()
+gpu_ids = [0] if use_cuda else []
+device = torch.device('cuda' if use_cuda else 'cpu')
+
+dataset_name = 'all'  # DRIVE
+#dataset_name = 'LES'  # LES
+# dataset_name = 'hrf'  # HRF
+# dataset_name = 'ukbb'  # UKBB
+# dataset_name = 'all'
+dataset = dataset_name
+max_step = 30000  # 30000 for ukbb
+
+batch_size = 8  # default: 4
+print_iter = 100  # default: 100
+display_iter = 100  # default: 100
+save_iter = 5000  # default: 5000
+first_display_metric_iter = max_step - save_iter  # default: 25000
+lr = 0.0002  # if dataset_name!='LES' else 0.00005 # default: 0.0002
+step_size = 7000  # 7000 for DRIVE
+lr_decay_gamma = 0.5  # default: 0.5
+use_SGD = False  # default:False
+
+input_nc = 3
+ndf = 32
+netD_type = 'basic'
+n_layers_D = 5
+norm = 'instance'
+no_lsgan = False
+init_type = 'normal'
+init_gain = 0.02
+use_sigmoid = no_lsgan
+use_noise_input_D = False
+use_dropout_D = False
+# torch.cuda.set_device(gpu_ids[0])
+use_GAN = True  # default: True
+
+# adam
+beta1 = 0.5
+
+# settings for GAN loss
+num_classes_D = 1
+lambda_GAN_D = 0.01
+lambda_GAN_G = 0.01
+lambda_GAN_gp = 100
+lambda_BCE = 5
+lambda_DICE = 5
+
+input_nc_D = input_nc + 3
+
+# settings for centerness
+use_centerness = True  # default: True
+lambda_centerness = 1
+center_loss_type = 'centerness'
+centerness_map_size = [128, 128]
+
+# pretrained model
+use_pretrained_G = True
+use_pretrained_D = False
+# model_path_pretrained_G = './log/patch_pretrain'
+model_path_pretrained_G = ''
+model_step_pretrained_G = 0
+stride_height = 0
+stride_width = 0
+patch_size_list=[]
+
+def set_dataset(name):
+    global dataset_name, model_path_pretrained_G, model_step_pretrained_G
+    global stride_height, stride_width,patch_size,patch_size_list,dataset
+    dataset_name = name
+    dataset = name
+    if dataset_name == 'DRIVE':
+        model_path_pretrained_G = './AV/log/DRIVE-2023_10_20_08_36_50(6500)'
+        model_step_pretrained_G = 6500
+    elif dataset_name == 'LES':
+        model_path_pretrained_G = './AV/log/LES-2023_09_28_14_04_06(0)'
+        model_step_pretrained_G = 0
+    elif dataset_name == 'hrf':
+        model_path_pretrained_G = './AV/log/HRF-2023_10_19_11_07_31(1500)'
+        model_step_pretrained_G = 1500
+    elif dataset_name == 'ukbb':
+        model_path_pretrained_G = './AV/log/UKBB-2023_11_02_23_22_07(5000)'
+        model_step_pretrained_G = 5000
+    else:
+        model_path_pretrained_G = './AV/log/ALL-2024_09_06_09_17_18(9000)'
+        model_step_pretrained_G = 9000
+    if dataset_name == 'DRIVE':
+        patch_size_list = [64, 128, 256]
+    elif dataset_name == 'LES':
+        patch_size_list = [96, 384, 256]
+    elif dataset_name == 'hrf':
+        patch_size_list = [64, 384, 256]
+    elif dataset_name == 'ukbb':
+        patch_size_list = [96, 384, 256]
+    else:
+        patch_size_list = [96, 384, 512]
+    patch_size = patch_size_list[2]
+
+# path for dataset
+    if dataset_name == 'DRIVE' or dataset_name == 'LES' or dataset_name == 'hrf':
+        stride_height = 50
+        stride_width = 50
+    else:
+        stride_height = 150
+        stride_width = 150
+
+n_classes = 3
+
+model_step = 0
+
+# use CAM
+use_CAM = False
+
+#use resize
+use_resize = True
+resize_w_h = (1920,512)
+
+# use av_cross
+use_av_cross = False
+
+use_high_semantic = False
+lambda_high = 1  # A,V,Vessel
+
+# use global semantic
+use_global_semantic = False
+global_warmup_step = 0 if use_pretrained_G else 5000
+
+
+
+
+

AV/config/config_train_general.py

@@ -0,0 +1,121 @@
+import torch
+import os
+
+# Check GPU availability
+use_cuda = torch.cuda.is_available()
+gpu_ids = [0] if use_cuda else []
+device = torch.device('cuda' if use_cuda else 'cpu')
+
+
+dataset_name = 'DRIVE'  # DRIVE
+#dataset_name = 'LES'  # LES
+#dataset_name = 'hrf'  # HRF
+dataset = dataset_name
+
+max_step = 30000  # 30000 for ukbb
+if dataset_name=='DRIVE':
+    patch_size_list = [64, 128, 256]
+elif dataset_name=='LES':
+    patch_size_list = [96,384, 256]
+elif dataset_name=='hrf':
+    patch_size_list = [64, 384, 256]
+patch_size = patch_size_list[2]
+batch_size = 8 # default: 4
+print_iter = 100 # default: 100
+display_iter = 100 # default: 100
+save_iter = 5000 # default: 5000
+first_display_metric_iter = max_step-save_iter # default: 25000
+lr = 0.0002 #if dataset_name!='LES' else 0.00005 # default: 0.0002
+step_size = 7000  # 7000 for DRIVE
+lr_decay_gamma = 0.5  # default: 0.5
+use_SGD = False # default:False
+
+input_nc = 3
+ndf = 32
+netD_type = 'basic'
+n_layers_D = 5
+norm = 'instance'
+no_lsgan = False
+init_type = 'normal'
+init_gain = 0.02
+use_sigmoid = no_lsgan
+use_noise_input_D = False
+use_dropout_D = False
+
+# torch.cuda.set_device(gpu_ids[0])
+use_GAN = True # default: True
+
+# adam
+beta1 = 0.5
+
+# settings for GAN loss
+num_classes_D = 1
+lambda_GAN_D = 0.01
+lambda_GAN_G = 0.01
+lambda_GAN_gp = 100
+lambda_BCE = 5
+lambda_DICE = 5
+
+input_nc_D = input_nc + 3
+
+# settings for centerness
+use_centerness =True # default: True
+lambda_centerness = 1
+center_loss_type = 'centerness'
+centerness_map_size =  [128,128]
+
+# pretrained model
+use_pretrained_G =  True
+use_pretrained_D = False
+
+model_path_pretrained_G = r"../RIP/weight"
+
+model_step_pretrained_G = 'best_drive'
+
+
+# path for dataset
+stride_height = 50
+stride_width = 50
+
+
+n_classes = 3
+
+model_step = 0
+
+# use CAM
+use_CAM = False
+
+#use resize
+use_resize = False
+resize_w_h = (256,256)
+
+#use av_cross
+use_av_cross = False
+
+use_high_semantic = False
+lambda_high = 1 # A,V,Vessel
+
+# use global semantic
+use_global_semantic = True
+global_warmup_step = 0 if use_pretrained_G else 5000
+
+# use network
+use_network = 'convnext_tiny' # swin_t,convnext_tiny
+
+dataset_path = {'DRIVE': './data/AV_DRIVE/training/',
+
+                'hrf': './data/hrf/training/',
+
+                'LES': './data/LES_AV/training/',
+
+                }
+trainset_path = dataset_path[dataset_name]
+
+
+print("Dataset:")
+print(trainset_path)
+print(use_network)
+
+
+
+

AV/log/ALL-2024_09_06_09_17_18(9000)/G_9000.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15bff178940810286c7df89a4ac416a167a3f2a14c015ce3bf3a4c65b082ae49
+size 115842242

AV/log/DRIVE-2023_10_20_08_36_50(6500)/G_6500.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c2f29a05c014e372e9f3421b34df62cf3a557b9f4834da27e37c555a4f465d5
+size 115848956

AV/log/HRF-2023_10_19_11_07_31(1500)/G_1500.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:325ce3ee74ecd9fb1c554fe810f70e471595e2f521b5fb094a34a682846efb7d
+size 115848956

AV/log/LES-2023_09_28_14_04_06(0)/G_0.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21d2261e124773dfe15113c2bb9c4e16c59988c99613cba68e0209a69be7a770
+size 115830579