first commit

Author: rikiyay

.DS_Store

@@ -0,0 +1,12 @@
+# Predicting post-surgical recurrence of hepatocellular carcinoma from digital histopathologic images using deep learning  
+  
+![method_outline](method_outline.png)  
+
+This repository contains the code to quantify risk scores for recurrence in patients with hepatocellular carcinoma from H&E-stained FFPE histopathology images.
+
+The code is written in python.  
+
+## Citation
+Predicting post-surgical recurrence of hepatocellular carcinoma from digital histopathologic images using deep learning  
+
+Rikiya Yamashita, Jin Long, Atif Saleem, Daniel Rubin, Jeanne Shen.  

README.md

@@ -0,0 +1,210 @@
+# ------------------------------------------------------------------------
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ------------------------------------------------------------------------
+
+import math
+import numpy as np
+from PIL import Image
+import skimage.morphology as sk_morphology
+
+def open_image(filename):
+    image = Image.open(filename)
+    return image
+
+def pil_to_np_rgb(pil_img):
+    rgb = np.asarray(pil_img)
+    return rgb
+
+def mask_percent(np_img):
+    if (len(np_img.shape) == 3) and (np_img.shape[2] == 3):
+        np_sum = np_img[:, :, 0] + np_img[:, :, 1] + np_img[:, :, 2]
+        mask_percentage = 100 - np.count_nonzero(np_sum) / np_sum.size * 100 #(np_img.shape[0]*np_img.shape[1])
+    else:
+        mask_percentage = 100 - np.count_nonzero(np_img) / np_img.size * 100
+    return mask_percentage
+
+def tissue_percent(np_img):
+    return 100 - mask_percent(np_img)
+
+def filter_green_channel(np_img, green_thresh=200, avoid_overmask=True, overmask_thresh=90, output_type="bool"):
+    g = np_img[:, :, 1]
+    gr_ch_mask = (g < green_thresh) & (g > 0)
+    mask_percentage = mask_percent(gr_ch_mask)
+    if (mask_percentage >= overmask_thresh) and (green_thresh < 255) and (avoid_overmask is True):
+        new_green_thresh = math.ceil((255 - green_thresh) / 2 + green_thresh)
+        print("Mask percentage %3.2f%% >= overmask threshold %3.2f%% for Remove Green Channel green_thresh=%d, so try %d" % (
+        mask_percentage, overmask_thresh, green_thresh, new_green_thresh))
+        gr_ch_mask = filter_green_channel(np_img, new_green_thresh, avoid_overmask, overmask_thresh, output_type)
+    np_img = gr_ch_mask
+    if output_type == "bool":
+        pass
+    elif output_type == "float":
+        np_img = np_img.astype(float)
+    else:
+        np_img = np_img.astype("uint8") * 255
+    return np_img
+
+def filter_grays(rgb, tolerance=15, output_type="bool"):
+    (h, w, c) = rgb.shape
+    rgb = rgb.astype(np.int)
+    rg_diff = abs(rgb[:, :, 0] - rgb[:, :, 1]) <= tolerance
+    rb_diff = abs(rgb[:, :, 0] - rgb[:, :, 2]) <= tolerance
+    gb_diff = abs(rgb[:, :, 1] - rgb[:, :, 2]) <= tolerance
+    result = ~(rg_diff & rb_diff & gb_diff)
+    if output_type == "bool":
+        pass
+    elif output_type == "float":
+        result = result.astype(float)
+    else:
+        result = result.astype("uint8") * 255    
+    return result
+
+def filter_red(rgb, red_lower_thresh, green_upper_thresh, blue_upper_thresh, output_type="bool"):
+    r = rgb[:, :, 0] > red_lower_thresh
+    g = rgb[:, :, 1] < green_upper_thresh
+    b = rgb[:, :, 2] < blue_upper_thresh
+    result = ~(r & g & b)
+    if output_type == "bool":
+        pass
+    elif output_type == "float":
+        result = result.astype(float)
+    else:
+        result = result.astype("uint8") * 255
+    return result
+
+def filter_red_pen(rgb, output_type="bool"):
+    result = filter_red(rgb, red_lower_thresh=150, green_upper_thresh=80, blue_upper_thresh=90) & \
+            filter_red(rgb, red_lower_thresh=110, green_upper_thresh=20, blue_upper_thresh=30) & \
+            filter_red(rgb, red_lower_thresh=185, green_upper_thresh=65, blue_upper_thresh=105) & \
+            filter_red(rgb, red_lower_thresh=195, green_upper_thresh=85, blue_upper_thresh=125) & \
+            filter_red(rgb, red_lower_thresh=220, green_upper_thresh=115, blue_upper_thresh=145) & \
+            filter_red(rgb, red_lower_thresh=125, green_upper_thresh=40, blue_upper_thresh=70) & \
+            filter_red(rgb, red_lower_thresh=200, green_upper_thresh=120, blue_upper_thresh=150) & \
+            filter_red(rgb, red_lower_thresh=100, green_upper_thresh=50, blue_upper_thresh=65) & \
+            filter_red(rgb, red_lower_thresh=85, green_upper_thresh=25, blue_upper_thresh=45)
+    if output_type == "bool":
+        pass
+    elif output_type == "float":
+        result = result.astype(float)
+    else:
+        result = result.astype("uint8") * 255
+    return result
+
+def filter_green(rgb, red_upper_thresh, green_lower_thresh, blue_lower_thresh, output_type="bool"):
+    r = rgb[:, :, 0] < red_upper_thresh
+    g = rgb[:, :, 1] > green_lower_thresh
+    b = rgb[:, :, 2] > blue_lower_thresh
+    result = ~(r & g & b)
+    if output_type == "bool":
+        pass
+    elif output_type == "float":
+        result = result.astype(float)
+    else:
+        result = result.astype("uint8") * 255
+    return result
+
+def filter_green_pen(rgb, output_type="bool"):
+    result = filter_green(rgb, red_upper_thresh=150, green_lower_thresh=160, blue_lower_thresh=140) & \
+            filter_green(rgb, red_upper_thresh=70, green_lower_thresh=110, blue_lower_thresh=110) & \
+            filter_green(rgb, red_upper_thresh=45, green_lower_thresh=115, blue_lower_thresh=100) & \
+            filter_green(rgb, red_upper_thresh=30, green_lower_thresh=75, blue_lower_thresh=60) & \
+            filter_green(rgb, red_upper_thresh=195, green_lower_thresh=220, blue_lower_thresh=210) & \
+            filter_green(rgb, red_upper_thresh=225, green_lower_thresh=230, blue_lower_thresh=225) & \
+            filter_green(rgb, red_upper_thresh=170, green_lower_thresh=210, blue_lower_thresh=200) & \
+            filter_green(rgb, red_upper_thresh=20, green_lower_thresh=30, blue_lower_thresh=20) & \
+            filter_green(rgb, red_upper_thresh=50, green_lower_thresh=60, blue_lower_thresh=40) & \
+            filter_green(rgb, red_upper_thresh=30, green_lower_thresh=50, blue_lower_thresh=35) & \
+            filter_green(rgb, red_upper_thresh=65, green_lower_thresh=70, blue_lower_thresh=60) & \
+            filter_green(rgb, red_upper_thresh=100, green_lower_thresh=110, blue_lower_thresh=105) & \
+            filter_green(rgb, red_upper_thresh=165, green_lower_thresh=180, blue_lower_thresh=180) & \
+            filter_green(rgb, red_upper_thresh=140, green_lower_thresh=140, blue_lower_thresh=150) & \
+            filter_green(rgb, red_upper_thresh=185, green_lower_thresh=195, blue_lower_thresh=195)
+    if output_type == "bool":
+        pass
+    elif output_type == "float":
+        result = result.astype(float)
+    else:
+        result = result.astype("uint8") * 255
+    return result
+
+def filter_blue(rgb, red_upper_thresh, green_upper_thresh, blue_lower_thresh, output_type="bool"):
+    r = rgb[:, :, 0] < red_upper_thresh
+    g = rgb[:, :, 1] < green_upper_thresh
+    b = rgb[:, :, 2] > blue_lower_thresh
+    result = ~(r & g & b)
+    if output_type == "bool":
+        pass
+    elif output_type == "float":
+        result = result.astype(float)
+    else:
+        result = result.astype("uint8") * 255
+    return result
+
+def filter_blue_pen(rgb, output_type="bool"):
+    result = filter_blue(rgb, red_upper_thresh=60, green_upper_thresh=120, blue_lower_thresh=190) & \
+            filter_blue(rgb, red_upper_thresh=120, green_upper_thresh=170, blue_lower_thresh=200) & \
+            filter_blue(rgb, red_upper_thresh=175, green_upper_thresh=210, blue_lower_thresh=230) & \
+            filter_blue(rgb, red_upper_thresh=145, green_upper_thresh=180, blue_lower_thresh=210) & \
+            filter_blue(rgb, red_upper_thresh=37, green_upper_thresh=95, blue_lower_thresh=160) & \
+            filter_blue(rgb, red_upper_thresh=30, green_upper_thresh=65, blue_lower_thresh=130) & \
+            filter_blue(rgb, red_upper_thresh=130, green_upper_thresh=155, blue_lower_thresh=180) & \
+            filter_blue(rgb, red_upper_thresh=40, green_upper_thresh=35, blue_lower_thresh=85) & \
+            filter_blue(rgb, red_upper_thresh=30, green_upper_thresh=20, blue_lower_thresh=65) & \
+            filter_blue(rgb, red_upper_thresh=90, green_upper_thresh=90, blue_lower_thresh=140) & \
+            filter_blue(rgb, red_upper_thresh=60, green_upper_thresh=60, blue_lower_thresh=120) & \
+            filter_blue(rgb, red_upper_thresh=110, green_upper_thresh=110, blue_lower_thresh=175)
+    if output_type == "bool":
+        pass
+    elif output_type == "float":
+        result = result.astype(float)
+    else:
+        result = result.astype("uint8") * 255
+    return result
+
+def filter_remove_small_objects(np_img, min_size=500, avoid_overmask=True, overmask_thresh=95, output_type="uint8"):
+    rem_sm = np_img.astype(bool)  # make sure mask is boolean
+    rem_sm = sk_morphology.remove_small_objects(rem_sm, min_size=min_size)
+    mask_percentage = mask_percent(rem_sm)
+    if (mask_percentage >= overmask_thresh) and (min_size >= 1) and (avoid_overmask is True):
+        new_min_size = min_size / 2
+        print("Mask percentage %3.2f%% >= overmask threshold %3.2f%% for Remove Small Objs size %d, so try %d" % (
+          mask_percentage, overmask_thresh, min_size, new_min_size))
+        rem_sm = filter_remove_small_objects(np_img, new_min_size, avoid_overmask, overmask_thresh, output_type)
+    np_img = rem_sm
+    if output_type == "bool":
+        pass
+    elif output_type == "float":
+        np_img = np_img.astype(float)
+    else:
+        np_img = np_img.astype("uint8") * 255
+    return np_img
+
+def mask_rgb(rgb, mask):
+    result = rgb * np.dstack([mask, mask, mask])
+    return result
+    
+def apply_image_filters(np_img):
+    rgb = np_img
+    mask_not_green = filter_green_channel(rgb)
+    mask_not_gray = filter_grays(rgb)
+    mask_no_red_pen = filter_red_pen(rgb)
+    mask_no_green_pen = filter_green_pen(rgb)
+    rgb_no_green_pen = mask_rgb(rgb, mask_no_green_pen)
+    mask_no_blue_pen = filter_blue_pen(rgb)
+    mask_gray_green_pens = mask_not_gray & mask_not_green & mask_no_red_pen & mask_no_green_pen & mask_no_blue_pen
+    mask_remove_small = filter_remove_small_objects(mask_gray_green_pens, min_size=500, output_type="bool")
+    rgb_remove_small = mask_rgb(rgb, mask_remove_small)
+    img = rgb_remove_small
+    return img