acvl-utils 0.2__tar.gz

acvl_utils-0.2/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: acvl_utils
+Version: 0.2
+Summary: Super cool utilities that we just love to use
+Author: Applied Computer Vision Lab, Helmholtz Imaging & Division of Medical Image Computing, German Cancer Research Center
+Author-email: f.isensee@dkfz.de
+License: Apache License Version 2.0, January 2004

acvl_utils-0.2/acvl_utils/array_manipulation/resampling.py

@@ -0,0 +1,93 @@
+from typing import Tuple
+
+import torch
+from torch.nn import functional as F
+
+
+def maybe_resample_on_gpu(data: torch.Tensor,
+                          target_shape: Tuple[int, ...],
+                          return_type=torch.half,
+                          compute_device: str = 'cuda:0', result_device: str = 'cuda:0',
+                          compute_precision=torch.half,
+                          fallback_compute_device: str = 'cpu', fallback_result_device: str = 'cpu',
+                          fallback_compute_precision=torch.float,
+                          verbose: bool = True) -> torch.Tensor:
+    """
+    channel-wise resampling function. Most useful for softmax resampling. Tries three things:
+    - resample the entire array at once on compute_device (fastest but uses the most memory). returned tensor will be on result_device
+    - failing that it will resample channel-wise on compute_device. returned tensor will be on fallback_result_device
+    - failing that it will resample channel-wise on fallback_device. returned tensor will be on fallback_result_device
+
+    data must be a 4d tensor of shape (c, x, y, z). It will be resampled to shape (tx, ty, tz), so the returned tensor
+    will have shape (c, tx, ty, tz)
+
+    returned tensor will be on result_device/fallback_result_device
+    returned tensor will have dtype return_type. half recommended if memory is scarce
+
+    fallback_compute_precision must be torch.float for CPU (half not implemented as of 11/2022)
+
+    this function does not use with torch.no_grad()!! You need to do this externally
+
+    Defaults for compute_device, result_device, compute_precision, fallback_compute_device, fallback_result_device,
+    fallback_compute_precision are good and should only be deviated from by experts.
+    """
+
+    def _maybe_empty_cache():
+        if torch.cuda.is_available(): torch.cuda.empty_cache()
+
+    def _allocate_result_tensor(shape, dtype, device, fallback_device) -> torch.Tensor:
+        try:
+            softmax_resampled = torch.zeros(shape, dtype=dtype, device=device)
+        except RuntimeError:
+            if verbose:
+                print(f'could not allocate result tensor of shape {(data.shape[0], *target_shape)} on device '
+                      f'{result_device}. Using fallback {fallback_device}')
+            assert fallback_device != device, 'Allocation on device failed and fallback_device=device so there is no ' \
+                                              'point attempting this. Duh.'
+            softmax_resampled = torch.zeros(shape, dtype=dtype, device=fallback_device)
+        finally:
+            _maybe_empty_cache()
+        return softmax_resampled
+
+    _maybe_empty_cache()
+
+    if all([i == j for i, j in zip(data.shape[1:], target_shape)]):
+        try:
+            return data.to(result_device)
+        except RuntimeError:
+            return data.to(fallback_result_device)
+
+    try:
+        # try all in one
+        result_tensor = \
+        F.interpolate(data.to(compute_device).type(compute_precision)[None], target_shape, mode='trilinear')[0].type(
+            return_type).to(result_device)
+    except RuntimeError:
+        if verbose:
+            print(f'Resampling all in one failed, attempting channel-wise on compute_device {compute_device}')
+        try:
+            _maybe_empty_cache()
+            # allocate result tensor
+            result_tensor = _allocate_result_tensor((data.shape[0], *target_shape), return_type, result_device,
+                                                    fallback_result_device)
+            for c in range(data.shape[0]):
+                result_tensor[c] = F.interpolate(data[c][None, None].to(compute_device).type(compute_precision),
+                                                 size=target_shape,
+                                                 mode='trilinear')[0, 0].to(result_tensor.device)
+        except RuntimeError:
+            if verbose:
+                print(f'Resampling channel-wise on compute_device {compute_device} failed, attempting chanel-wise '
+                      f'on fallback {fallback_compute_device}')
+            _maybe_empty_cache()
+            # allocate result tensor
+            result_tensor = _allocate_result_tensor((data.shape[0], *target_shape), return_type, fallback_result_device,
+                                                    fallback_result_device)
+            for c in range(data.shape[0]):
+                result_tensor[c] = F.interpolate(data[c][None, None].to(fallback_compute_device).type(fallback_compute_precision),
+                                                 size=target_shape,
+                                                 mode='trilinear')[0, 0].to(result_tensor.device)
+        finally:
+            _maybe_empty_cache()
+    finally:
+        _maybe_empty_cache()
+    return result_tensor

