def __call__(self, data):
d = dict(data)
sp_size = fall_back_tuple(self.rand_2d_elastic.spatial_size,
data[self.keys[0]].shape[1:])
self.randomize(spatial_size=sp_size)
if self.rand_2d_elastic.do_transform:
grid = self.rand_2d_elastic.deform_grid(spatial_size=sp_size)
grid = self.rand_2d_elastic.rand_affine_grid(grid=grid)
grid = _torch_interp(
input=grid.unsqueeze(0),
scale_factor=list(self.rand_2d_elastic.deform_grid.spacing),
mode=InterpolateMode.BICUBIC.value,
align_corners=False,
)
grid = CenterSpatialCrop(roi_size=sp_size)(grid[0])
else:
grid = create_grid(spatial_size=sp_size)
for idx, key in enumerate(self.keys):
d[key] = self.rand_2d_elastic.resampler(
d[key],
grid,
mode=self.mode[idx],
padding_mode=self.padding_mode[idx])
return d
def __call__(
self, data: Mapping[Hashable, Union[np.ndarray, torch.Tensor]]
) -> Dict[Hashable, Union[np.ndarray, torch.Tensor]]:
d = dict(data)
sp_size = fall_back_tuple(self.rand_2d_elastic.spatial_size, data[self.keys[0]].shape[1:])
self.randomize(spatial_size=sp_size)
if self.rand_2d_elastic.do_transform:
grid = self.rand_2d_elastic.deform_grid(spatial_size=sp_size)
grid = self.rand_2d_elastic.rand_affine_grid(grid=grid)
grid = torch.nn.functional.interpolate( # type: ignore
recompute_scale_factor=True,
input=grid.unsqueeze(0),
scale_factor=ensure_tuple_rep(self.rand_2d_elastic.deform_grid.spacing, 2),
mode=InterpolateMode.BICUBIC.value,
align_corners=False,
)
grid = CenterSpatialCrop(roi_size=sp_size)(grid[0])
else:
grid = create_grid(spatial_size=sp_size)
for idx, key in enumerate(self.keys):
d[key] = self.rand_2d_elastic.resampler(
d[key], grid, mode=self.mode[idx], padding_mode=self.padding_mode[idx]
)
return d
def __call__(
self,
img: Union[np.ndarray, torch.Tensor],
spatial_size: Optional[Union[Tuple[int, int], int]] = None,
mode: Optional[Union[GridSampleMode, str]] = None,
padding_mode: Optional[Union[GridSamplePadMode, str]] = None,
) -> Union[np.ndarray, torch.Tensor]:
sp_size = fall_back_tuple(spatial_size or self.spatial_size,
img.shape[1:])
self.randomize()
if self.do_transform:
grid = self.deform_grid(spatial_size=sp_size)
grid = torch.nn.functional.interpolate(
input=grid.unsqueeze(0),
scale_factor=list(ensure_tuple(self.deform_grid.spacing)),
mode=InterpolateMode.BICUBIC.value,
align_corners=False,
)
grid = CenterSpatialCrop(roi_size=sp_size)(grid[0])
else:
grid = create_grid(spatial_size=sp_size)
return self.resampler(
img,
grid,
mode=mode or self.mode,
padding_mode=padding_mode or self.padding_mode,
)
def __call__(self, data):
d = dict(data)
self.randomize(d[self.keys[0]].shape[1:]) # image shape from the first data key
for key in self.keys:
if self.random_center:
d[key] = d[key][self._slices]
else:
cropper = CenterSpatialCrop(self._size)
d[key] = cropper(d[key])
return d
def __call__(self, data: Mapping[Hashable, np.ndarray]) -> Dict[Hashable, np.ndarray]:
d = dict(data)
self.randomize(d[self.keys[0]].shape[1:]) # image shape from the first data key
assert self._size is not None
for key in self.keys:
if self.random_center:
d[key] = d[key][self._slices]
else:
cropper = CenterSpatialCrop(self._size)
d[key] = cropper(d[key])
return d
def inverse(data: dict) -> Dict[Hashable, np.ndarray]:
if not isinstance(data, Mapping):
raise RuntimeError("Inverse can only currently be applied on dictionaries.")
d = dict(data)
for key in d:
transforms = None
if isinstance(d[key], MetaTensor):
transforms = d[key].applied_operations
else:
transform_key = InvertibleTransform.trace_key(key)
if transform_key in d:
transforms = d[transform_key]
if not transforms or not isinstance(transforms[-1], Dict):
continue
if transforms[-1].get(TraceKeys.CLASS_NAME) == PadListDataCollate.__name__:
xform = transforms.pop()
cropping = CenterSpatialCrop(xform.get(TraceKeys.ORIG_SIZE, -1))
with cropping.trace_transform(False):
d[key] = cropping(d[key]) # fallback to image size
return d
def inverse(data: dict) -> Dict[Hashable, np.ndarray]:
if not isinstance(data, dict):
raise RuntimeError("Inverse can only currently be applied on dictionaries.")
d = deepcopy(data)
for key in d.keys():
transform_key = str(key) + InverseKeys.KEY_SUFFIX
if transform_key in d.keys():
transform = d[transform_key][-1]
if transform[InverseKeys.CLASS_NAME] == PadListDataCollate.__name__:
d[key] = CenterSpatialCrop(transform["orig_size"])(d[key])
# remove transform
d[transform_key].pop()
return d
def __call__(self, data: Mapping[Hashable, np.ndarray]) -> Dict[Hashable, np.ndarray]:
d = dict(data)
self.randomize(d[self.keys[0]].shape[1:]) # image shape from the first data key
if self._size is None:
raise AssertionError
for key in self.key_iterator(d):
if self.random_center:
self.push_transform(d, key, {"slices": [(i.start, i.stop) for i in self._slices[1:]]}) # type: ignore
d[key] = d[key][self._slices]
else:
self.push_transform(d, key)
cropper = CenterSpatialCrop(self._size)
d[key] = cropper(d[key])
return d
def inverse(data: dict) -> Dict[Hashable, np.ndarray]:
if not isinstance(data, dict):
raise RuntimeError(
"Inverse can only currently be applied on dictionaries.")
d = deepcopy(data)
for key in d:
transform_key = InvertibleTransform.trace_key(key)
if transform_key in d:
transform = d[transform_key][-1]
if not isinstance(transform, Dict):
continue
if transform.get(
TraceKeys.CLASS_NAME) == PadListDataCollate.__name__:
d[key] = CenterSpatialCrop(transform.get("orig_size", -1))(
d[key]) # fallback to image size
# remove transform
d[transform_key].pop()
return d
def __init__(self,
keys: KeysCollection,
roi_size: Union[Sequence[int], int],
allow_missing_keys: bool = False) -> None:
super().__init__(keys, allow_missing_keys)
self.cropper = CenterSpatialCrop(roi_size)
def __init__(self, keys: KeysCollection, roi_size: Union[Sequence[int],
int]) -> None:
super().__init__(keys)
self.cropper = CenterSpatialCrop(roi_size)
def __init__(self, keys: KeysCollection, roi_size):
super().__init__(keys)
self.cropper = CenterSpatialCrop(roi_size)
def __init__(self, keys, roi_size):
super().__init__(keys)
self.cropper = CenterSpatialCrop(roi_size)
