Upload 9 files

CellAware.py

@@ -0,0 +1,88 @@
+import numpy as np
+import copy
+
+from monai.transforms import RandScaleIntensity, Compose
+from monai.transforms.compose import MapTransform
+from skimage.segmentation import find_boundaries
+
+
+__all__ = ["BoundaryExclusion", "IntensityDiversification"]
+
+
+class BoundaryExclusion(MapTransform):
+    """Map the cell boundary pixel labels to the background class (0)."""
+
+    def __init__(self, keys=["label"], allow_missing_keys=False):
+        super(BoundaryExclusion, self).__init__(keys, allow_missing_keys)
+
+    def __call__(self, data):
+        # Find and Exclude Boundary
+        label_original = data["label"]
+        label = copy.deepcopy(label_original)
+        boundary = find_boundaries(label, connectivity=1, mode="thick")
+        label[boundary] = 0
+
+        # Do not exclude if the cell is too small (< 14x14).
+        new_label = copy.deepcopy(label_original)
+        new_label[label == 0] = 0
+
+        cell_idx, cell_counts = np.unique(label_original, return_counts=True)
+
+        for k in range(len(cell_counts)):
+            if cell_counts[k] < 196:
+                new_label[label_original == cell_idx[k]] = cell_idx[k]
+
+        # Do not exclude if the pixels are at the image boundaries.
+        _, W, H = label_original.shape
+        bd = np.zeros_like(label_original, dtype=label.dtype)
+        bd[:, 2 : W - 2, 2 : H - 2] = 1
+        new_label += label_original * bd
+
+        # Assign the transformed label
+        data["label"] = new_label
+
+        return data
+
+
+class IntensityDiversification(MapTransform):
+    """Randomly rescale the intensity of cell pixels."""
+
+    def __init__(
+        self,
+        keys=["img"],
+        change_cell_ratio=0.4,
+        scale_factors=[0, 0.7],
+        allow_missing_keys=False,
+    ):
+        super(IntensityDiversification, self).__init__(keys, allow_missing_keys)
+
+        self.change_cell_ratio = change_cell_ratio
+        self.randscale_intensity = Compose(
+            [RandScaleIntensity(prob=1.0, factors=scale_factors)]
+        )
+
+    def __call__(self, data):
+        # Select cells to be transformed
+        cell_count = int(data["label"].max())
+        change_cell_count = int(cell_count * self.change_cell_ratio)
+        change_cell = np.random.choice(cell_count, change_cell_count, replace=False)
+
+        mask = copy.deepcopy(data["label"])
+
+        for i in range(cell_count):
+            cell_id = i + 1
+
+            if cell_id not in change_cell:
+                mask[mask == cell_id] = 0
+
+        mask[mask > 0] = 1
+
+        # Conduct intensity transformation for the selected cells
+        img_original = copy.deepcopy((1 - mask) * data["img"])
+        img_transformed = copy.deepcopy(mask * data["img"])
+        img_transformed = self.randscale_intensity(img_transformed)
+
+        # Assign the transformed image
+        data["img"] = img_original + img_transformed
+
+        return data

NormalizeImage.py

@@ -0,0 +1,77 @@
+import numpy as np
+from skimage import exposure
+from monai.config import KeysCollection
+
+from monai.transforms.transform import Transform
+from monai.transforms.compose import MapTransform
+
+from typing import Dict, Hashable, Mapping
+
+
+__all__ = [
+    "CustomNormalizeImage",
+    "CustomNormalizeImageD",
+    "CustomNormalizeImageDict",
+    "CustomNormalizeImaged",
+]
+
+
+class CustomNormalizeImage(Transform):
+    """Normalize the image."""
+
+    def __init__(self, percentiles=[0, 99.5], channel_wise=False):
+        self.lower, self.upper = percentiles
+        self.channel_wise = channel_wise
+
+    def _normalize(self, img) -> np.ndarray:
+        non_zero_vals = img[np.nonzero(img)]
+        percentiles = np.percentile(non_zero_vals, [self.lower, self.upper])
+        img_norm = exposure.rescale_intensity(
+            img, in_range=(percentiles[0], percentiles[1]), out_range="uint8"
+        )
+
+        return img_norm.astype(np.uint8)
+
+    def __call__(self, img: np.ndarray) -> np.ndarray:
+        if self.channel_wise:
+            pre_img_data = np.zeros(img.shape, dtype=np.uint8)
+            for i in range(img.shape[-1]):
+                img_channel_i = img[:, :, i]
+
+                if len(img_channel_i[np.nonzero(img_channel_i)]) > 0:
+                    pre_img_data[:, :, i] = self._normalize(img_channel_i)
+
+            img = pre_img_data
+
+        else:
+            img = self._normalize(img)
+
+        return img
+
+
+class CustomNormalizeImaged(MapTransform):
+    """Dictionary-based wrapper of NormalizeImage"""
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        percentiles=[1, 99],
+        channel_wise: bool = False,
+        allow_missing_keys: bool = False,
+    ):
+        super(CustomNormalizeImageD, self).__init__(keys, allow_missing_keys)
+        self.normalizer = CustomNormalizeImage(percentiles, channel_wise)
+
+    def __call__(
+        self, data: Mapping[Hashable, np.ndarray]
+    ) -> Dict[Hashable, np.ndarray]:
+
+        d = dict(data)
+
+        for key in self.keys:
+            d[key] = self.normalizer(d[key])
+
+        return d
+
+
+CustomNormalizeImageD = CustomNormalizeImageDict = CustomNormalizeImaged

__init__.py

@@ -0,0 +1,3 @@
+from .LoadImage import *
+from .NormalizeImage import *
+from .CellAware import *

modalities.pkl

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