| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| """ |
| A collection of "vanilla" transforms for crop and pad operations |
| https://github.com/Project-MONAI/MONAI/wiki/MONAI_Design |
| """ |
|
|
| from typing import Any, Callable, List, Optional, Sequence, Tuple, Union |
|
|
| import numpy as np |
|
|
| from monai.config import IndexSelection |
| from monai.data.utils import get_random_patch, get_valid_patch_size |
| from monai.transforms.compose import Randomizable, Transform |
| from monai.transforms.utils import ( |
| generate_pos_neg_label_crop_centers, |
| generate_spatial_bounding_box, |
| map_binary_to_indices, |
| ) |
| from monai.utils import Method, NumpyPadMode, ensure_tuple, fall_back_tuple |
|
|
|
|
| class SpatialPad(Transform): |
| """ |
| Performs padding to the data, symmetric for all sides or all on one side for each dimension. |
| Uses np.pad so in practice, a mode needs to be provided. See numpy.lib.arraypad.pad |
| for additional details. |
| |
| Args: |
| spatial_size: the spatial size of output data after padding. |
| If its components have non-positive values, the corresponding size of input image will be used (no padding). |
| method: {``"symmetric"``, ``"end"``} |
| Pad image symmetric on every side or only pad at the end sides. Defaults to ``"symmetric"``. |
| mode: {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``, |
| ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``} |
| One of the listed string values or a user supplied function. Defaults to ``"constant"``. |
| See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html |
| """ |
|
|
| def __init__( |
| self, |
| spatial_size: Union[Sequence[int], int], |
| method: Union[Method, str] = Method.SYMMETRIC, |
| mode: Union[NumpyPadMode, str] = NumpyPadMode.CONSTANT, |
| ) -> None: |
| self.spatial_size = spatial_size |
| self.method: Method = Method(method) |
| self.mode: NumpyPadMode = NumpyPadMode(mode) |
|
|
| def _determine_data_pad_width(self, data_shape: Sequence[int]) -> List[Tuple[int, int]]: |
| self.spatial_size = fall_back_tuple(self.spatial_size, data_shape) |
| if self.method == Method.SYMMETRIC: |
| pad_width = list() |
| for i in range(len(self.spatial_size)): |
| width = max(self.spatial_size[i] - data_shape[i], 0) |
| pad_width.append((width // 2, width - (width // 2))) |
| return pad_width |
| else: |
| return [(0, max(self.spatial_size[i] - data_shape[i], 0)) for i in range(len(self.spatial_size))] |
|
|
| def __call__(self, img: np.ndarray, mode: Optional[Union[NumpyPadMode, str]] = None) -> np.ndarray: |
| """ |
| Args: |
| img: data to be transformed, assuming `img` is channel-first and |
| padding doesn't apply to the channel dim. |
| mode: {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``, |
| ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``} |
| One of the listed string values or a user supplied function. Defaults to ``self.mode``. |
| See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html |
| """ |
| data_pad_width = self._determine_data_pad_width(img.shape[1:]) |
| all_pad_width = [(0, 0)] + data_pad_width |
| if not np.asarray(all_pad_width).any(): |
| |
| return img |
| else: |
| img = np.pad(img, all_pad_width, mode=self.mode.value if mode is None else NumpyPadMode(mode).value) |
| return img |
|
|
|
|
| class BorderPad(Transform): |
| """ |
| Pad the input data by adding specified borders to every dimension. |
| |
| Args: |
| spatial_border: specified size for every spatial border. it can be 3 shapes: |
| |
| - single int number, pad all the borders with the same size. |
| - length equals the length of image shape, pad every spatial dimension separately. |
| for example, image shape(CHW) is [1, 4, 4], spatial_border is [2, 1], |
| pad every border of H dim with 2, pad every border of W dim with 1, result shape is [1, 8, 6]. |
| - length equals 2 x (length of image shape), pad every border of every dimension separately. |
| for example, image shape(CHW) is [1, 4, 4], spatial_border is [1, 2, 3, 4], pad top of H dim with 1, |
| pad bottom of H dim with 2, pad left of W dim with 3, pad right of W dim with 4. |
| the result shape is [1, 7, 11]. |
| |
| mode: {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``, |
| ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``} |
| One of the listed string values or a user supplied function. Defaults to ``"constant"``. |
| See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html |
| """ |
|
|
| def __init__( |
| self, spatial_border: Union[Sequence[int], int], mode: Union[NumpyPadMode, str] = NumpyPadMode.CONSTANT |
| ) -> None: |
| self.spatial_border = spatial_border |
| self.mode: NumpyPadMode = NumpyPadMode(mode) |
|
|
| def __call__(self, img: np.ndarray, mode: Optional[Union[NumpyPadMode, str]] = None) -> np.ndarray: |
| """ |
| Args: |
| img: data to be transformed, assuming `img` is channel-first and |
| padding doesn't apply to the channel dim. |
| mode: {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``, |
| ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``} |
| One of the listed string values or a user supplied function. Defaults to ``self.mode``. |
| See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html |
| |
| Raises: |
| ValueError: When ``self.spatial_border`` contains a nonnegative int. |
| ValueError: When ``self.spatial_border`` length is not one of |
| [1, len(spatial_shape), 2*len(spatial_shape)]. |
| |
| """ |
| spatial_shape = img.shape[1:] |
| spatial_border = ensure_tuple(self.spatial_border) |
| for b in spatial_border: |
| if not isinstance(b, int) or b < 0: |
| raise ValueError(f"self.spatial_border must contain only nonnegative ints, got {spatial_border}.") |
|
|
| if len(spatial_border) == 1: |
| data_pad_width = [(spatial_border[0], spatial_border[0]) for _ in range(len(spatial_shape))] |
| elif len(spatial_border) == len(spatial_shape): |
| data_pad_width = [(spatial_border[i], spatial_border[i]) for i in range(len(spatial_shape))] |
| elif len(spatial_border) == len(spatial_shape) * 2: |
| data_pad_width = [(spatial_border[2 * i], spatial_border[2 * i + 1]) for i in range(len(spatial_shape))] |
| else: |
| raise ValueError( |
| f"Unsupported spatial_border length: {len(spatial_border)}, available options are " |
| f"[1, len(spatial_shape)={len(spatial_shape)}, 2*len(spatial_shape)={2*len(spatial_shape)}]." |
| ) |
|
|
| return np.pad( |
| img, [(0, 0)] + data_pad_width, mode=self.mode.value if mode is None else NumpyPadMode(mode).value |
| ) |
|
|
|
|
| class DivisiblePad(Transform): |
| """ |
| Pad the input data, so that the spatial sizes are divisible by `k`. |
| """ |
|
|
| def __init__(self, k: Union[Sequence[int], int], mode: Union[NumpyPadMode, str] = NumpyPadMode.CONSTANT) -> None: |
| """ |
| Args: |
| k: the target k for each spatial dimension. |
| if `k` is negative or 0, the original size is preserved. |
| if `k` is an int, the same `k` be applied to all the input spatial dimensions. |
| mode: {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``, |
| ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``} |
| One of the listed string values or a user supplied function. Defaults to ``"constant"``. |
| See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html |
| |
| See also :py:class:`monai.transforms.SpatialPad` |
| """ |
| self.k = k |
| self.mode: NumpyPadMode = NumpyPadMode(mode) |
|
|
| def __call__(self, img: np.ndarray, mode: Optional[Union[NumpyPadMode, str]] = None) -> np.ndarray: |
| """ |
| Args: |
| img: data to be transformed, assuming `img` is channel-first |
| and padding doesn't apply to the channel dim. |
| mode: {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``, |
| ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``} |
| One of the listed string values or a user supplied function. Defaults to ``self.mode``. |
| See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html |
| """ |
| spatial_shape = img.shape[1:] |
| k = fall_back_tuple(self.k, (1,) * len(spatial_shape)) |
| new_size = [] |
| for k_d, dim in zip(k, spatial_shape): |
| new_dim = int(np.ceil(dim / k_d) * k_d) if k_d > 0 else dim |
| new_size.append(new_dim) |
|
|
| spatial_pad = SpatialPad(spatial_size=new_size, method=Method.SYMMETRIC, mode=mode or self.mode) |
| return spatial_pad(img) |
|
|
|
|
| class SpatialCrop(Transform): |
| """ |
| General purpose cropper to produce sub-volume region of interest (ROI). |
| It can support to crop ND spatial (channel-first) data. |
| Either a spatial center and size must be provided, or alternatively if center and size |
| are not provided, the start and end coordinates of the ROI must be provided. |
| The sub-volume must sit the within original image. |
| Note: This transform will not work if the crop region is larger than the image itself. |
| """ |
|
|
| def __init__( |
| self, |
| roi_center: Optional[Sequence[int]] = None, |
| roi_size: Optional[Sequence[int]] = None, |
| roi_start: Optional[Sequence[int]] = None, |
| roi_end: Optional[Sequence[int]] = None, |
| ) -> None: |
| """ |
| Args: |
| roi_center: voxel coordinates for center of the crop ROI. |
| roi_size: size of the crop ROI. |
| roi_start: voxel coordinates for start of the crop ROI. |
| roi_end: voxel coordinates for end of the crop ROI. |
| """ |
| if roi_center is not None and roi_size is not None: |
| roi_center = np.asarray(roi_center, dtype=np.uint16) |
| roi_size = np.asarray(roi_size, dtype=np.uint16) |
| self.roi_start = np.subtract(roi_center, np.floor_divide(roi_size, 2)) |
| self.roi_end = np.add(self.roi_start, roi_size) |
| else: |
| assert roi_start is not None and roi_end is not None, "roi_start and roi_end must be provided." |
| self.roi_start = np.asarray(roi_start, dtype=np.uint16) |
| self.roi_end = np.asarray(roi_end, dtype=np.uint16) |
|
|
| assert np.all(self.roi_start >= 0), "all elements of roi_start must be greater than or equal to 0." |
| assert np.all(self.roi_end > 0), "all elements of roi_end must be positive." |
| assert np.all(self.roi_end >= self.roi_start), "invalid roi range." |
|
|
| def __call__(self, img: np.ndarray) -> np.ndarray: |
| """ |
| Apply the transform to `img`, assuming `img` is channel-first and |
| slicing doesn't apply to the channel dim. |
| """ |
| max_end = img.shape[1:] |
| sd = min(len(self.roi_start), len(max_end)) |
| assert np.all(max_end[:sd] >= self.roi_start[:sd]), "roi start out of image space." |
| assert np.all(max_end[:sd] >= self.roi_end[:sd]), "roi end out of image space." |
|
|
| slices = [slice(None)] + [slice(s, e) for s, e in zip(self.roi_start[:sd], self.roi_end[:sd])] |
| return img[tuple(slices)] |
|
|
|
|
| class CenterSpatialCrop(Transform): |
| """ |
| Crop at the center of image with specified ROI size. |
| |
| Args: |
| roi_size: the spatial size of the crop region e.g. [224,224,128] |
| If its components have non-positive values, the corresponding size of input image will be used. |
| """ |
|
|
| def __init__(self, roi_size: Union[Sequence[int], int]) -> None: |
| self.roi_size = roi_size |
|
|
| def __call__(self, img: np.ndarray) -> np.ndarray: |
| """ |
| Apply the transform to `img`, assuming `img` is channel-first and |
| slicing doesn't apply to the channel dim. |
| """ |
| self.roi_size = fall_back_tuple(self.roi_size, img.shape[1:]) |
| center = [i // 2 for i in img.shape[1:]] |
| cropper = SpatialCrop(roi_center=center, roi_size=self.roi_size) |
| return cropper(img) |
|
|
|
|
| class RandSpatialCrop(Randomizable, Transform): |
| """ |
| Crop image with random size or specific size ROI. It can crop at a random position as center |
| or at the image center. And allows to set the minimum size to limit the randomly generated ROI. |
| |
| Args: |
| roi_size: if `random_size` is True, it specifies the minimum crop region. |
| if `random_size` is False, it specifies the expected ROI size to crop. e.g. [224, 224, 128] |
| If its components have non-positive values, the corresponding size of input image will be used. |
| random_center: crop at random position as center or the image center. |
| random_size: crop with random size or specific size ROI. |
| The actual size is sampled from `randint(roi_size, img_size)`. |
| """ |
|
|
| def __init__( |
| self, roi_size: Union[Sequence[int], int], random_center: bool = True, random_size: bool = True |
| ) -> None: |
| self.roi_size = roi_size |
| self.random_center = random_center |
| self.random_size = random_size |
| self._size: Optional[Sequence[int]] = None |
| self._slices: Optional[Tuple[slice, ...]] = None |
|
|
| def randomize(self, img_size: Sequence[int]) -> None: |
| self._size = fall_back_tuple(self.roi_size, img_size) |
| if self.random_size: |
| self._size = tuple((self.R.randint(low=self._size[i], high=img_size[i] + 1) for i in range(len(img_size)))) |
| if self.random_center: |
| valid_size = get_valid_patch_size(img_size, self._size) |
| self._slices = (slice(None),) + get_random_patch(img_size, valid_size, self.R) |
|
|
| def __call__(self, img: np.ndarray) -> np.ndarray: |
| """ |
| Apply the transform to `img`, assuming `img` is channel-first and |
| slicing doesn't apply to the channel dim. |
| """ |
| self.randomize(img.shape[1:]) |
| assert self._size is not None |
| if self.random_center: |
| return img[self._slices] |
| else: |
| cropper = CenterSpatialCrop(self._size) |
| return cropper(img) |
|
|
|
|
| class RandSpatialCropSamples(Randomizable, Transform): |
| """ |
| Crop image with random size or specific size ROI to generate a list of N samples. |
| It can crop at a random position as center or at the image center. And allows to set |
| the minimum size to limit the randomly generated ROI. |
| It will return a list of cropped images. |
| |
| Args: |
| roi_size: if `random_size` is True, the spatial size of the minimum crop region. |
| if `random_size` is False, specify the expected ROI size to crop. e.g. [224, 224, 128] |
| num_samples: number of samples (crop regions) to take in the returned list. |
| random_center: crop at random position as center or the image center. |
| random_size: crop with random size or specific size ROI. |
| The actual size is sampled from `randint(roi_size, img_size)`. |
| |
| Raises: |
| ValueError: When ``num_samples`` is nonpositive. |
| |
| """ |
|
|
| def __init__( |
| self, |
| roi_size: Union[Sequence[int], int], |
| num_samples: int, |
| random_center: bool = True, |
| random_size: bool = True, |
| ) -> None: |
| if num_samples < 1: |
| raise ValueError(f"num_samples must be positive, got {num_samples}.") |
| self.num_samples = num_samples |
| self.cropper = RandSpatialCrop(roi_size, random_center, random_size) |
|
|
| def randomize(self, data: Optional[Any] = None) -> None: |
| pass |
|
|
| def __call__(self, img: np.ndarray) -> List[np.ndarray]: |
| """ |
| Apply the transform to `img`, assuming `img` is channel-first and |
| cropping doesn't change the channel dim. |
| """ |
| return [self.cropper(img) for _ in range(self.num_samples)] |
|
|
|
|
| class CropForeground(Transform): |
| """ |
| Crop an image using a bounding box. The bounding box is generated by selecting foreground using select_fn |
| at channels channel_indices. margin is added in each spatial dimension of the bounding box. |
| The typical usage is to help training and evaluation if the valid part is small in the whole medical image. |
| Users can define arbitrary function to select expected foreground from the whole image or specified channels. |
| And it can also add margin to every dim of the bounding box of foreground object. |
| For example: |
| |
| .. code-block:: python |
| |
| image = np.array( |
| [[[0, 0, 0, 0, 0], |
| [0, 1, 2, 1, 0], |
| [0, 1, 3, 2, 0], |
| [0, 1, 2, 1, 0], |
| [0, 0, 0, 0, 0]]]) # 1x5x5, single channel 5x5 image |
| cropper = CropForeground(select_fn=lambda x: x > 1, margin=0) |
| print(cropper(image)) |
| [[[2, 1], |
| [3, 2], |
| [2, 1]]] |
| |
| """ |
|
|
| def __init__( |
| self, select_fn: Callable = lambda x: x > 0, channel_indices: Optional[IndexSelection] = None, margin: int = 0 |
| ) -> None: |
| """ |
| Args: |
| select_fn: function to select expected foreground, default is to select values > 0. |
| channel_indices: if defined, select foreground only on the specified channels |
| of image. if None, select foreground on the whole image. |
| margin: add margin to all dims of the bounding box. |
| """ |
| self.select_fn = select_fn |
| self.channel_indices = ensure_tuple(channel_indices) if channel_indices is not None else None |
| self.margin = margin |
|
|
| def __call__(self, img: np.ndarray) -> np.ndarray: |
| """ |
| Apply the transform to `img`, assuming `img` is channel-first and |
| slicing doesn't change the channel dim. |
| """ |
| box_start, box_end = generate_spatial_bounding_box(img, self.select_fn, self.channel_indices, self.margin) |
| cropper = SpatialCrop(roi_start=box_start, roi_end=box_end) |
| return cropper(img) |
|
|
|
|
| class RandCropByPosNegLabel(Randomizable, Transform): |
| """ |
| Crop random fixed sized regions with the center being a foreground or background voxel |
| based on the Pos Neg Ratio. |
| And will return a list of arrays for all the cropped images. |
| For example, crop two (3 x 3) arrays from (5 x 5) array with pos/neg=1:: |
| |
| [[[0, 0, 0, 0, 0], |
| [0, 1, 2, 1, 0], [[0, 1, 2], [[2, 1, 0], |
| [0, 1, 3, 0, 0], --> [0, 1, 3], [3, 0, 0], |
| [0, 0, 0, 0, 0], [0, 0, 0]] [0, 0, 0]] |
| [0, 0, 0, 0, 0]]] |
| |
| Args: |
| spatial_size: the spatial size of the crop region e.g. [224, 224, 128]. |
| If its components have non-positive values, the corresponding size of `label` will be used. |
| label: the label image that is used for finding foreground/background, if None, must set at |
| `self.__call__`. Non-zero indicates foreground, zero indicates background. |
| pos: used with `neg` together to calculate the ratio ``pos / (pos + neg)`` for the probability |
| to pick a foreground voxel as a center rather than a background voxel. |
| neg: used with `pos` together to calculate the ratio ``pos / (pos + neg)`` for the probability |
| to pick a foreground voxel as a center rather than a background voxel. |
| num_samples: number of samples (crop regions) to take in each list. |
| image: optional image data to help select valid area, can be same as `img` or another image array. |
| if not None, use ``label == 0 & image > image_threshold`` to select the negative |
| sample (background) center. So the crop center will only come from the valid image areas. |
| image_threshold: if enabled `image`, use ``image > image_threshold`` to determine |
| the valid image content areas. |
| fg_indices: if provided pre-computed foreground indices of `label`, will ignore above `image` and |
| `image_threshold`, and randomly select crop centers based on them, need to provide `fg_indices` |
| and `bg_indices` together, expect to be 1 dim array of spatial indices after flattening. |
| a typical usage is to call `FgBgToIndices` transform first and cache the results. |
| bg_indices: if provided pre-computed background indices of `label`, will ignore above `image` and |
| `image_threshold`, and randomly select crop centers based on them, need to provide `fg_indices` |
| and `bg_indices` together, expect to be 1 dim array of spatial indices after flattening. |
| a typical usage is to call `FgBgToIndices` transform first and cache the results. |
| |
| Raises: |
| ValueError: When ``pos`` or ``neg`` are negative. |
| ValueError: When ``pos=0`` and ``neg=0``. Incompatible values. |
| |
| """ |
|
|
| def __init__( |
| self, |
| spatial_size: Union[Sequence[int], int], |
| label: Optional[np.ndarray] = None, |
| pos: float = 1.0, |
| neg: float = 1.0, |
| num_samples: int = 1, |
| image: Optional[np.ndarray] = None, |
| image_threshold: float = 0.0, |
| fg_indices: Optional[np.ndarray] = None, |
| bg_indices: Optional[np.ndarray] = None, |
| ) -> None: |
| self.spatial_size = ensure_tuple(spatial_size) |
| self.label = label |
| if pos < 0 or neg < 0: |
| raise ValueError(f"pos and neg must be nonnegative, got pos={pos} neg={neg}.") |
| if pos + neg == 0: |
| raise ValueError("Incompatible values: pos=0 and neg=0.") |
| self.pos_ratio = pos / (pos + neg) |
| self.num_samples = num_samples |
| self.image = image |
| self.image_threshold = image_threshold |
| self.centers: Optional[List[List[np.ndarray]]] = None |
| self.fg_indices = fg_indices |
| self.bg_indices = bg_indices |
|
|
| def randomize( |
| self, |
| label: np.ndarray, |
| fg_indices: Optional[np.ndarray] = None, |
| bg_indices: Optional[np.ndarray] = None, |
| image: Optional[np.ndarray] = None, |
| ) -> None: |
| self.spatial_size = fall_back_tuple(self.spatial_size, default=label.shape[1:]) |
| if fg_indices is None or bg_indices is None: |
| fg_indices_, bg_indices_ = map_binary_to_indices(label, image, self.image_threshold) |
| else: |
| fg_indices_ = fg_indices |
| bg_indices_ = bg_indices |
| self.centers = generate_pos_neg_label_crop_centers( |
| self.spatial_size, self.num_samples, self.pos_ratio, label.shape[1:], fg_indices_, bg_indices_, self.R |
| ) |
|
|
| def __call__( |
| self, |
| img: np.ndarray, |
| label: Optional[np.ndarray] = None, |
| image: Optional[np.ndarray] = None, |
| fg_indices: Optional[np.ndarray] = None, |
| bg_indices: Optional[np.ndarray] = None, |
| ) -> List[np.ndarray]: |
| """ |
| Args: |
| img: input data to crop samples from based on the pos/neg ratio of `label` and `image`. |
| Assumes `img` is a channel-first array. |
| label: the label image that is used for finding foreground/background, if None, use `self.label`. |
| image: optional image data to help select valid area, can be same as `img` or another image array. |
| use ``label == 0 & image > image_threshold`` to select the negative sample(background) center. |
| so the crop center will only exist on valid image area. if None, use `self.image`. |
| fg_indices: foreground indices to randomly select crop centers, |
| need to provide `fg_indices` and `bg_indices` together. |
| bg_indices: background indices to randomly select crop centers, |
| need to provide `fg_indices` and `bg_indices` together. |
| |
| """ |
| if label is None: |
| label = self.label |
| if image is None: |
| image = self.image |
| if fg_indices is None or bg_indices is None: |
| if self.fg_indices is not None and self.bg_indices is not None: |
| fg_indices = self.fg_indices |
| bg_indices = self.bg_indices |
| else: |
| fg_indices, bg_indices = map_binary_to_indices(label, image, self.image_threshold) |
| self.randomize(label, fg_indices, bg_indices, image) |
| results: List[np.ndarray] = list() |
| if self.centers is not None: |
| for center in self.centers: |
| cropper = SpatialCrop(roi_center=tuple(center), roi_size=self.spatial_size) |
| results.append(cropper(img)) |
|
|
| return results |
|
|
