Add files

README.md

@@ -1,5 +1,5 @@
 ---
-title: Celldetection
+title: CellDetection
 emoji: ⚡
 colorFrom: pink
 colorTo: gray

app.py

@@ -0,0 +1,48 @@
+import gradio as gr
+from cpn import CpnInterface
+from prep import multi_norm
+from util import imread, imsave, get_examples
+from celldetection import label_cmap
+
+default_model = 'ginoro_CpnResNeXt101UNet-fbe875f1a3e5ce2c'
+
+
+def predict(filename, model=None, device=None, reduce_labels=True):
+    global default_model
+    assert isinstance(filename, str)
+    print(dict(
+        filename=filename,
+        model=model,
+        device=device,
+        reduce_labels=reduce_labels
+    ), flush=True)
+
+    img = imread(filename)
+    print('Image:', img.dtype, img.shape, (img.min(), img.max()), flush=True)
+    if model is None or len(str(model)) <= 0:
+        model = default_model
+
+    img = multi_norm(img, 'cstm-mix')  # TODO
+
+    m = CpnInterface(model.strip(), device=device)
+    y = m(img, reduce_labels=reduce_labels)
+
+    labels = y['labels']
+
+    vis_labels = label_cmap(labels)
+    dst = '.'.join(filename.split('.')[:-1]) + '_labels.tiff'
+    imsave(dst, labels)
+
+    return img, vis_labels, dst
+
+
+gr.Interface(
+    predict,
+    inputs=[gr.components.Image(label="Upload Input Image", type="filepath"),
+            gr.components.Textbox(label='Model Name', value=default_model, max_lines=1)],
+    outputs=[gr.Image(label="Processed Image"),
+             gr.Image(label="Label Image"),
+             gr.File(label="Download Label Image")],
+    title="Cell Detection with Contour Proposal Networks",
+    examples=get_examples(default_model)
+).launch()

cpn.py

@@ -0,0 +1,71 @@
+import torch
+import celldetection as cd
+import cv2
+import numpy as np
+
+__all__ = ['contours2labels', 'CpnInterface']
+
+
+def contours2labels(contours, size, overlap=False, max_iter=999):
+    labels = cd.data.contours2labels(cd.asnumpy(contours), size, initial_depth=3)
+
+    if not overlap:
+        kernel = cv2.getStructuringElement(1, (3, 3))
+        mask_sm = np.sum(labels > 0, axis=-1)
+        mask = mask_sm > 1  # all overlaps
+        if mask.any():
+            mask_ = mask_sm == 1  # all cores
+            lbl = np.zeros(labels.shape[:2], dtype='float64')
+            lbl[mask_] = labels.max(-1)[mask_]
+            for _ in range(max_iter):
+                lbl_ = np.copy(lbl)
+                m = mask & (lbl <= 0)
+                if not np.any(m):
+                    break
+                lbl[m] = cv2.dilate(lbl, kernel=kernel)[m]
+                if np.allclose(lbl_, lbl):
+                    break
+        else:
+            lbl = labels.max(-1)
+        labels = lbl.astype('int')
+    return labels
+
+
+class CpnInterface:
+    def __init__(self, model, device=None):
+        self.device = ('cuda' if torch.cuda.is_available() else 'cpu') if device is None else device
+        self.model = cd.models.LitCpn(model).to(device)
+        self.model.eval()
+        self.tile_size = 768
+        self.overlap = 384
+
+    def __call__(
+            self,
+            img,
+            div=255,
+            reduce_labels=True,
+            return_labels=True,
+            return_viewable_contours=True,
+    ):
+        if img.ndim == 2:
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
+        img = img / div
+        x = cd.data.to_tensor(img, transpose=True, dtype=torch.float32)[None]
+        with torch.no_grad():
+            out = cd.asnumpy(self.model(x, crop_size=self.tile_size,
+                                        stride=max(64, self.tile_size - self.overlap)))
+
+        contours, = out['contours']
+        boxes, = out['boxes']
+        scores, = out['scores']
+
+        labels = None
+        if return_labels or return_viewable_contours:
+            labels = contours2labels(contours, img.shape[:2], overlap=not reduce_labels)
+
+        return dict(
+            contours=contours,
+            labels=labels,
+            boxes=boxes,
+            scores=scores
+        )