acvl_utils-0.2/acvl_utils/array_manipulation/slicer.py

@@ -0,0 +1,66 @@
+import numbers
+
+
+def slicer(arr, slices):
+    """
+    A dynamic N-dimensional array slicer that returns a tuple that can be used for slicing an N-dimensional array. Works exactly as Python and Numpy slicing, only with different syntax.
+    The conventional slicing method has the drawback that one must know the dimensionality of the array beforehand. By contrast, this slicer can be adapted dynamically at runtime.
+    :param arr: The array that should be sliced.
+    :param slices: A list of slices that obeys the syntax described below.
+    :return A tuple that can be used for slicing the array.
+
+    Use case example - Center crop augmentation for an N-dimensional image:
+    Imaging you have an N-dimensional array. You don't know what dimension it has. You want to crop each dimension to the center:
+        image = ...
+        print(image.shape)  # (32, 32) (48, 32, 32) or ...
+        indices = comp_indices(image, width=8)
+        # crop = image[???]  # Not possible to define a crop with arbitrary dimensions with regular slicing. Instead ...
+        if len(image.shape) == 2:
+            crop = image[indices[0][0]:indices[0][1], indices[1][0]:indices[1][1]]  # image[10:22, 10:22])
+        elif len(image.shape) == 3:
+            crop = image[indices[0][0]:indices[0][1], indices[1][0]:indices[1][1], indices[2][0]:indices[2][1]]  # image[18:30, 10:22, 10:22]
+        elif ...
+    As you see, this cannot be done with regular slicing as the slicing syntax needs to be hardcoded.
+    You would need to create an if case for each possible dimension.
+    However, this slicer function enables you to do just that dynamically for data with arbitrary dimensions:
+        image = ...
+        print(image.shape)  # (32, 32) (48, 32, 32) or ...
+        indices = comp_indices(image, width=8)
+        crop = data[slicer(data, indices)]  # Center crop the data
+
+    Syntax:
+    - ... -> None
+    - : -> [None]
+    - i -> i
+    - i:j -> [i, j]
+    - i: -> [i, None]
+    - :j -> [None, j]
+
+    Syntax examples:
+    - sub_arr = arr[5] -> sub_arr = arr[slicer(arr, [5])]
+    - sub_arr = arr[...] -> sub_arr = arr[slicer(arr, [None])]
+    - sub_arr = arr[..., 5] -> sub_arr = arr[slicer(arr, [None, 5])]
+    - sub_arr = arr[5:9] -> sub_arr = arr[slicer(arr, [[5, 9]])]
+    - sub_arr = arr[14:30, 12:17] -> sub_arr = arr[slicer(arr, [[14, 30], [12, 17]])]
+    - sub_arr = arr[14:30, 12:17, ...] -> sub_arr = arr[slicer(arr, [[14, 30], [12, 17], None])]
+    - sub_arr = arr[14:30, 12:17, :] -> sub_arr = arr[slicer(arr, [[14, 30], [12, 17], [None]])]
+    - sub_arr = arr[14:30, :-17, :] -> sub_arr = arr[slicer(arr, [[14, 30], [None, -17], [None]])]
+    - arr[5] = 7 -> arr[slicer(arr, [5])] = 7
+    - arr[15:30, 12:19] = np.zeros((15, 7)) -> arr[slicer(arr, [[15, 30], [12, 19]])] = np.zeros((15, 7))
+
+    This function was inspired by the following stackoverflow thread: https://stackoverflow.com/questions/24398708/slicing-a-numpy-array-along-a-dynamically-specified-axis/37729566#37729566
+    """
+    slc = [slice(None)] * len(arr.shape)
+    axis = 0
+    for i in range(len(slices)):
+        if slices[i] is None:  # Ellipsis: Take all values from multiple axes: array[..., ???]
+            axis = len(arr.shape) - (len(slices) - 1)
+        elif isinstance(slices[i], numbers.Number):  # Take single value from a single axis: array[???, i, ???]
+            slc[axis] = slices[i]
+            axis += 1
+        elif len(slices[i]) == 1 and slices[i][0] is None:  # Colon: Take all values from a single axis: array[???, :, ???]
+            axis += 1
+        else:  # Take all values from the range i to j on a single axis: array[???, i:j, ???]. i or j can also be None
+            slc[axis] = slice(slices[i][0], slices[i][1])
+            axis += 1
+    return tuple(slc)

acvl_utils-0.2/acvl_utils/cropping_and_padding/bounding_boxes.py

