Upload app.py

app.py

@@ -0,0 +1,151 @@
+import cv2
+
+import numpy as np
+import streamlit as st
+import tensorflow as tf
+
+from utils import _get_retina_bb, _pad_to_square
+
+
+@st.cache(allow_output_mutation=True)
+def load_model(model_file):
+    model = tf.keras.models.load_model(model_file, compile=False)
+    print(f'Model {model_file} Loaded!')
+    return model
+
+
+@st.cache(allow_output_mutation=True)
+def load_gatekeeper():
+    validator_model = tf.keras.models.load_model('checkpoints/ResNetV2-EyeQ-QA.tf')
+    print('Gatekeeper Model Loaded!')
+    return validator_model
+
+
+def parse_function(image):
+    image = tf.image.resize(image, [512, 512])
+    image = tf.image.convert_image_dtype(image, tf.float32)
+    return image
+
+
+def main():
+
+    st.title('Retina Segmentation')
+
+    st.sidebar.title('Segmentation Model')
+    options = st.sidebar.selectbox('Select Option:', ('Vessels', 'Lesions (BETA)'))
+    gatekeeper = st.sidebar.radio("Gatekeeper:", ('Enabled', 'Disabled'))
+
+    gatekeeper_model = load_gatekeeper()
+
+    if options == 'Vessels':
+
+        st.set_option('deprecation.showfileUploaderEncoding', False)
+        uploaded_file = st.file_uploader('Choose an image...', type=('png', 'jpg', 'jpeg'))
+
+        model = load_model('checkpoints/DeeplabV3Plus_DRIVE.tf')
+
+        if uploaded_file:
+            col1, col2 = st.columns(2)
+
+            # Load Image
+            file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+            image = cv2.imdecode(file_bytes, 1)
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+            # Check image
+            valid = np.argmax(gatekeeper_model(parse_function(image[None, ...])))
+            if valid == 2 and gatekeeper == 'Enabled':
+                st.image(image)
+                st.info('Image is of poor quality')
+                return
+
+            # Localise and center retina image
+            x, y, w, h, _ = _get_retina_bb(image)
+            image = image[y:y + h, x:x + w, :]
+            image = _pad_to_square(image, border=0)
+            image = cv2.resize(image, (1024, 1024))
+
+            with col1:
+                st.subheader("Uploaded Image")
+                st.image(image)
+
+            # Apply CLAHE pre-processing
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(16, 16))
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
+            image[:, :, 0] = clahe.apply(image[:, :, 0])
+            image = cv2.cvtColor(image, cv2.COLOR_LAB2RGB)
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+            image = tf.image.convert_image_dtype(image, tf.float32)
+
+            # Run model on input
+            y_pred = model(image[None, ..., None])[0].numpy()
+
+            with col2:
+                st.subheader("Predicted Vessel")
+                st.image(y_pred)
+
+    elif options == 'Lesions (BETA)':
+
+        st.write('```--- WARNING: This model is highly experimental ---```')
+
+        st.set_option('deprecation.showfileUploaderEncoding', False)
+        uploaded_file = st.file_uploader('Choose an image...', type=('png', 'jpg', 'jpeg'))
+
+        model = load_model('checkpoints/DeeplabV3Plus_FGADR.tf')
+
+        if uploaded_file:
+            col1, col2, col3, = st.columns(3)
+
+            # Load Image
+            file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+            image = cv2.imdecode(file_bytes, 1)
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+            # Check image
+            valid = np.argmax(gatekeeper_model(parse_function(image[None, ...])))
+            if valid == 2 and gatekeeper == 'Enabled':
+                st.image(image)
+                st.info('Image is of poor quality')
+                return
+
+            # Localise and center retina image
+            x, y, w, h, _ = _get_retina_bb(image)
+            image = image[y:y + h, x:x + w, :]
+            image = _pad_to_square(image, border=0)
+            image = cv2.resize(image, (1024, 1024))
+
+            with col1:
+                st.subheader("Uploaded Image")
+                st.image(image)
+
+            # Apply CLAHE pre-processing
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(16, 16))
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
+            image[:, :, 0] = clahe.apply(image[:, :, 0])
+            image = cv2.cvtColor(image, cv2.COLOR_LAB2RGB)
+            image = tf.image.convert_image_dtype(image, tf.float32)
+
+            # Run model on input
+            y_pred = model(image[None, ..., None])[0].numpy()
+
+            with col2:
+                st.subheader(f'MA')
+                st.image(y_pred[..., 1])
+            with col3:
+                st.subheader(f'HE')
+                st.image(y_pred[..., 2])
+            with col1:
+                st.subheader(f'EX')
+                st.image(y_pred[..., 3])
+            with col2:
+                st.subheader(f'SE')
+                st.image(y_pred[..., 4])
+            with col3:
+                st.subheader(f'OD')
+                st.image(y_pred[..., 5])
+
+if __name__ == '__main__':
+
+    tf.config.set_visible_devices([], 'GPU')
+
+    main()

utils.py

