initial code commit

README.md

@@ -1,6 +1,6 @@
 ---
 title: Glacuma Detection
-emoji: 🚀
+emoji: 👀
 colorFrom: blue
 colorTo: yellow
 sdk: gradio

app.py

@@ -0,0 +1,174 @@
+import torch
+import torchvision.transforms as transforms
+from torch.nn import functional as F
+import cv2
+import gradio as gr
+import numpy as np
+from PIL import Image
+from pipline import Transformer_Regression, extract_regions_Last , compute_ratios
+
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+## Define some parameters
+image_shape = 384     #### 512 got 87
+batch_size=1
+dim_patch=4
+num_classes=3
+label_smoothing=0.1
+scale=1
+import time
+start = time.time()
+torch.manual_seed(0)
+#import random
+
+
+tfms = transforms.Compose([
+    transforms.Resize((image_shape, image_shape)),
+    transforms.ToTensor(),
+    transforms.Normalize(0.5,0.5)
+    #transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
+    #transforms.Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711))
+
+])
+
+def Final_Compute_regression_results_Sample(Model, batch_sampler,num_head=2):
+    Model.eval()
+    score_cup = []
+    score_disc = []
+    yreg_pred = []
+    yreg_true = []
+    with torch.no_grad():
+        #for batch_sampler in loader:
+            train_batch_tfms = batch_sampler['image'].to(device=device)
+            #ytrue_seg = batch_sampler['image_original'] #.detach().cpu().numpy()
+            ytrue_seg = batch_sampler['image_original']  # .detach().cpu().numpy()
+            scores = Model(train_batch_tfms.unsqueeze(0))
+
+            yseg_pred = F.interpolate(scores['seg'], size=(ytrue_seg.shape[0], ytrue_seg.shape[1]), mode='bilinear',
+                                      align_corners=True)
+
+
+            # Regions_crop=extract_regions_Last(np.array(batch_sampler['image_original'][0]),yseg_pred[0].detach().cpu().numpy())
+            Regions_crop = extract_regions_Last(np.array(batch_sampler['image_original']),
+                                        yseg_pred.argmax(1).long()[0].detach().cpu().numpy())
+            Regions_crop['image'] = Image.fromarray(np.uint8(Regions_crop['image'])).convert('RGB')
+
+            ### Get back if two heads
+            ytrue_seg_crop = ytrue_seg[Regions_crop['cord'][0]:Regions_crop['cord'][1],
+                     Regions_crop['cord'][2]:Regions_crop['cord'][3]]
+            ytrue_seg_crop = np.expand_dims(ytrue_seg_crop, axis=0)
+
+            if num_head==2:
+                scores = Model((tfms(Regions_crop['image']).unsqueeze(0)).to(device))
+                yseg_pred_crop = F.interpolate(scores['seg_aux_1'], size=(ytrue_seg_crop.shape[1], ytrue_seg_crop.shape[2]),
+                                           mode='bilinear', align_corners=True)
+                yseg_pred[:, :, Regions_crop['cord'][0]:Regions_crop['cord'][1],
+                Regions_crop['cord'][2]:Regions_crop['cord'][3]] = yseg_pred_crop
+            # yseg_pred[:, :, Regions_crop['cord'][0]:Regions_crop['cord'][1],
+            # Regions_crop['cord'][2]:Regions_crop['cord'][3]]+yseg_pred_crop
+            yseg_pred = torch.softmax(yseg_pred, dim=1)
+            yseg_pred = yseg_pred.argmax(1).long()
+            yseg_pred = ((yseg_pred).long()).detach().cpu().numpy()
+            ratios = compute_ratios(yseg_pred[0])
+            yreg_pred.append(ratios.vcdr)
+
+            ### Plot
+            p_img = batch_sampler['image'].to(device=device).unsqueeze(0)
+            p_img = F.interpolate(p_img, size=(yseg_pred.shape[1], yseg_pred.shape[2]),
+                                   mode='bilinear', align_corners=True)
+            ### Get reversed image
+            image_orig = (p_img[0] * 0.5 + 0.5).permute(1, 2, 0).detach().cpu().numpy()
+            image_orig=np.uint8(image_orig*255)
+            ####
+            # train_batch_tfms
+            #plt.imshow(image_orig)
+            # make a copy as these operations are destructive
+            image_cont = image_orig.copy()
+            ###### plot for Prediction....
+            # threshold for 2 value
+            ret, thresh = cv2.threshold(np.uint8(yseg_pred[0]), 1, 2, 0)
+            # find and draw contour for 2 value (red)
+            conts, hir = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+            cv2.drawContours(image_cont, conts, -1, (0, 255, 0), 2)
+            #threshold for 1 value
+            ret, thresh = cv2.threshold(np.uint8(yseg_pred[0]), 0, 2, 0)
+            #find and draw contour for 1 value (blue)
+            conts, hir = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+            cv2.drawContours(image_cont, conts, -1, (0, 0, 255), 2)
+            #plot contoured image
+
+            # plt.imshow(image_cont)
+            # plt.axis('off')
+
+            # print('Vertical cup to disc ratio:')
+            # print(ratios.vcdr)
+            if True:
+                glaucoma = 'not implemented'
+            # print('Galucoma:')
+
+
+    return image_cont, ratios.vcdr, glaucoma, Regions_crop
+
+#load model
+DeepLab=Transformer_Regression(image_dim=image_shape,dim_patch=dim_patch,num_classes=3,scale=scale,feat_dim=128)
+DeepLab.to(device=device)
+DeepLab.load_state_dict(torch.load("TrainAll_Maghrabi84_50iteration_SWIN.pth.tar"))
+
+def infer(img):
+    # img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+    sample_batch = dict()
+
+    sample_batch['image_original'] = img
+
+    im_retina_pil = Image.fromarray(img)
+
+    im_retina_pil = tfms(im_retina_pil)
+    sample_batch['image'] = im_retina_pil
+
+    # plt.figure('Head2')
+    result, ratio, diagnosis, cropped = Final_Compute_regression_results_Sample(DeepLab, sample_batch, num_head=2)
+
+    # cropped = cv2.cvtColor(np.asarray(cropped), cv2.COLOR_BGR2RGB)
+    cropped = result[cropped['cord'][0] -100 :cropped['cord'][1] +100,
+                     cropped['cord'][2] -100 :cropped['cord'][3] +100]
+
+    return ratio, diagnosis, result, cropped
+
+
+title = "Glaucoma detection"
+description = "Using vertical ratio"
+
+outputs = [gr.Textbox(label="Vertical cup to disc ratio:"), gr.Textbox(label="predicted diagnosis"), gr.Image(label='labeled image'), gr.Image(label='zoomed in')]
+with gr.Blocks(css='#title {text-align : center;} ') as demo:
+    with gr.Row():
+        gr.Markdown(
+            f'''
+            # {title}
+            {description}
+
+            ''',
+            elem_id='title'
+        )
+    with gr.Row():
+        with gr.Column():
+            prompt = gr.Image(label="Enter Your Retina Image")
+            btn = gr.Button(value='Submit')
+            examples = gr.Examples(
+                ['M00027.png','M00056.png','M00073.png','M00093.png', 'M00018.png', 'M00034.png'],
+                inputs=[prompt], fn=infer, outputs=[outputs], cache_examples=False)
+        with gr.Column():
+            with gr.Row():
+                text1 = gr.Textbox(label="Vertical cup to disc ratio:")
+                text2 = gr.Textbox(label="predicted diagnosis")
+            img = gr.Image(label='labeled image')
+            zoom = gr.Image(label='zoomed in')
+
+            outputs = [text1,text2,img,zoom]
+
+            btn.click(fn=infer, inputs=prompt, outputs=outputs)
+
+
+if __name__ == '__main__':
+    demo.launch()

