| import logging |
| import warnings |
| from functools import lru_cache |
| from typing import Tuple, Optional, List |
|
|
| import cv2 |
| import numpy as np |
|
|
| transforms_logger = logging.getLogger(__name__) |
|
|
|
|
| @lru_cache(maxsize=None) |
| def _patch_intensity_mask(patch_height: int = 224, patch_width: int = 224, sig: float = 7.5): |
| """ |
| Provides an intensity mask, given a patch size, based on an exponential function. |
| Values close to the center of the patch are close to 1. |
| When we are 20 pixels from the edges, we are ~0.88. Then, we have a drastic drop |
| to 0 at the edges. |
| Args: |
| patch_height: Input patch height |
| patch_width: Input patch width |
| sig: Sigma that divides the exponential. |
| |
| Returns: |
| An intensity map as a numpy array, with shape == (patch_height, patch_width) |
| """ |
| max_size = max(224, patch_height, patch_width) |
| xm = np.arange(max_size) |
| xm = np.abs(xm - xm.mean()) |
| mask = 1 / (1 + np.exp((xm - (max_size / 2 - 20)) / sig)) |
| mask = mask * mask[:, np.newaxis] |
| mask = mask[ |
| max_size // 2 - patch_height // 2: max_size // 2 + patch_height // 2 + patch_height % 2, |
| max_size // 2 - patch_width // 2: max_size // 2 + patch_width // 2 + patch_width % 2] |
| return mask |
|
|
|
|
| def average_patches(patches: np.ndarray, y_sub: List[Tuple[int, int]], x_sub: List[Tuple[int, int]], |
| height: int, width: int): |
| """ |
| Average the patch values over an image of (height, width). |
| Args: |
| patches: numpy array of (# patches, # classes == 3, patch_height, patch_width) |
| y_sub: list of integer tuples. Each tuple contains the start and ending position of |
| the patch in the y-axis. |
| x_sub: list of integer tuples. Each tuple contains the start and ending position of |
| the patch in the x-axis. |
| height: output image height |
| width: output image width |
| |
| Returns: |
| A numpy array of (height, width) with the average of the patches with appropriate overlap interpolation. |
| """ |
| intensity_mask = np.zeros((height, width), dtype=np.float32) |
| mean_output = np.zeros((patches.shape[1], height, width), dtype=np.float32) |
| patch_intensity_mask = _patch_intensity_mask(patch_height=patches.shape[-2], patch_width=patches.shape[-1]) |
|
|
| for i in range(len(y_sub)): |
| mean_output[:, y_sub[i][0]:y_sub[i][1], x_sub[i][0]:x_sub[i][1]] += patches[i] * patch_intensity_mask |
| intensity_mask[y_sub[i][0]:y_sub[i][1], x_sub[i][0]:x_sub[i][1]] += patch_intensity_mask |
|
|
| return mean_output / intensity_mask |
|
|
|
|
| def split_in_patches(x: np.ndarray, patch_size: int = 224, tile_overlap: float = 0.1): |
| """ make tiles of image to run at test-time |
| |
| Parameters |
| ---------- |
| x : float32 |
| array that's n_channels x height x width |
| |
| patch_size : int (optional, default 224) |
| size of tiles |
| |
| |
| tile_overlap: float (optional, default 0.1) |
| fraction of overlap of tiles |
| |
| Returns |
| ------- |
| patches : float32 |
| array that's ntiles x n_channels x bsize x bsize |
| |
| y_sub : list |
| list of arrays with start and end of tiles in Y of length ntiles |
| |
| x_sub : list |
| list of arrays with start and end of tiles in X of length ntiles |
| |
| |
| """ |
|
|
| n_channels, height, width = x.shape |
|
|
| tile_overlap = min(0.5, max(0.05, tile_overlap)) |
| patch_height = np.int32(min(patch_size, height)) |
| patch_width = np.int32(min(patch_size, width)) |
|
|
| |
| ny = 1 if height <= patch_size else int(np.ceil((1. + 2 * tile_overlap) * height / patch_size)) |
| nx = 1 if width <= patch_size else int(np.ceil((1. + 2 * tile_overlap) * width / patch_size)) |
|
|
| y_start = np.linspace(0, height - patch_height, ny).astype(np.int32) |
| x_start = np.linspace(0, width - patch_width, nx).astype(np.int32) |
|
|
| y_sub, x_sub = [], [] |
| patches = np.zeros((len(y_start), len(x_start), n_channels, patch_height, patch_width), np.float32) |
| for j in range(len(y_start)): |
| for i in range(len(x_start)): |
| y_sub.append([y_start[j], y_start[j] + patch_height]) |
| x_sub.append([x_start[i], x_start[i] + patch_width]) |
| patches[j, i] = x[:, y_sub[-1][0]:y_sub[-1][1], x_sub[-1][0]:x_sub[-1][1]] |
|
|
| return patches, y_sub, x_sub |
|
|
|
|
| def convert_image_grayscale(x: np.ndarray): |
| assert x.ndim == 2 |
| x = x.astype(np.float32) |
| x = x[:, :, np.newaxis] |
| x = np.concatenate((x, np.zeros_like(x)), axis=-1) |
| return x |
|
|
|
|
| def convert_image(x, channels: Tuple[int, int]): |
| assert len(channels) == 2 |
|
|
| return reshape(x, channels=channels) |
|
|
|
|
| def reshape(x: np.ndarray, channels=(0, 0)): |
| """ reshape data using channels |
| |
| Parameters |
| ---------- |
| x : Numpy array, channel last. |
| |
| channels : list of int of length 2 (optional, default [0,0]) |
| First element of list is the channel to segment (0=grayscale, 1=red, 2=green, 3=blue). |
| Second element of list is the optional nuclear channel (0=none, 1=red, 2=green, 3=blue). |
| For instance, to train on grayscale images, input [0,0]. To train on images with cells |
| in green and nuclei in blue, input [2,3]. |
| |
| |
| Returns |
| ------- |
| data : numpy array that's (Z x ) Ly x Lx x nchan (if chan_first==False) |
| |
| """ |
| x = x.astype(np.float32) |
| if x.ndim < 3: |
| x = x[:, :, np.newaxis] |
|
|
| if x.shape[-1] == 1: |
| x = np.concatenate((x, np.zeros_like(x)), axis=-1) |
| else: |
| if channels[0] == 0: |
| x = x.mean(axis=-1, keepdims=True) |
| x = np.concatenate((x, np.zeros_like(x)), axis=-1) |
| else: |
| channels_index = [channels[0] - 1] |
| if channels[1] > 0: |
| channels_index.append(channels[1] - 1) |
| x = x[..., channels_index] |
| for i in range(x.shape[-1]): |
| if np.ptp(x[..., i]) == 0.0: |
| if i == 0: |
| warnings.warn("chan to seg' has value range of ZERO") |
| else: |
| warnings.warn("'chan2 (opt)' has value range of ZERO, can instead set chan2 to 0") |
| if x.shape[-1] == 1: |
| x = np.concatenate((x, np.zeros_like(x)), axis=-1) |
|
|
| return np.transpose(x, (2, 0, 1)) |
|
|
|
|
| def resize_image(image, height: Optional[int] = None, width: Optional[int] = None, resize: Optional[float] = None, |
| interpolation=cv2.INTER_LINEAR, no_channels=False): |
| """ resize image for computing flows / unresize for computing dynamics |
| |
| Parameters |
| ------------- |
| |
| image: ND-array |
| image of size [Y x X x nchan] or [Lz x Y x X x nchan] or [Lz x Y x X] |
| |
| height: int, optional |
| |
| width: int, optional |
| |
| resize: float, optional |
| resize coefficient(s) for image; if Ly is None then rsz is used |
| |
| interpolation: cv2 interp method (optional, default cv2.INTER_LINEAR) |
| |
| Returns |
| -------------- |
| |
| imgs: ND-array |
| image of size [Ly x Lx x nchan] or [Lz x Ly x Lx x nchan] |
| |
| """ |
| if height is None and resize is None: |
| error_message = 'must give size to resize to or factor to use for resizing' |
| transforms_logger.critical(error_message) |
| raise ValueError(error_message) |
|
|
| if height is None: |
| |
| if not isinstance(resize, list) and not isinstance(resize, np.ndarray): |
| resize = [resize, resize] |
| if no_channels: |
| height = int(image.shape[-2] * resize[-2]) |
| width = int(image.shape[-1] * resize[-1]) |
| else: |
| height = int(image.shape[-3] * resize[-2]) |
| width = int(image.shape[-2] * resize[-1]) |
|
|
| return cv2.resize(image, (width, height), interpolation=interpolation) |
|
|
|
|
| def pad_image(x: np.ndarray, div: int = 16): |
| """ pad image for test-time so that its dimensions are a multiple of 16 (2D or 3D) |
| |
| Parameters |
| ------------- |
| |
| x: ND-array |
| image of size [nchan (x Lz) x height x width] |
| |
| div: int (optional, default 16) |
| |
| Returns |
| -------------- |
| |
| output: ND-array |
| padded image |
| |
| y_sub: array, int |
| yrange of pixels in output corresponding to img0 |
| |
| x_sub: array, int |
| xrange of pixels in output corresponding to img0 |
| |
| """ |
| x_pad = int(div * np.ceil(x.shape[-2] / div) - x.shape[-2]) |
| x_pad_left = div // 2 + x_pad // 2 |
| x_pad_right = div // 2 + x_pad - x_pad // 2 |
|
|
| y_pad = int(div * np.ceil(x.shape[-1] / div) - x.shape[-1]) |
| y_pad_left = div // 2 + y_pad // 2 |
| y_pad_right = div // 2 + y_pad - y_pad // 2 |
|
|
| if x.ndim > 3: |
| pads = np.array([[0, 0], [0, 0], [x_pad_left, x_pad_right], [y_pad_left, y_pad_right]]) |
| else: |
| pads = np.array([[0, 0], [x_pad_left, x_pad_right], [y_pad_left, y_pad_right]]) |
|
|
| output = np.pad(x, pads, mode='constant') |
|
|
| height, width = x.shape[-2:] |
| y_sub = np.arange(x_pad_left, x_pad_left + height) |
| x_sub = np.arange(y_pad_left, y_pad_left + width) |
| return output, y_sub, x_sub |