prep.py

@@ -0,0 +1,63 @@
+import celldetection as cd
+import numpy as np
+from skimage import img_as_ubyte, exposure
+from PIL import ImageFile
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+__all__ = ['normalize_img', 'normalize_channel', 'multi_norm']
+
+
+def normalize_img(img, gamma_spread=17, lower_gamma_bound=.6, percentile=99.88):
+    log = []
+    if img.dtype.kind == 'f':  # floats
+        if img.max() < 256:
+            img = img_as_ubyte(img / 255)
+            log.append('img_as_ubyte')
+        else:
+            v = 99.95
+            img = cd.data.normalize_percentile(img, v)
+            log.append(f'cd.data.normalize_percentile(img, {v})')
+    elif img.itemsize > 1:
+        img = cd.data.normalize_percentile(img, percentile)
+        log.append(f'cd.data.normalize_percentile(img, {percentile})')
+    mean_thresh = np.pi * gamma_spread
+    if img.mean() < mean_thresh:
+        gamma = (1 - ((np.cos(1 / gamma_spread * img.mean()) + 1) / 2)) * (1 - lower_gamma_bound) + lower_gamma_bound
+        log.append(f'(img / 255) ** {gamma}')
+        img = (img / 255) ** gamma
+        img = img_as_ubyte(img)
+    return img, log
+
+
+def normalize_channel(img, lower=1, upper=99):
+    non_zero_vals = img[np.nonzero(img)]
+    percentiles = np.percentile(non_zero_vals, [lower, upper])
+    if percentiles[1] - percentiles[0] > 0.001:
+        img_norm = exposure.rescale_intensity(img, in_range=(percentiles[0], percentiles[1]), out_range='uint8')
+    else:
+        img_norm = img
+    return img_norm.astype(np.uint8)
+
+
+def multi_norm(img, method):
+    if method == 'prov':
+        img = normalize_channel(img)
+    elif method == 'rand-mix' or method == 'cstm-mix':
+        img0 = normalize_channel(img)
+        img1, log = normalize_img(img)
+        if method == 'rand-mix':
+            alpha = np.random.uniform(0., 1.)
+        else:
+            is_grayscale = img.ndim == 2 or (img.ndim == 3 and img.shape[2] == 1)
+            alpha = 0.
+            if not is_grayscale:
+                if img[..., 2].mean() > 200 and img[..., 2].std() < 20:
+                    alpha = 1.
+            else:
+                if img1.mean() < 45 and img1.std() < 33:
+                    alpha = .5
+        img = np.clip(alpha * img0 + (1 - alpha) * img1, 0, 255).astype(img0.dtype)
+    else:
+        img, log = normalize_img(img)
+    return img

requirements.txt

@@ -0,0 +1,2 @@
+celldetection @ git+https://github.com/FZJ-INM1-BDA/celldetection.git
+tifffile

util.py

@@ -0,0 +1,27 @@
+from imageio.v2 import imread as _imread
+import tifffile as tif
+
+__all__ = ['imread', 'imsave', 'get_examples']
+
+
+def imread(filename):
+    if filename.split('.')[-1] in ('tiff', 'tif'):
+        return tif.imread(filename)
+    return _imread(filename)
+
+
+def imsave(filename, img, compression="zlib"):
+    tif.imwrite(filename, img, compression=compression)
+
+
+def get_examples(default_model):
+    from skimage import data
+    from os.path import dirname, join, isfile
+
+    examples = []
+    for f in ['coins.png']:
+        f = join(dirname(data.__file__), f)
+        if isfile(f):
+            examples.append([f, default_model])
+    if len(examples):
+        return examples