@@ -0,0 +1,137 @@
+import cv2
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def _pad_to_square(image, long_side=None, border=0):
+    h, w, _ = image.shape
+
+    if long_side == None: long_side = max(h, w)
+
+    l_pad = (long_side - w) // 2 + border
+    r_pad = (long_side - w) // 2 + border
+    t_pad = (long_side - h) // 2 + border
+    b_pad = (long_side - h) // 2 + border
+    if w % 2 != 0: r_pad = r_pad + 1
+    if h % 2 != 0: b_pad = b_pad + 1
+
+    image = np.pad(
+        image,
+        ((t_pad, b_pad),
+         (l_pad, r_pad),
+         (0, 0)),
+        'constant')
+
+    return image
+
+
+def _get_retina_bb(image):
+
+    # make image greyscale and normalise
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX)
+
+    # calculate threshold perform threshold
+    threshold = np.mean(image)/3-7
+    ret, thresh = cv2.threshold(image, max(0, threshold), 255, cv2.THRESH_BINARY)
+
+    # median filter, erode and dilate to remove noise and holes
+    thresh = cv2.medianBlur(thresh, 25)
+    thresh = cv2.erode(thresh, None, iterations=2)
+    thresh = cv2.dilate(thresh, None, iterations=2)
+
+    # find mask contour
+    cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    cnts = cnts[0] if len(cnts) == 2 else cnts[1]
+    c = max(cnts, key=cv2.contourArea)
+
+    # Get bounding box from mask contour
+    x, y, w, h = cv2.boundingRect(c)
+
+    # Get mask from contour
+    mask = np.zeros_like(image)
+    cv2.drawContours(mask, [c], -1, (255, 255, 255), -1)
+
+    return x, y, w, h, mask
+
+
+def _get_retina_bb2(image, skips=4):
+    '''
+    Experimental Retina Bounding Box detector based on Convexity Defect Points
+    '''
+
+    # make image greyscale and normalise
+    image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX)
+
+    # calculate threshold perform threshold
+    threshold = np.mean(image)/3-7
+    ret, thresh = cv2.threshold(image, max(0, threshold), 255, cv2.THRESH_BINARY)
+
+    # median filter, erode and dilate to remove noise and holes
+    thresh = cv2.medianBlur(thresh, 25)
+    thresh = cv2.erode(thresh, None, iterations=2)
+    thresh = cv2.dilate(thresh, None, iterations=2)
+
+    # Find contours
+    contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+
+    # Find the index of the largest contour
+    areas = [cv2.contourArea(c) for c in contours]
+    max_index = np.argmax(areas)
+    cnt = contours[max_index]
+
+    # Get convexity defect points
+    hull = cv2.convexHull(cnt, returnPoints=False)
+    hull[::-1].sort(axis=0)
+    defects = cv2.convexityDefects(cnt, hull)
+
+    ConvexityDefectPoint = []
+    for i in range(0, defects.shape[0], skips):
+        s, e, f, d = defects[i, 0]
+        ConvexityDefectPoint.append(tuple(cnt[f][0]))
+
+    # Get minimum enclosing circle as retina estimate
+    (x, y), radius = cv2.minEnclosingCircle(np.array(ConvexityDefectPoint))
+
+    # Get mask from contour
+    mask = np.zeros_like(image)
+    cv2.circle(mask, (x, y), radius, (255, 255, 255), -1)
+
+    # return (x, y, w, h) bounding box
+    return int(x - radius), int(y - radius), int(2 * radius - 1), int(2 * radius - 1), mask
+
+
+def rgb_clahe(image, clipLimit=2.0, tileGridSize=(16, 16)):
+    lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
+    clahe = cv2.createCLAHE(clipLimit=clipLimit, tileGridSize=tileGridSize)
+    lab[..., 0] = clahe.apply(lab[..., 0])
+    return cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
+
+
+if __name__ == '__main__':
+
+    # image_file = '/vol/biomedic3/bh1511/retina/IDRID/segmentation/0_Original_Images/IDRiD_65.jpg'
+    # image_file = '/vol/biomedic3/bh1511/retina/CHASE_DB1/images/Image_08R.jpg'
+    # image_file = '/vol/vipdata/data/retina/kaggle-diabetic-retinopathy-detection/train/16_right.jpeg'
+    # image_file = '/vol/vipdata/data/retina/IDRID/a_segmentation/images/train/IDRiD_01.jpg'
+    image_file = 'preprocessing/Image_10L.png'
+
+    # Load Image
+    image = cv2.imread(image_file)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    plt.imshow(image); plt.show()
+
+    # Localise and center retina image
+    x, y, w, h, _ = _get_retina_bb(image)
+    image = image[y:y + h, x:x + w, :]
+    image = _pad_to_square(image, border=0)
+    image = cv2.resize(image, (1024, 1024))
+
+    # Apply CLAHE pre-processing
+    image = rgb_clahe(image)
+
+    # Display or save image
+    plt.imshow(image); plt.show()
+    # cv2.imwrite('processed_image.png', image)