@@ -0,0 +1,102 @@
+import numpy as np
+from copy import deepcopy
+from typing import List, Tuple, Union
+
+
+def pad_bbox(bounding_box: Union[List[List[int]], Tuple[Tuple[int, int]]], pad_amount: Union[int, List[int]],
+             array_shape: Tuple[int, ...] = None) -> List[List[int]]:
+    """
+
+    """
+    if isinstance(bounding_box, tuple):
+        # convert to list
+        bounding_box = [list(i) for i in bounding_box]
+    else:
+        # needed because otherwise we overwrite input which could have unforseen consequences
+        bounding_box = deepcopy(bounding_box)
+
+    if isinstance(pad_amount, int):
+        pad_amount = [pad_amount] * len(bounding_box)
+
+    for i in range(len(bounding_box)):
+        new_values = [max(0, bounding_box[i][0] - pad_amount[i]), bounding_box[i][1] + pad_amount[i]]
+        if array_shape is not None:
+            new_values[1] = min(array_shape[i], new_values[1])
+        bounding_box[i] = new_values
+
+    return bounding_box
+
+
+def regionprops_bbox_to_proper_bbox(regionprops_bbox: Tuple[int, ...]) -> List[List[int]]:
+    """
+    regionprops_bbox is what you get from `from skimage.measure import regionprops`
+    """
+    dim = len(regionprops_bbox) // 2
+    return [[regionprops_bbox[i], regionprops_bbox[i + dim]] for i in range(dim)]
+
+
+def bounding_box_to_slice(bounding_box: List[List[int]]):
+    return tuple([slice(*i) for i in bounding_box])
+
+
+def crop_to_bbox(array: np.ndarray, bounding_box: List[List[int]]):
+    assert len(bounding_box) == len(array.shape), f"Dimensionality of bbox and array do not match. bbox has length " \
+                                          f"{len(bounding_box)} while array has dimension {len(array.shape)}"
+    slicer = bounding_box_to_slice(bounding_box)
+    return array[slicer]
+
+
+def get_bbox_from_mask(mask: np.ndarray) -> List[List[int]]:
+    """
+    this implementation uses less ram than the np.where one and is faster as well IF we expect the bounding box to
+    be close to the image size. If it's not it's likely slower!
+
+    :param mask:
+    :param outside_value:
+    :return:
+    """
+    Z, X, Y = mask.shape
+    minzidx, maxzidx, minxidx, maxxidx, minyidx, maxyidx = 0, Z, 0, X, 0, Y
+    zidx = list(range(Z))
+    for z in zidx:
+        if np.any(mask[z]):
+            minzidx = z
+            break
+    for z in zidx[::-1]:
+        if np.any(mask[z]):
+            maxzidx = z + 1
+            break
+
+    xidx = list(range(X))
+    for x in xidx:
+        if np.any(mask[:, x]):
+            minxidx = x
+            break
+    for x in xidx[::-1]:
+        if np.any(mask[:, x]):
+            maxxidx = x + 1
+            break
+
+    yidx = list(range(Y))
+    for y in yidx:
+        if np.any(mask[:, :, y]):
+            minyidx = y
+            break
+    for y in yidx[::-1]:
+        if np.any(mask[:, :, y]):
+            maxyidx = y + 1
+            break
+    return [[minzidx, maxzidx], [minxidx, maxxidx], [minyidx, maxyidx]]
+
+
+def get_bbox_from_mask_npwhere(mask: np.ndarray) -> List[List[int]]:
+    where = np.array(np.where(mask))
+    mins = np.min(where, 1)
+    maxs = np.max(where, 1) + 1
+    return [[i, j] for i, j in zip(mins, maxs)]
+
+
+if __name__ == '__main__':
+    bbox = [[32, 64], [21, 46]]
+    bbox_padded = pad_bbox(bbox, 3)
+    slicer = bounding_box_to_slice(bbox_padded)

acvl_utils-0.2/acvl_utils/cropping_and_padding/padding.py

