def create_shear(spatial_dims: int, coefs: Union[Sequence[float],
float]) -> np.ndarray:
"""
create a shearing matrix
Args:
spatial_dims: spatial rank
coefs: shearing factors, defaults to 0.
Raises:
NotImplementedError: When ``spatial_dims`` is not one of [2, 3].
"""
if spatial_dims == 2:
coefs = ensure_tuple_size(coefs, dim=2, pad_val=0.0)
return np.array([[1, coefs[0], 0.0], [coefs[1], 1.0, 0.0],
[0.0, 0.0, 1.0]])
if spatial_dims == 3:
coefs = ensure_tuple_size(coefs, dim=6, pad_val=0.0)
return np.array([
[1.0, coefs[0], coefs[1], 0.0],
[coefs[2], 1.0, coefs[3], 0.0],
[coefs[4], coefs[5], 1.0, 0.0],
[0.0, 0.0, 0.0, 1.0],
])
raise NotImplementedError(
"Currently only spatial_dims in [2, 3] are supported.")
def __call__(self, img: np.ndarray) -> np.ndarray:
self.randomize()
if not self._do_transform:
return img
sigma1 = ensure_tuple_size(tup=(self.x1, self.y1, self.z1), dim=img.ndim - 1)
sigma2 = ensure_tuple_size(tup=(self.x2, self.y2, self.z2), dim=img.ndim - 1)
return GaussianSharpen(sigma1=sigma1, sigma2=sigma2, alpha=self.a)(img)
def iter_patch_slices(
dims: Sequence[int],
patch_size: Union[Sequence[int], int],
start_pos: Sequence[int] = ()
) -> Generator[Tuple[slice, ...], None, None]:
"""
Yield successive tuples of slices defining patches of size `patch_size` from an array of dimensions `dims`. The
iteration starts from position `start_pos` in the array, or starting at the origin if this isn't provided. Each
patch is chosen in a contiguous grid using a first dimension as least significant ordering.
Args:
dims: dimensions of array to iterate over
patch_size: size of patches to generate slices for, 0 or None selects whole dimension
start_pos: starting position in the array, default is 0 for each dimension
Yields:
Tuples of slice objects defining each patch
"""
# ensure patchSize and startPos are the right length
ndim = len(dims)
patch_size_ = get_valid_patch_size(dims, patch_size)
start_pos = ensure_tuple_size(start_pos, ndim)
# collect the ranges to step over each dimension
ranges = tuple(starmap(range, zip(start_pos, dims, patch_size_)))
# choose patches by applying product to the ranges
for position in product(
*ranges[::-1]): # reverse ranges order to iterate in index order
yield tuple(
slice(s, s + p) for s, p in zip(position[::-1], patch_size_))
def one_hot(labels: torch.Tensor,
num_classes: int,
dtype: torch.dtype = torch.float,
dim: int = 1) -> torch.Tensor:
"""
For a tensor `labels` of dimensions B1[spatial_dims], return a tensor of dimensions `BN[spatial_dims]`
for `num_classes` N number of classes.
Example:
For every value v = labels[b,1,h,w], the value in the result at [b,v,h,w] will be 1 and all others 0.
Note that this will include the background label, thus a binary mask should be treated as having 2 classes.
"""
assert labels.dim() > 0, "labels should have dim of 1 or more."
# if `dim` is bigger, add singelton dim at the end
if labels.ndimension() < dim + 1:
shape = ensure_tuple_size(labels.shape, dim + 1, 1)
labels = labels.reshape(*shape)
sh = list(labels.shape)
assert sh[
dim] == 1, "labels should have a channel with length equals to one."
sh[dim] = num_classes
o = torch.zeros(size=sh, dtype=dtype, device=labels.device)
labels = o.scatter_(dim=dim, index=labels.long(), value=1)
return labels
def create_scale(spatial_dims: int,
scaling_factor: Union[Sequence[float], float]) -> np.ndarray:
"""
create a scaling matrix
Args:
spatial_dims: spatial rank
scaling_factor: scaling factors, defaults to 1.
"""
scaling_factor = ensure_tuple_size(scaling_factor,
dim=spatial_dims,
pad_val=1.0)
return np.diag(scaling_factor[:spatial_dims] + (1.0, ))
def get_valid_patch_size(
image_size: Sequence[int], patch_size: Union[Sequence[int],
int]) -> Tuple[int, ...]:
"""
Given an image of dimensions `image_size`, return a patch size tuple taking the dimension from `patch_size` if this is
not 0/None. Otherwise, or if `patch_size` is shorter than `image_size`, the dimension from `image_size` is taken. This ensures
the returned patch size is within the bounds of `image_size`. If `patch_size` is a single number this is interpreted as a
patch of the same dimensionality of `image_size` with that size in each dimension.
"""
ndim = len(image_size)
patch_size_ = ensure_tuple_size(patch_size, ndim)
# ensure patch size dimensions are not larger than image dimension, if a dimension is None or 0 use whole dimension
return tuple(min(ms, ps or ms) for ms, ps in zip(image_size, patch_size_))
def iter_patch(
arr: np.ndarray,
patch_size: Union[Sequence[int], int] = 0,
start_pos: Sequence[int] = (),
copy_back: bool = True,
mode: Union[NumpyPadMode, str] = NumpyPadMode.WRAP,
**pad_opts: Dict,
) -> Generator[np.ndarray, None, None]:
"""
Yield successive patches from `arr` of size `patch_size`. The iteration can start from position `start_pos` in `arr`
but drawing from a padded array extended by the `patch_size` in each dimension (so these coordinates can be negative
to start in the padded region). If `copy_back` is True the values from each patch are written back to `arr`.
Args:
arr: array to iterate over
patch_size: size of patches to generate slices for, 0 or None selects whole dimension
start_pos: starting position in the array, default is 0 for each dimension
copy_back: if True data from the yielded patches is copied back to `arr` once the generator completes
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 ``"wrap"``.
See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html
pad_opts: padding options, see `numpy.pad`
Yields:
Patches of array data from `arr` which are views into a padded array which can be modified, if `copy_back` is
True these changes will be reflected in `arr` once the iteration completes.
"""
# ensure patchSize and startPos are the right length
patch_size_ = get_valid_patch_size(arr.shape, patch_size)
start_pos = ensure_tuple_size(start_pos, arr.ndim)
# pad image by maximum values needed to ensure patches are taken from inside an image
arrpad = np.pad(arr, tuple((p, p) for p in patch_size_),
NumpyPadMode(mode).value, **pad_opts)
# choose a start position in the padded image
start_pos_padded = tuple(s + p for s, p in zip(start_pos, patch_size_))
# choose a size to iterate over which is smaller than the actual padded image to prevent producing
# patches which are only in the padded regions
iter_size = tuple(s + p for s, p in zip(arr.shape, patch_size_))
for slices in iter_patch_slices(iter_size, patch_size_, start_pos_padded):
yield arrpad[slices]
# copy back data from the padded image if required
if copy_back:
slices = tuple(slice(p, p + s) for p, s in zip(patch_size_, arr.shape))
arr[...] = arrpad[slices]
def dense_patch_slices(
image_size: Sequence[int],
patch_size: Sequence[int],
scan_interval: Sequence[int],
) -> List[Tuple[slice, ...]]:
"""
Enumerate all slices defining 2D/3D patches of size `patch_size` from an `image_size` input image.
Args:
image_size: dimensions of image to iterate over
patch_size: size of patches to generate slices
scan_interval: dense patch sampling interval
Raises:
ValueError: When ``image_size`` length is not one of [2, 3].
Returns:
a list of slice objects defining each patch
"""
num_spatial_dims = len(image_size)
if num_spatial_dims not in (2, 3):
raise ValueError(
f"Unsupported image_size length: {len(image_size)}, available options are [2, 3]"
)
patch_size = get_valid_patch_size(image_size, patch_size)
scan_interval = ensure_tuple_size(scan_interval, num_spatial_dims)
scan_num = list()
for i in range(num_spatial_dims):
if scan_interval[i] == 0:
scan_num.append(1)
else:
num = int(math.ceil(float(image_size[i]) / scan_interval[i]))
scan_dim = first(
d for d in range(num)
if d * scan_interval[i] + patch_size[i] >= image_size[i])
scan_num.append(scan_dim + 1)
slices: List[Tuple[slice, ...]] = []
if num_spatial_dims == 3:
for i in range(scan_num[0]):
start_i = i * scan_interval[0]
start_i -= max(start_i + patch_size[0] - image_size[0], 0)
slice_i = slice(start_i, start_i + patch_size[0])
for j in range(scan_num[1]):
start_j = j * scan_interval[1]
start_j -= max(start_j + patch_size[1] - image_size[1], 0)
slice_j = slice(start_j, start_j + patch_size[1])
for k in range(0, scan_num[2]):
start_k = k * scan_interval[2]
start_k -= max(start_k + patch_size[2] - image_size[2], 0)
slice_k = slice(start_k, start_k + patch_size[2])
slices.append((slice_i, slice_j, slice_k))
else:
for i in range(scan_num[0]):
start_i = i * scan_interval[0]
start_i -= max(start_i + patch_size[0] - image_size[0], 0)
slice_i = slice(start_i, start_i + patch_size[0])
for j in range(scan_num[1]):
start_j = j * scan_interval[1]
start_j -= max(start_j + patch_size[1] - image_size[1], 0)
slice_j = slice(start_j, start_j + patch_size[1])
slices.append((slice_i, slice_j))
return slices
def __call__(self, img: np.ndarray) -> np.ndarray:
self.randomize()
if not self._do_transform:
return img
sigma = ensure_tuple_size(tup=(self.x, self.y, self.z), dim=img.ndim - 1)
return GaussianSmooth(sigma=sigma)(img)