pipline.py

@@ -0,0 +1,222 @@
+#### This is an implmentation of deeplabv3 plus for retina detection
+import torch
+import torchvision
+from torch.nn import functional as F
+import torch.nn as nn
+import numpy as np
+import cv2
+from skimage.measure import label, regionprops
+import torch
+from collections import namedtuple
+
+# check you have the right version of timm
+# assert timm.__version__ == "0.3.2"
+from timm.models.swin_transformer import swin_base_patch4_window12_384_in22k
+
+torch.manual_seed(0)
+device = "cuda" if torch.cuda.is_available() else "cpu"
+pad_value = 10
+
+
+def extract_regions_Last(img_test, ytruth, pad1=pad_value, pad2=pad_value, pad3=pad_value, pad4=pad_value):
+
+    y_truth_copy = ytruth.copy()
+    y_truth_copy[y_truth_copy == 2] = 1
+    label_img = label(y_truth_copy)
+
+    regions = regionprops(label_img)
+    max_Area = -1
+    cropped_results = dict()
+    for props in regions:
+        if props.area > max_Area:
+            max_Area = props.area
+            minr, minc, maxr, maxc = props.bbox
+            bx = (minc, maxc, maxc, minc, minc)
+            by = (minr, minr, maxr, maxr, minr)
+            # print(minr,maxr)
+            # print(bx)
+            # ax.plot(bx, by, '-b', linewidth=2.5)
+            # cropped_image= pred_class[minr-pad:maxr+pad, minc-pad:maxc+pad]
+            # cropped_pred_mask = pred_class[minr - pad:maxr + pad, minc - pad:maxc + pad]
+            if minr - pad1 < 0:
+                pad1 = 5
+                if minr - pad1 < 0:
+                    pad1 = 0
+
+            if minc - pad2 < 0:
+                pad2 = 5
+                if minc - pad2 < 0:
+                    pad2 = 0
+            if maxr + pad3 > label_img.shape[0]:
+                pad3 = 5
+                if maxr + pad3 > label_img.shape[0]:
+                    pad3 = 0
+
+            if maxc + pad4 > label_img.shape[1]:
+                pad4 = 5
+                if maxc + pad4 > label_img.shape[1]:
+                    pad4 = 0
+
+            cropped_image = img_test[minr - pad1:maxr + pad3, minc - pad2:maxc + pad4, :]
+            cropped_truth = ytruth[minr - pad1:maxr + pad3, minc - pad2:maxc + pad4]
+            txcordi = []
+            txcordi.append(minr - pad1)
+            txcordi.append(maxr + pad3)
+            txcordi.append(minc - pad2)
+            txcordi.append(maxc + pad4)
+            cropped_results['image'] = cropped_image
+            cropped_results['truth'] = cropped_truth
+            cropped_results['cord'] = txcordi
+
+    return cropped_results
+
+
+class BasicBlock(nn.Module):
+    def __init__(self, channel_num):
+        super(BasicBlock, self).__init__()
+        # TODO: 3x3 convolution -> relu
+        # the input and output channel number is channel_num
+        self.conv_block1 = nn.Sequential(
+            nn.Conv2d(channel_num, 48, 1, padding=0),
+            nn.GroupNorm(num_groups=8, num_channels=48),
+            nn.GELU(),
+        )
+        self.conv_block2 = nn.Sequential(
+            nn.Conv2d(48, channel_num, 3, padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=channel_num),
+            nn.GELU(),
+        )
+        self.relu = nn.GELU()
+
+    def forward(self, x):
+        # TODO: forward
+        residual = x
+        x = self.conv_block1(x)
+        x = self.conv_block2(x)
+        x = x + residual
+        return x
+
+
+class ASPP(nn.Module):
+    def __init__(self, image_dim=384, head=1):
+        super(ASPP, self).__init__()
+        self.image_dim = image_dim
+        self.Residual2 = BasicBlock(channel_num=head)
+        self.pixel_shuffle = nn.PixelShuffle(2)
+        self.head = head
+
+    def forward(self, x):
+        x21 = F.interpolate(x, size=(self.image_dim, self.image_dim), mode='bilinear',
+                            align_corners=True)
+        return x21
+
+
+class Transformer_Regression(nn.Module):
+    def __init__(self, image_dim=224, dim_patch=24, num_classes=3, scale=1, feat_dim=192):
+        super(Transformer_Regression, self).__init__()
+        self.backbone = swin_base_patch4_window12_384_in22k(pretrained=True)
+        self.aux = 1
+        self.dim_patch = dim_patch
+        self.image_dim = image_dim
+        self.num_classes = num_classes
+        self.ASPP1 = ASPP(image_dim, head=128)
+        self.ASPP2 = ASPP(image_dim, head=128)
+        # self.ASPP3=ASPP(image_dim,scale,feat_dim)
+        self.feat_dim = feat_dim
+        # self.scale=1
+        self.Classifier_main = nn.Sequential(
+            # nn.Dropout(0.1),
+            nn.Conv2d(128, self.num_classes, 3, bias=True, padding=1),
+        )
+        self.Classifier_aux1 = nn.Sequential(
+            # nn.Dropout(0.1),
+            nn.Conv2d(128, self.num_classes, 3, bias=True, padding=1),
+        )
+
+        self.conv1 = nn.Sequential(nn.Conv2d(448, 128, kernel_size=(1, 1), padding=1), nn.GELU())
+        self.pixelshufler1 = nn.PixelShuffle(2)
+        self.pixelshufler2 = nn.PixelShuffle(4)
+
+    def forward(self, x):
+        hide1 = self.backbone(x)
+        x1 = []
+        x1.append((hide1[0][:, 0:].reshape(-1, 48, 48, 256)))
+        x1.append((hide1[1][:, 0:].reshape(-1, 24, 24, 512)))
+        x1.append((hide1[2][:, 0:].reshape(-1, 12, 12, 1024)))
+        for jk in range(len(x1)):
+            x1[jk] = x1[jk].permute(0, 3, 1, 2)
+        x1[1] = self.pixelshufler1(x1[1])
+        x1[2] = self.pixelshufler2(x1[2])
+
+        x1[0] = torch.cat((x1[0], x1[1], x1[2]), 1)
+
+        x1[0] = self.conv1(x1[0])
+        Score = dict()
+        x_main1 = self.ASPP1(x1[0])
+        x_main = self.Classifier_main(x_main1)
+        x_aux_1 = self.ASPP2(x1[0])
+        x_aux_1 = self.Classifier_aux1(x_aux_1)  ####### x_aux_1
+
+        Score['seg'] = x_main
+        Score['seg_aux_1'] = x_aux_1
+        # Score['seg_aux_2'] = x_aux_2
+
+        return Score
+
+
+
+
+Ratios = namedtuple("Ratios", 'cdr hcdr vcdr')
+eps = np.finfo(np.float32).eps
+
+
+def compute_ratios(mask_image):
+    '''
+    Given an input image containing the cup and disc masks the function returns
+    a tuple with the area, horizontal, and vertical cup-to-disc ratios
+    Input:
+        mask_image: an image with values (0,1,2) or (255,128,0)
+                    for bg, disc, cup respectively
+    Output:
+        Ratios(cdr,hcdr,vcdr): a named tuple containing the computed ratios
+    '''
+
+    # if mask_image.max() == 2:
+    # make sure correct values are provided in the image
+    #    if np.setdiff1d(np.unique(mask_image),np.array([0,1,2])).shape[0]>0:
+    #        raise ValueError(('Mask values can only be (0,1,2) '
+    #                          'or (255,128,0) for bg, disc, cup'))
+    #    disc = np.uint8(mask_image > 0)
+    #    cup = np.uint8(mask_image > 1)
+    # elif mask_image.max() == 255:
+    #    # make sure correct values are provided in the image
+    #    if np.setdiff1d(np.unique(mask_image),np.array([0,128,255])).shape[0]>0:
+    #        raise ValueError(('Mask values can only be (0,1,2) '
+    #                          'or (255,128,0) for bg, disc, cup'))
+    #    disc = np.uint8(mask_image < 255)
+    #    cup = np.uint8(mask_image == 0)
+    # else:
+    #    raise ValueError(("Mask values can only be (0,1,2) or (255,128,0) "
+    #                      "for bg, disc, cup"))
+
+    # get the area
+    disc = 0
+    cup = 0
+    disc = disc + np.uint8(mask_image > 0)
+    cup = cup + np.uint8(mask_image > 1)
+
+    disc_area = np.sum(disc)
+    cup_area = np.sum(cup)
+    # get the vertical and horizontal mesure of the cup
+    cup_vert = np.sum(cup, axis=0).max().astype(np.int32)
+    cup_horz = np.sum(cup, axis=1).max().astype(np.int32)
+    # get the vertical and horizontal mesure of the disc
+    disc_vert = np.sum(disc, axis=0).max().astype(np.int32)
+    disc_horz = np.sum(disc, axis=1).max().astype(np.int32)
+    # calculate the cup to disc ratio
+    cdr = (cup_area + eps) / (disc_area + eps)  # add eps to avoid div by 0
+    # calculate the horizontal and vertical cup to disc ration
+    hcdr = (cup_horz + eps) / (disc_horz + eps)
+    vcdr = (cup_vert + eps) / (disc_vert + eps)
+
+    return Ratios(cdr, hcdr, vcdr)

requirements.txt

@@ -0,0 +1,6 @@
+torch
+timm
+skimage
+numpy
+cv2
+Pillow