@@ -0,0 +1,105 @@
+from typing import Union, List, Tuple
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+
+def pad_nd_image(image: Union[torch.Tensor, np.ndarray], new_shape: Tuple[int, ...] = None,
+                 mode: str = "constant", kwargs: dict = None, return_slicer: bool = False,
+                 shape_must_be_divisible_by: Union[int, Tuple[int, ...], List[int]] = None) -> \
+        Union[Union[torch.Tensor, np.ndarray], Tuple[Union[torch.Tensor, np.ndarray], Tuple]]:
+    """
+    One padder to pad them all. Documentation? Well okay. A little bit
+
+    Padding is done such that the original content will be at the center of the padded image. If the amount of padding
+    needed it odd, the padding 'above' the content is larger,
+    Example:
+    old shape: [ 3 34 55  3]
+    new_shape: [3, 34, 96, 64]
+    amount of padding (low, high for each axis): [[0, 0], [0, 0], [20, 21], [30, 31]]
+
+    :param image: can either be a numpy array or a torch.Tensor. pad_nd_image uses np.pad for the former and
+           torch.nn.functional.pad for the latter
+    :param new_shape: what shape do you want? new_shape does not have to have the same dimensionality as image. If
+           len(new_shape) < len(image.shape) then the last axes of image will be padded. If new_shape < image.shape in
+           any of the axes then we will not pad that axis, but also not crop! (interpret new_shape as new_min_shape)
+
+           Example:
+           image.shape = (10, 1, 512, 512); new_shape = (768, 768) -> result: (10, 1, 768, 768). Cool, huh?
+           image.shape = (10, 1, 512, 512); new_shape = (364, 768) -> result: (10, 1, 512, 768).
+
+    :param mode: will be passed to either np.pad or torch.nn.functional.pad depending on what the image is. Read the
+           respective documentation!
+    :param return_slicer: if True then this function will also return a tuple of python slice objects that you can use
+           to crop back to the original image (reverse padding)
+    :param shape_must_be_divisible_by: for network prediction. After applying new_shape, make sure the new shape is
+           divisibly by that number (can also be a list with an entry for each axis). Whatever is missing to match
+           that will be padded (so the result may be larger than new_shape if shape_must_be_divisible_by is not None)
+    :param kwargs: see np.pad for documentation (numpy) or torch.nn.functional.pad (torch)
+
+    :returns: if return_slicer=False, this function returns the padded numpy array / torch Tensor. If
+              return_slicer=True it will also return a tuple of slice objects that you can use to revert the padding:
+              output, slicer = pad_nd_image(input_array, new_shape=XXX, return_slicer=True)
+              reversed_padding = output[slicer] ## this is now the same as input_array, padding was reversed
+    """
+    if kwargs is None:
+        kwargs = {}
+
+    old_shape = np.array(image.shape)
+
+    if shape_must_be_divisible_by is not None:
+        assert isinstance(shape_must_be_divisible_by, (int, list, tuple, np.ndarray))
+        if isinstance(shape_must_be_divisible_by, int):
+            shape_must_be_divisible_by = [shape_must_be_divisible_by] * len(image.shape)
+        else:
+            if len(shape_must_be_divisible_by) < len(image.shape):
+                shape_must_be_divisible_by = [1] * (len(image.shape) - len(shape_must_be_divisible_by)) + \
+                                             list(shape_must_be_divisible_by)
+
+    if new_shape is None:
+        assert shape_must_be_divisible_by is not None
+        new_shape = image.shape
+
+    if len(new_shape) < len(image.shape):
+        new_shape = list(image.shape[:len(image.shape) - len(new_shape)]) + list(new_shape)
+
+    new_shape = [max(new_shape[i], old_shape[i]) for i in range(len(new_shape))]
+
+    if shape_must_be_divisible_by is not None:
+        if not isinstance(shape_must_be_divisible_by, (list, tuple, np.ndarray)):
+            shape_must_be_divisible_by = [shape_must_be_divisible_by] * len(new_shape)
+
+        if len(shape_must_be_divisible_by) < len(new_shape):
+            shape_must_be_divisible_by = [1] * (len(new_shape) - len(shape_must_be_divisible_by)) + \
+                                         list(shape_must_be_divisible_by)
+
+        for i in range(len(new_shape)):
+            if new_shape[i] % shape_must_be_divisible_by[i] == 0:
+                new_shape[i] -= shape_must_be_divisible_by[i]
+
+        new_shape = np.array([new_shape[i] + shape_must_be_divisible_by[i] - new_shape[i] %
+                              shape_must_be_divisible_by[i] for i in range(len(new_shape))])
+
+    difference = new_shape - old_shape
+    pad_below = difference // 2
+    pad_above = difference // 2 + difference % 2
+    pad_list = [list(i) for i in zip(pad_below, pad_above)]
+
+    if not ((all([i == 0 for i in pad_below])) and (all([i == 0 for i in pad_above]))):
+        if isinstance(image, np.ndarray):
+            res = np.pad(image, pad_list, mode, **kwargs)
+        elif isinstance(image, torch.Tensor):
+            # torch padding has the weirdest interface ever. Like wtf? Y u no read numpy documentation? So much easier
+            torch_pad_list = [i for j in pad_list for i in j[::-1]][::-1]
+            res = F.pad(image, torch_pad_list, mode, **kwargs)
+    else:
+        res = image
+
+    if not return_slicer:
+        return res
+    else:
+        pad_list = np.array(pad_list)
+        pad_list[:, 1] = np.array(res.shape) - pad_list[:, 1]
+        slicer = tuple(slice(*i) for i in pad_list)
+        return res, slicer