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): d = dict(data) spatial_size = self.rand_3d_elastic.spatial_size if np.any([sz <= 1 for sz in spatial_size]): spatial_size = data[self.keys[0]].shape[1:] self.randomize(spatial_size) grid = create_grid(spatial_size) if self.rand_3d_elastic.do_transform: device = self.rand_3d_elastic.device grid = torch.tensor(grid).to(device) gaussian = GaussianFilter(spatial_dims=3, sigma=self.rand_3d_elastic.sigma, truncated=3.0).to(device) offset = torch.tensor(self.rand_3d_elastic.rand_offset[None], device=device) grid[:3] += gaussian(offset)[0] * self.rand_3d_elastic.magnitude grid = self.rand_3d_elastic.rand_affine_grid(grid=grid) for idx, key in enumerate(self.keys): d[key] = self.rand_3d_elastic.resampler( d[key], grid, padding_mode=self.padding_mode[idx], mode=self.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: Mapping[Hashable, Union[np.ndarray, torch.Tensor]] ) -> Dict[Hashable, Union[np.ndarray, torch.Tensor]]: d = dict(data) sp_size = fall_back_tuple(self.rand_3d_elastic.spatial_size, data[self.keys[0]].shape[1:]) self.randomize(grid_size=sp_size) grid = create_grid(spatial_size=sp_size) if self.rand_3d_elastic.do_transform: device = self.rand_3d_elastic.device grid = torch.tensor(grid).to(device) gaussian = GaussianFilter(spatial_dims=3, sigma=self.rand_3d_elastic.sigma, truncated=3.0).to(device) offset = torch.tensor(self.rand_3d_elastic.rand_offset, device=device).unsqueeze(0) grid[:3] += gaussian(offset)[0] * self.rand_3d_elastic.magnitude grid = self.rand_3d_elastic.rand_affine_grid(grid=grid) for idx, key in enumerate(self.keys): d[key] = self.rand_3d_elastic.resampler( d[key], grid, mode=self.mode[idx], padding_mode=self.padding_mode[idx]) return d
def __call__(self, data): d = dict(data) spatial_size = self.rand_3d_elastic.spatial_size self.randomize(spatial_size) grid = create_grid(spatial_size) if self.rand_3d_elastic.do_transform: device = self.rand_3d_elastic.device grid = torch.tensor(grid).to(device) gaussian = GaussianFilter(spatial_dims=3, sigma=self.rand_3d_elastic.sigma, truncated=3., device=device) grid[:3] += gaussian(self.rand_3d_elastic.rand_offset[None] )[0] * self.rand_3d_elastic.magnitude grid = self.rand_3d_elastic.rand_affine_grid(grid=grid) if isinstance(self.mode, (tuple, list)): for key, m in zip(self.keys, self.mode): d[key] = self.rand_3d_elastic.resampler(d[key], grid, mode=m) return d for key in self.keys: # same interpolation mode d[key] = self.rand_3d_elastic.resampler( d[key], grid, mode=self.rand_3d_elastic.mode) return d
def __call__(self, spatial_size=None, grid=None): """ Args: spatial_size (list or tuple of int): output grid size. grid (ndarray): grid to be transformed. Shape must be (3, H, W) for 2D or (4, H, W, D) for 3D. """ if grid is None: if spatial_size is not None: grid = create_grid(spatial_size) else: raise ValueError("Either specify a grid or a spatial size to create a grid from.") spatial_dims = len(grid.shape) - 1 affine = np.eye(spatial_dims + 1) if self.rotate_params: affine = affine @ create_rotate(spatial_dims, self.rotate_params) if self.shear_params: affine = affine @ create_shear(spatial_dims, self.shear_params) if self.translate_params: affine = affine @ create_translate(spatial_dims, self.translate_params) if self.scale_params: affine = affine @ create_scale(spatial_dims, self.scale_params) affine = torch.as_tensor(np.ascontiguousarray(affine), device=self.device) grid = torch.tensor(grid) if not torch.is_tensor(grid) else grid.detach().clone() if self.device: grid = grid.to(self.device) grid = (affine.float() @ grid.reshape((grid.shape[0], -1)).float()).reshape([-1] + list(grid.shape[1:])) if self.as_tensor_output: return grid return grid.cpu().numpy()
def __call__(self, data): d = dict(data) self.randomize() sp_size = fall_back_tuple(self.rand_affine.spatial_size, data[self.keys[0]].shape[1:]) if self.rand_affine.do_transform: grid = self.rand_affine.rand_affine_grid(spatial_size=sp_size) else: grid = create_grid(spatial_size=sp_size) for idx, key in enumerate(self.keys): d[key] = self.rand_affine.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) self.randomize() sp_size = fall_back_tuple(self.rand_affine.spatial_size, data[self.keys[0]].shape[1:]) if self.rand_affine.do_transform: grid = self.rand_affine.rand_affine_grid(spatial_size=sp_size) else: grid = create_grid(spatial_size=sp_size) for idx, key in enumerate(self.keys): d[key] = self.rand_affine.resampler(d[key], grid, mode=self.mode[idx], padding_mode=self.padding_mode[idx]) return d
def __call__(self, img, spatial_size=None, mode=None): """ Args: img (ndarray or tensor): shape must be (num_channels, H, W[, D]), spatial_size (list or tuple of int): output image spatial size. if `img` has two spatial dimensions, `spatial_size` should have 2 elements [h, w]. if `img` has three spatial dimensions, `spatial_size` should have 3 elements [h, w, d]. mode ('nearest'|'bilinear'): interpolation order. Defaults to 'bilinear'. """ self.randomize() spatial_size = spatial_size or self.spatial_size mode = mode or self.mode if self.do_transform: grid = self.rand_affine_grid(spatial_size=spatial_size) else: grid = create_grid(spatial_size) return self.resampler(img=img, grid=grid, mode=mode)
def __call__(self, data): d = dict(data) spatial_size = self.rand_2d_elastic.spatial_size self.randomize(spatial_size) if self.rand_2d_elastic.do_transform: grid = self.rand_2d_elastic.deform_grid(spatial_size) grid = self.rand_2d_elastic.rand_affine_grid(grid=grid) grid = torch.nn.functional.interpolate(grid[None], spatial_size, mode="bicubic", align_corners=False)[0] else: grid = create_grid(spatial_size) for idx, key in enumerate(self.keys): d[key] = self.rand_2d_elastic.resampler( d[key], grid, padding_mode=self.padding_mode[idx], mode=self.mode[idx] ) return d
def __call__(self, img, spatial_size=None, mode=None): """ Args: img (ndarray or tensor): shape must be (num_channels, H, W, D), spatial_size (3 ints): specifying spatial 3D output image spatial size [h, w, d]. mode ('nearest'|'bilinear'): interpolation order. Defaults to 'self.mode'. """ spatial_size = spatial_size or self.spatial_size mode = mode or self.mode self.randomize(spatial_size) grid = create_grid(spatial_size) if self.do_transform: grid = torch.as_tensor(np.ascontiguousarray(grid), device=self.device) gaussian = GaussianFilter(3, self.sigma, 3., device=self.device) grid[:3] += gaussian(self.rand_offset[None])[0] * self.magnitude grid = self.rand_affine_grid(grid=grid) return self.resampler(img, grid, mode)
def __call__(self, data): d = dict(data) self.randomize() spatial_size = self.rand_affine.spatial_size if self.rand_affine.do_transform: grid = self.rand_affine.rand_affine_grid(spatial_size=spatial_size) else: grid = create_grid(spatial_size) if isinstance(self.mode, (tuple, list)): for key, m in zip(self.keys, self.mode): d[key] = self.rand_affine.resampler(d[key], grid, mode=m) return d for key in self.keys: # same interpolation mode d[key] = self.rand_affine.resampler(d[key], grid, self.rand_affine.mode) return d
def __call__(self, img, spatial_size=None, padding_mode=None, mode=None): """ Args: img (ndarray or tensor): shape must be (num_channels, H, W), spatial_size (2 ints): specifying output image spatial size [h, w]. padding_mode ('zeros'|'border'|'reflection'): mode of handling out of range indices. Defaults to ``'zeros'``. mode ('nearest'|'bilinear'): interpolation order. Defaults to ``self.mode``. """ spatial_size = spatial_size or self.spatial_size self.randomize(spatial_size) if self.do_transform: grid = self.deform_grid(spatial_size=spatial_size) grid = self.rand_affine_grid(grid=grid) grid = torch.nn.functional.interpolate(grid[None], spatial_size, mode="bicubic", align_corners=False)[0] else: grid = create_grid(spatial_size) return self.resampler(img, grid, padding_mode=padding_mode or self.padding_mode, mode=mode or self.mode)
def __call__(self, data): d = dict(data) spatial_size = self.rand_2d_elastic.spatial_size self.randomize(spatial_size) if self.rand_2d_elastic.do_transform: grid = self.rand_2d_elastic.deform_grid(spatial_size) grid = self.rand_2d_elastic.rand_affine_grid(grid=grid) grid = torch.nn.functional.interpolate(grid[None], spatial_size, mode="bicubic", align_corners=False)[0] else: grid = create_grid(spatial_size) if isinstance(self.mode, (tuple, list)): for key, m in zip(self.keys, self.mode): d[key] = self.rand_2d_elastic.resampler(d[key], grid, mode=m) return d for key in self.keys: # same interpolation mode d[key] = self.rand_2d_elastic.resampler(d[key], grid, mode=self.rand_2d_elastic.mode) return d
def __call__(self, data): d = dict(data) spatial_size = self.rand_2d_elastic.spatial_size if np.any([sz <= 1 for sz in spatial_size]): spatial_size = data[self.keys[0]].shape[1:] self.randomize(spatial_size) if self.rand_2d_elastic.do_transform: grid = self.rand_2d_elastic.deform_grid(spatial_size) grid = self.rand_2d_elastic.rand_affine_grid(grid=grid) grid = _torch_interp(input=grid[None], size=spatial_size, mode="bicubic", align_corners=False)[0] else: grid = create_grid(spatial_size) for idx, key in enumerate(self.keys): d[key] = self.rand_2d_elastic.resampler( d[key], grid, padding_mode=self.padding_mode[idx], mode=self.mode[idx]) return d
# See the License for the specific language governing permissions and # limitations under the License. import unittest import numpy as np import torch from parameterized import parameterized from monai.transforms import Resample from monai.transforms.utils import create_grid TEST_CASES = [ [ dict(padding_mode="zeros", as_tensor_output=False, device=None), {"grid": create_grid((2, 2)), "img": np.arange(4).reshape((1, 2, 2))}, np.array([[[0.0, 1.0], [2.0, 3.0]]]), ], [ dict(padding_mode="zeros", as_tensor_output=False, device=None), {"grid": create_grid((4, 4)), "img": np.arange(4).reshape((1, 2, 2))}, np.array([[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 2.0, 3.0, 0.0], [0.0, 0.0, 0.0, 0.0]]]), ], [ dict(padding_mode="border", as_tensor_output=False, device=None), {"grid": create_grid((4, 4)), "img": np.arange(4).reshape((1, 2, 2))}, np.array([[[0.0, 0.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0], [2.0, 2.0, 3, 3.0], [2.0, 2.0, 3.0, 3.0]]]), ], [ dict(padding_mode="reflection", as_tensor_output=False, device=None), {"grid": create_grid((4, 4)), "img": np.arange(4).reshape((1, 2, 2)), "mode": "nearest"},
import numpy as np import torch from parameterized import parameterized from monai.transforms import Resample from monai.transforms.utils import create_grid from tests.utils import TEST_NDARRAYS, assert_allclose TESTS = [] for p in TEST_NDARRAYS: for q in TEST_NDARRAYS: for device in [None, "cpu", "cuda"] if torch.cuda.is_available() else [None, "cpu"]: TESTS.append( [ dict(padding_mode="zeros", device=device), {"grid": p(create_grid((2, 2))), "img": q(np.arange(4).reshape((1, 2, 2)))}, q(np.array([[[0.0, 1.0], [2.0, 3.0]]])), ] ) TESTS.append( [ dict(padding_mode="zeros", device=device), {"grid": p(create_grid((4, 4))), "img": q(np.arange(4).reshape((1, 2, 2)))}, q( np.array( [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 2.0, 3.0, 0.0], [0.0, 0.0, 0.0, 0.0]]] ) ), ] ) TESTS.append(
# See the License for the specific language governing permissions and # limitations under the License. import unittest import numpy as np import torch from parameterized import parameterized from monai.transforms import Resample from monai.transforms.utils import create_grid TEST_CASES = [ [ dict(padding_mode='zeros', as_tensor_output=False, device=None), { 'grid': create_grid((2, 2)), 'img': np.arange(4).reshape((1, 2, 2)) }, np.array([[[0., 0.25], [0.5, 0.75]]]) ], [ dict(padding_mode='zeros', as_tensor_output=False, device=None), { 'grid': create_grid((4, 4)), 'img': np.arange(4).reshape((1, 2, 2)) }, np.array([[[0., 0., 0., 0.], [0., 0., 0.25, 0.], [0., 0.5, 0.75, 0.], [0., 0., 0., 0.]]]) ], [ dict(padding_mode='border', as_tensor_output=False, device=None), { 'grid': create_grid((4, 4)),
# limitations under the License. import unittest import numpy as np import torch from parameterized import parameterized from monai.transforms import Resample from monai.transforms.utils import create_grid TEST_CASES = [ [ dict(padding_mode="zeros", as_tensor_output=False, device=None), { "grid": create_grid((2, 2)), "img": np.arange(4).reshape((1, 2, 2)) }, np.array([[[0.0, 0.25], [0.5, 0.75]]]), ], [ dict(padding_mode="zeros", as_tensor_output=False, device=None), { "grid": create_grid((4, 4)), "img": np.arange(4).reshape((1, 2, 2)) }, np.array([[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.25, 0.0], [0.0, 0.5, 0.75, 0.0], [0.0, 0.0, 0.0, 0.0]]]), ], [ dict(padding_mode="border", as_tensor_output=False, device=None),
def test_create_grid(self): with self.assertRaisesRegex(TypeError, ''): create_grid(None) with self.assertRaisesRegex(TypeError, ''): create_grid((1, 1), spacing=2.) with self.assertRaisesRegex(TypeError, ''): create_grid((1, 1), spacing=2.) g = create_grid((1, 1)) expected = np.array([[[0.]], [[0.]], [[1.]]]) np.testing.assert_allclose(g, expected) g = create_grid((1, 1), homogeneous=False) expected = np.array([[[0.]], [[0.]]]) np.testing.assert_allclose(g, expected) g = create_grid((1, 1), spacing=(1.2, 1.3)) expected = np.array([[[0.]], [[0.]], [[1.]]]) np.testing.assert_allclose(g, expected) g = create_grid((1, 1, 1), spacing=(1.2, 1.3, 1.0)) expected = np.array([[[[0.]]], [[[0.]]], [[[0.]]], [[[1.]]]]) np.testing.assert_allclose(g, expected) g = create_grid((1, 1, 1), spacing=(1.2, 1.3, 1.0), homogeneous=False) expected = np.array([[[[0.]]], [[[0.]]], [[[0.]]]]) np.testing.assert_allclose(g, expected) g = create_grid((1, 1, 1), spacing=(1.2, 1.3, 1.0), dtype=int) np.testing.assert_equal(g.dtype, np.int64) g = create_grid((2, 2, 2)) expected = np.array([[[[-0.5, -0.5], [-0.5, -0.5]], [[0.5, 0.5], [0.5, 0.5]]], [[[-0.5, -0.5], [0.5, 0.5]], [[-0.5, -0.5], [0.5, 0.5]]], [[[-0.5, 0.5], [-0.5, 0.5]], [[-0.5, 0.5], [-0.5, 0.5]]], [[[1., 1.], [1., 1.]], [[1., 1.], [1., 1.]]]]) np.testing.assert_allclose(g, expected) g = create_grid((2, 2, 2), spacing=(1.2, 1.3, 1.0)) expected = np.array([[[[-0.6, -0.6], [-0.6, -0.6]], [[0.6, 0.6], [0.6, 0.6]]], [[[-0.65, -0.65], [0.65, 0.65]], [[-0.65, -0.65], [0.65, 0.65]]], [[[-0.5, 0.5], [-0.5, 0.5]], [[-0.5, 0.5], [-0.5, 0.5]]], [[[1., 1.], [1., 1.]], [[1., 1.], [1., 1.]]]]) np.testing.assert_allclose(g, expected)