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)
