From 16a781b9829f26169e2395cf9351960802ed08e4 Mon Sep 17 00:00:00 2001 From: Wenqi Li Date: Sat, 6 Jun 2020 19:09:41 +0100 Subject: [PATCH 1/5] revises rotate/rand_rotate --- monai/data/utils.py | 2 +- monai/transforms/spatial/array.py | 197 ++++++++++++++----------- monai/transforms/spatial/dictionary.py | 141 +++++++++--------- tests/test_compose.py | 2 +- tests/test_rand_rotate.py | 68 ++++++--- tests/test_rand_rotated.py | 72 ++++++--- tests/test_rotate.py | 91 ++++++++++-- tests/test_rotated.py | 113 +++++++++++--- tests/utils.py | 26 +++- 9 files changed, 468 insertions(+), 244 deletions(-) diff --git a/monai/data/utils.py b/monai/data/utils.py index ea35f2bbbb0..cc956656a08 100644 --- a/monai/data/utils.py +++ b/monai/data/utils.py @@ -351,7 +351,7 @@ def compute_shape_offset(spatial_shape, in_affine, out_affine): corners = in_affine @ corners corners_out = np.linalg.inv(out_affine) @ corners corners_out = corners_out[:-1] / corners_out[-1] - out_shape = np.round(np.max(corners_out, 1) - np.min(corners_out, 1) + 1.0) + out_shape = np.round(corners_out.ptp(axis=1) + 1.0) if np.allclose(nib.io_orientation(in_affine), nib.io_orientation(out_affine)): # same orientation, get translate from the origin offset = in_affine @ ([0] * sr + [1]) diff --git a/monai/transforms/spatial/array.py b/monai/transforms/spatial/array.py index 55c95d72772..af6e98b205d 100644 --- a/monai/transforms/spatial/array.py +++ b/monai/transforms/spatial/array.py @@ -18,7 +18,6 @@ import nibabel as nib import numpy as np -import scipy.ndimage import torch from monai.config import get_torch_version_tuple @@ -286,68 +285,77 @@ def __call__( # type: ignore # see issue #495 class Rotate(Transform): """ - Rotates an input image by given angle. Uses scipy.ndimage.rotate. For more details, see - https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.rotate.html + Rotates an input image by given angle using :py:class:`monai.networks.layers.AffineTransform`. Args: - angle: Rotation angle in degrees. - spatial_axes (tuple of 2 ints): Spatial axes of rotation. Default: (0, 1). - This is the first two axis in spatial dimensions. - reshape: If reshape is true, the output shape is adapted so that the + angle (float or sequence of float): Rotation angle(s) in degrees. + should a float for 2D, three floats for 3D. + keep_size (bool): If it is True, the output shape is kept the same as the input. + If it is False, the output shape is adapted so that the input array is contained completely in the output. Default is True. - interp_order: Order of spline interpolation. Range 0-5. Default: InterpolationCode.LINEAR. This is - different from scipy where default interpolation is InterpolationCode.SPLINE3. - mode (str): Points outside boundary filled according to this mode. Options are - 'constant', 'nearest', 'reflect', 'wrap'. Default: 'constant'. - cval: Values to fill outside boundary. Default: 0. - prefilter: Apply spline_filter before interpolation. Default: True. + interp_order (`nearest|bilinear`): interpolation mode, defaults to "bilinear" + Available options are 'nearest', 'bilinear'. + See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample. + mode (`zeros|border|reflection`): Points outside boundary filled according to this mode. + Available options are 'zeros', 'border', 'reflection'. Defaults to "border". + align_corners (bool): Defaults to False. + See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate """ def __init__( self, - angle: float, - spatial_axes=(0, 1), - reshape: bool = True, - interp_order=1, - mode: str = "constant", - cval: float = 0.0, - prefilter: bool = True, + angle, + keep_size: bool = True, + interp_order: str = "bilinear", + mode: str = "border", + align_corners: bool = False, ): self.angle = angle - self.spatial_axes = spatial_axes - self.reshape = reshape + self.keep_size = keep_size self.interp_order = interp_order self.mode = mode - self.cval = cval - self.prefilter = prefilter + self.align_corners = align_corners def __call__( # type: ignore # see issue #495 - self, - img, - order=None, - mode: Optional[str] = None, - cval: Optional[float] = None, - prefilter: Optional[bool] = None, + self, img, interp_order: Optional[str] = None, mode: Optional[str] = None, ): """ Args: img (ndarray): channel first array, must have shape: (num_channels, H[, W, ..., ]), """ - rotated = list() - for channel in img: - rotated.append( - scipy.ndimage.rotate( - input=channel, - angle=self.angle, - axes=self.spatial_axes, - reshape=self.reshape, - order=self.interp_order if order is None else order, - mode=mode or self.mode, - cval=self.cval if cval is None else cval, - prefilter=self.prefilter if prefilter is None else prefilter, - ) + im_shape = np.asarray(img.shape[1:]) # spatial dimensions + input_ndim = len(im_shape) + if input_ndim not in (2, 3): + raise ValueError("Rotate only supports 2D and 3D: [chns, H, W] and [chns, H, W, D].") + _angle = ensure_tuple_rep(self.angle, 1 if input_ndim == 2 else 3) + _rad = np.deg2rad(_angle) + transform = create_rotate(input_ndim, _rad) + shift = create_translate(input_ndim, (im_shape - 1) / 2) + if self.keep_size: + output_shape = im_shape + else: + corners = np.asarray(np.meshgrid(*[(0, dim) for dim in im_shape], indexing="ij")).reshape( + (len(im_shape), -1) ) - return np.stack(rotated).astype(img.dtype) + corners = transform[:-1, :-1] @ corners + output_shape = (corners.ptp(axis=1) + 0.5).astype(int) + shift_1 = create_translate(input_ndim, -(output_shape - 1) / 2) + transform = shift @ transform @ shift_1 + _dtype = img.dtype + xform = AffineTransform( + normalized=False, + mode=interp_order or self.interp_order, + padding_mode=mode or self.mode, + align_corners=self.align_corners, + reverse_indexing=True, + ) + output = xform( + torch.from_numpy(img.astype(np.float64)[None]), + torch.from_numpy(transform.astype(np.float64)), + spatial_size=output_shape, + ) + output = output.squeeze(0).detach().cpu().numpy().astype(_dtype) + return output class Zoom(Transform): @@ -472,75 +480,86 @@ def __call__(self, img): class RandRotate(Randomizable, Transform): - """Randomly rotates the input arrays. + """ + Randomly rotate the input arrays. Args: - degrees (tuple of float or float): Range of rotation in degrees. If single number, - angle is picked from (-degrees, degrees). - prob: Probability of rotation. - spatial_axes (tuple of 2 ints): Spatial axes of rotation. Default: (0, 1). - This is the first two axis in spatial dimensions. - reshape: If reshape is true, the output shape is adapted so that the - input array is contained completely in the output. Default is True. - interp_order: Order of spline interpolation. Range 0-5. Default: InterpolationCode.LINEAR. This is - different from scipy where default interpolation is InterpolationCode.SPLINE3. - mode (str): Points outside boundary filled according to this mode. Options are - 'constant', 'nearest', 'reflect', 'wrap'. Default: 'constant'. - cval: Value to fill outside boundary. Default: 0. - prefilter: Apply spline_filter before interpolation. Default: True. + range_x (tuple of float or float): Range of rotation angle in degrees in the + plane defined by the first and second axes. + If single number, angle is uniformly sampled from (-range_x, range_x). + range_y (tuple of float or float): Range of rotation angle in degrees in the + plane defined by the first and third axes. + If single number, angle is uniformly sampled from (-range_y, range_y). + range_z (tuple of float or float): Range of rotation angle in degrees in the + plane defined by the second and third axes. + If single number, angle is uniformly sampled from (-range_z, range_z). + prob (float): Probability of rotation. + keep_size (bool): If it is False, the output shape is adapted so that the + input array is contained completely in the output. + If it is True, the output shape is the same as the input. Default is True. + interp_order (`nearest|bilinear`): interpolation mode, defaults to "bilinear" + Available options are 'nearest', 'bilinear'. + See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample. + mode (`zeros|border|reflection`): Points outside boundary filled according to this mode. + Available options are 'zeros', 'border', 'reflection'. Defaults to "border". + align_corners (bool): Defaults to False. + See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate """ def __init__( self, - degrees, + range_x=0.0, + range_y=0.0, + range_z=0.0, prob: float = 0.1, - spatial_axes=(0, 1), - reshape: bool = True, - interp_order=InterpolationCode.LINEAR, - mode: str = "constant", - cval: float = 0.0, - prefilter: bool = True, + keep_size: bool = True, + interp_order: str = "bilinear", + mode: str = "border", + align_corners: bool = False, ): - self.degrees = degrees + self.range_x = ensure_tuple(range_x) + if len(self.range_x) == 1: + self.range_x = sorted((-self.range_x[0], self.range_x[0])) + self.range_y = ensure_tuple(range_y) + if len(self.range_y) == 1: + self.range_y = sorted((-self.range_y[0], self.range_y[0])) + self.range_z = ensure_tuple(range_z) + if len(self.range_z) == 1: + self.range_z = sorted((-self.range_z[0], self.range_z[0])) + self.prob = prob - self.spatial_axes = spatial_axes - self.reshape = reshape + self.keep_size = keep_size self.interp_order = interp_order self.mode = mode - self.cval = cval - self.prefilter = prefilter - - if not hasattr(self.degrees, "__iter__"): - self.degrees = (-self.degrees, self.degrees) - assert len(self.degrees) == 2, "degrees should be a number or pair of numbers." + self.align_corners = align_corners self._do_transform = False - self.angle = None + self.x = 0.0 + self.y = 0.0 + self.z = 0.0 def randomize(self): self._do_transform = self.R.random_sample() < self.prob - self.angle = self.R.uniform(low=self.degrees[0], high=self.degrees[1]) + self.x = self.R.uniform(low=self.range_x[0], high=self.range_x[1]) + self.y = self.R.uniform(low=self.range_y[0], high=self.range_y[1]) + self.z = self.R.uniform(low=self.range_z[0], high=self.range_z[1]) def __call__( # type: ignore # see issue #495 - self, - img, - order=None, - mode: Optional[str] = None, - cval: Optional[float] = None, - prefilter: Optional[bool] = None, + self, img, interp_order: Optional[str] = None, mode: Optional[str] = None, ): + """ + Args: + img (ndarray): channel first array, must have shape 2D: (nchannels, H, W), or 3D: (nchannels, H, W, D). + """ self.randomize() - assert self.angle is not None if not self._do_transform: return img rotator = Rotate( - angle=self.angle, - spatial_axes=self.spatial_axes, - reshape=self.reshape, - interp_order=self.interp_order if order is None else order, + angle=self.x if img.ndim == 3 else (self.x, self.y, self.z), + keep_size=self.keep_size, + interp_order=interp_order or self.interp_order, mode=mode or self.mode, - cval=self.cval if cval is None else cval, - prefilter=self.prefilter if prefilter is None else prefilter, + align_corners=self.align_corners, ) return rotator(img) diff --git a/monai/transforms/spatial/dictionary.py b/monai/transforms/spatial/dictionary.py index 5df288cb5a5..60ed6d695fd 100644 --- a/monai/transforms/spatial/dictionary.py +++ b/monai/transforms/spatial/dictionary.py @@ -39,7 +39,7 @@ _torch_interp, ) from monai.transforms.utils import create_grid -from monai.utils.misc import ensure_tuple_rep +from monai.utils.misc import ensure_tuple, ensure_tuple_rep class Spacingd(MapTransform): @@ -585,49 +585,38 @@ class Rotated(MapTransform): Args: keys (dict): Keys to pick data for transformation. - angle: Rotation angle in degrees. - spatial_axes (tuple of 2 ints): Spatial axes of rotation. Default: (0, 1). - This is the first two axis in spatial dimensions. - reshape: If reshape is true, the output shape is adapted so that the - input array is contained completely in the output. Default is True. - interp_order (int or sequence of int): Order of spline interpolation. Range 0-5. - Default: InterpolationCode.LINEAR. This is different from scipy where default interpolation - is InterpolationCode.SPLINE3. - mode (str or sequence of str): Points outside boundary filled according to this mode. Options are - 'constant', 'nearest', 'reflect', 'wrap'. Default: 'constant'. - cval (scalar or sequence of scalar): Values to fill outside boundary. Default: 0. - prefilter (bool or sequence of bool): Apply spline_filter before interpolation. Default: True. + angle (float or sequence of float): Rotation angle(s) in degrees. + keep_size (bool): If it is False, the output shape is adapted so that the + input array is contained completely in the output. + If it is True, the output shape is the same as the input. Default is True. + interp_order (str or sequence of str): interpolation mode, defaults to "bilinear". + Available options are 'nearest', 'bilinear'. + See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample. + mode (str or sequence of str): Points outside boundary filled according to this mode. + Available options are 'zeros', 'border', 'reflection'. Defaults to "border". + align_corners (bool): Defaults to False. + See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate """ def __init__( self, keys: KeysCollection, - angle: float, - spatial_axes=(0, 1), - reshape: bool = True, - interp_order=InterpolationCode.LINEAR, - mode="constant", - cval=0, - prefilter=True, + angle, + keep_size: bool = True, + interp_order: str = "bilinear", + mode: str = "border", + align_corners: bool = False, ): super().__init__(keys) - self.rotator = Rotate(angle=angle, spatial_axes=spatial_axes, reshape=reshape) + self.rotator = Rotate(angle=angle, keep_size=keep_size, align_corners=align_corners) self.interp_order = ensure_tuple_rep(interp_order, len(self.keys)) self.mode = ensure_tuple_rep(mode, len(self.keys)) - self.cval = ensure_tuple_rep(cval, len(self.keys)) - self.prefilter = ensure_tuple_rep(prefilter, len(self.keys)) def __call__(self, data): d = dict(data) for idx, key in enumerate(self.keys): - d[key] = self.rotator( - d[key], - order=self.interp_order[idx], - mode=self.mode[idx], - cval=self.cval[idx], - prefilter=self.prefilter[idx], - ) + d[key] = self.rotator(d[key], interp_order=self.interp_order[idx], mode=self.mode[idx]) return d @@ -636,70 +625,80 @@ class RandRotated(Randomizable, MapTransform): Randomly rotates the input arrays. Args: - prob: Probability of rotation. - degrees (tuple of float or float): Range of rotation in degrees. If single number, - angle is picked from (-degrees, degrees). - spatial_axes (tuple of 2 ints): Spatial axes of rotation. Default: (0, 1). - This is the first two axis in spatial dimensions. - reshape: If reshape is true, the output shape is adapted so that the - input array is contained completely in the output. Default is True. - interp_order (int or sequence of int): Order of spline interpolation. Range 0-5. - Default: InterpolationCode.LINEAR. This is different from scipy where default - interpolation is InterpolationCode.SPLINE3. - mode (str or sequence of str): Points outside boundary filled according to this mode. Options are - 'constant', 'nearest', 'reflect', 'wrap'. Default: 'constant'. - cval (scalar or sequence of scalar): Value to fill outside boundary. Default: 0. - prefilter (bool or sequence of bool): Apply spline_filter before interpolation. Default: True. + range_x (tuple of float or float): Range of rotation angle in degrees in the + plane defined by the first and second axes. + If single number, angle is uniformly sampled from (-range_x, range_x). + range_y (tuple of float or float): Range of rotation angle in degrees in the + plane defined by the first and third axes. + If single number, angle is uniformly sampled from (-range_y, range_y). + range_z (tuple of float or float): Range of rotation angle in degrees in the + plane defined by the second and third axes. + If single number, angle is uniformly sampled from (-range_z, range_z). + prob (float): Probability of rotation. + keep_size (bool): If it is False, the output shape is adapted so that the + input array is contained completely in the output. + If it is True, the output shape is the same as the input. Default is True. + interp_order (str or sequence of str): interpolation mode, defaults to "bilinear" + Available options are 'nearest', 'bilinear'. + See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample. + mode (str or sequence of str): Points outside boundary filled according to this mode. + Available options are 'zeros', 'border', 'reflection'. Defaults to "border". + align_corners (bool): Defaults to False. + See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate """ def __init__( self, keys: KeysCollection, - degrees, + range_x=0.0, + range_y=0.0, + range_z=0.0, prob: float = 0.1, - spatial_axes=(0, 1), - reshape: bool = True, - interp_order=InterpolationCode.LINEAR, - mode="constant", - cval=0, - prefilter=True, + keep_size: bool = True, + interp_order: str = "bilinear", + mode: str = "border", + align_corners: bool = False, ): super().__init__(keys) - self.prob = prob - self.degrees = degrees - self.reshape = reshape - self.spatial_axes = spatial_axes + self.range_x = ensure_tuple(range_x) + if len(self.range_x) == 1: + self.range_x = sorted((-self.range_x[0], self.range_x[0])) + self.range_y = ensure_tuple(range_y) + if len(self.range_y) == 1: + self.range_y = sorted((-self.range_y[0], self.range_y[0])) + self.range_z = ensure_tuple(range_z) + if len(self.range_z) == 1: + self.range_z = sorted((-self.range_z[0], self.range_z[0])) + self.prob = prob + self.keep_size = keep_size self.interp_order = ensure_tuple_rep(interp_order, len(self.keys)) self.mode = ensure_tuple_rep(mode, len(self.keys)) - self.cval = ensure_tuple_rep(cval, len(self.keys)) - self.prefilter = ensure_tuple_rep(prefilter, len(self.keys)) - - if not hasattr(self.degrees, "__iter__"): - self.degrees = (-self.degrees, self.degrees) - assert len(self.degrees) == 2, "degrees should be a number or pair of numbers." + self.align_corners = align_corners self._do_transform = False - self.angle = None + self.x = 0.0 + self.y = 0.0 + self.z = 0.0 def randomize(self): self._do_transform = self.R.random_sample() < self.prob - self.angle = self.R.uniform(low=self.degrees[0], high=self.degrees[1]) + self.x = self.R.uniform(low=self.range_x[0], high=self.range_x[1]) + self.y = self.R.uniform(low=self.range_y[0], high=self.range_y[1]) + self.z = self.R.uniform(low=self.range_z[0], high=self.range_z[1]) def __call__(self, data): self.randomize() d = dict(data) if not self._do_transform: return d - rotator = Rotate(angle=self.angle, spatial_axes=self.spatial_axes, reshape=self.reshape) + rotator = Rotate( + angle=self.x if d[self.keys[0]].ndim == 3 else (self.x, self.y, self.z), + keep_size=self.keep_size, + align_corners=self.align_corners, + ) for idx, key in enumerate(self.keys): - d[key] = rotator( - d[key], - order=self.interp_order[idx], - mode=self.mode[idx], - cval=self.cval[idx], - prefilter=self.prefilter[idx], - ) + d[key] = rotator(d[key], interp_order=self.interp_order[idx], mode=self.mode[idx]) return d diff --git a/tests/test_compose.py b/tests/test_compose.py index d31921e78e4..8413ac2cb0a 100644 --- a/tests/test_compose.py +++ b/tests/test_compose.py @@ -96,7 +96,7 @@ def randomize(self, foo): def test_err_msg(self): transforms = Compose([abs, AddChannel(), round]) - with self.assertRaisesRegexp(Exception, "AddChannel"): + with self.assertRaisesRegex(Exception, "AddChannel"): transforms(42.1) diff --git a/tests/test_rand_rotate.py b/tests/test_rand_rotate.py index 3c18724f126..309de65087a 100644 --- a/tests/test_rand_rotate.py +++ b/tests/test_rand_rotate.py @@ -10,47 +10,69 @@ # limitations under the License. import unittest -import numpy as np +import numpy as np import scipy.ndimage from parameterized import parameterized +from tests.utils import NumpyImageTestCase2D, NumpyImageTestCase3D from monai.transforms import RandRotate -from tests.utils import NumpyImageTestCase2D -class TestRandRotate(NumpyImageTestCase2D): +class TestRandRotate2D(NumpyImageTestCase2D): @parameterized.expand( [ - (90, (0, 1), True, 1, "reflect", 0, True), - ((-45, 45), (1, 0), True, 3, "constant", 0, True), - (180, (1, 0), False, 2, "constant", 4, False), + (90, True, "bilinear", "border", False), + (45, True, "nearest", "border", False), + (180, False, "nearest", "zeros", True), + ((-45, 0), False, "nearest", "zeros", True), ] ) - def test_correct_results(self, degrees, spatial_axes, reshape, order, mode, cval, prefilter): + def test_correct_results(self, degrees, keep_size, order, mode, align_corners): rotate_fn = RandRotate( - degrees, + range_x=degrees, prob=1.0, keep_size=keep_size, interp_order=order, mode=mode, align_corners=align_corners, + ) + rotate_fn.set_random_state(243) + rotated = rotate_fn(self.imt[0]) + + _order = 0 if order == "nearest" else 1 + if mode == "border": + _mode = "nearest" + elif mode == "reflection": + _mode = "reflect" + else: + _mode = "constant" + angle = rotate_fn.x + expected = scipy.ndimage.rotate( + self.imt[0, 0], -angle, (0, 1), not keep_size, order=_order, mode=_mode, prefilter=False + ) + expected = np.stack(expected).astype(np.float32) + np.testing.assert_allclose(expected, rotated[0]) + + +class TestRandRotate3D(NumpyImageTestCase3D): + @parameterized.expand( + [ + (90, -30, (0.0, 180), False, "bilinear", "border", False, (1, 87, 104, 109)), + (45, (-20, 40), (20, 30), False, "nearest", "border", True, (1, 89, 105, 104)), + (0.0, (360, 370), (-1, 1), True, "nearest", "zeros", True, (1, 48, 64, 80)), + ((-45, 0), 0, 0, False, "nearest", "zeros", False, (1, 48, 77, 90)), + ] + ) + def test_correct_results(self, x, y, z, keep_size, order, mode, align_corners, expected): + rotate_fn = RandRotate( + range_x=x, + range_y=y, + range_z=z, prob=1.0, - spatial_axes=spatial_axes, - reshape=reshape, + keep_size=keep_size, interp_order=order, mode=mode, - cval=cval, - prefilter=prefilter, + align_corners=align_corners, ) rotate_fn.set_random_state(243) rotated = rotate_fn(self.imt[0]) - - angle = rotate_fn.angle - expected = list() - for channel in self.imt[0]: - expected.append( - scipy.ndimage.rotate( - channel, angle, spatial_axes, reshape, order=order, mode=mode, cval=cval, prefilter=prefilter - ) - ) - expected = np.stack(expected).astype(np.float32) - self.assertTrue(np.allclose(expected, rotated)) + np.testing.assert_allclose(rotated.shape, expected) if __name__ == "__main__": diff --git a/tests/test_rand_rotated.py b/tests/test_rand_rotated.py index 3ebd2808850..c982d7d89cf 100644 --- a/tests/test_rand_rotated.py +++ b/tests/test_rand_rotated.py @@ -16,42 +16,70 @@ from parameterized import parameterized from monai.transforms import RandRotated -from tests.utils import NumpyImageTestCase2D +from tests.utils import NumpyImageTestCase2D, NumpyImageTestCase3D -class TestRandRotated(NumpyImageTestCase2D): +class TestRandRotated2D(NumpyImageTestCase2D): @parameterized.expand( [ - (90, (0, 1), True, 1, "reflect", 0, True), - ((-45, 45), (1, 0), True, 3, "constant", 0, True), - (180, (1, 0), False, 2, "constant", 4, False), + (90, True, "bilinear", "border", False), + (45, True, "nearest", "border", False), + (180, False, "nearest", "zeros", True), + ((-45, 0), False, "nearest", "zeros", True), ] ) - def test_correct_results(self, degrees, spatial_axes, reshape, order, mode, cval, prefilter): + def test_correct_results(self, degrees, keep_size, order, mode, align_corners): rotate_fn = RandRotated( "img", - degrees, + range_x=degrees, prob=1.0, - spatial_axes=spatial_axes, - reshape=reshape, + keep_size=keep_size, interp_order=order, mode=mode, - cval=cval, - prefilter=prefilter, + align_corners=align_corners, ) rotate_fn.set_random_state(243) - rotated = rotate_fn({"img": self.imt[0]}) - - angle = rotate_fn.angle - expected = list() - for channel in self.imt[0]: - expected.append( - scipy.ndimage.rotate( - channel, angle, spatial_axes, reshape, order=order, mode=mode, cval=cval, prefilter=prefilter - ) - ) + rotated = rotate_fn({"img": self.imt[0], "seg": self.segn[0]}) + + _order = 0 if order == "nearest" else 1 + if mode == "border": + _mode = "nearest" + elif mode == "reflection": + _mode = "reflect" + else: + _mode = "constant" + angle = rotate_fn.x + expected = scipy.ndimage.rotate( + self.imt[0, 0], -angle, (0, 1), not keep_size, order=_order, mode=_mode, prefilter=False + ) expected = np.stack(expected).astype(np.float32) - self.assertTrue(np.allclose(expected, rotated["img"])) + self.assertTrue(np.allclose(expected, rotated["img"][0])) + + +class TestRandRotated3D(NumpyImageTestCase3D): + @parameterized.expand( + [ + (90, -30, (0.0, 180), False, "bilinear", "border", False, (1, 87, 104, 109)), + (45, (-20, 40), (20, 30), False, "nearest", "border", True, (1, 89, 105, 104)), + (0.0, (360, 370), (-1, 1), True, "nearest", "zeros", True, (1, 48, 64, 80)), + ((-45, 0), 0, 0, False, "nearest", "zeros", False, (1, 48, 77, 90)), + ] + ) + def test_correct_shapes(self, x, y, z, keep_size, order, mode, align_corners, expected): + rotate_fn = RandRotated( + "img", + range_x=x, + range_y=y, + range_z=z, + prob=1.0, + keep_size=keep_size, + interp_order=order, + mode=mode, + align_corners=align_corners, + ) + rotate_fn.set_random_state(243) + rotated = rotate_fn({"img": self.imt[0], "seg": self.segn[0]}) + np.testing.assert_allclose(rotated["img"].shape, expected) if __name__ == "__main__": diff --git a/tests/test_rotate.py b/tests/test_rotate.py index e16c484f969..494f08ea697 100644 --- a/tests/test_rotate.py +++ b/tests/test_rotate.py @@ -10,35 +10,98 @@ # limitations under the License. import unittest -import numpy as np +import numpy as np import scipy.ndimage from parameterized import parameterized +from tests.utils import NumpyImageTestCase2D, NumpyImageTestCase3D from monai.transforms import Rotate -from tests.utils import NumpyImageTestCase2D -TEST_CASES = [ - (90, (0, 1), True, 1, "reflect", 0, True), - (-90, (1, 0), True, 3, "constant", 0, True), - (180, (1, 0), False, 2, "constant", 4, False), +TEST_CASES_2D = [ + (30, False, "bilinear", "border", False), + (45, True, "bilinear", "border", False), + (-40, True, "nearest", "reflection", False), + (180, False, "nearest", "zeros", False), + (-90, False, "bilinear", "zeros", True), +] + +TEST_CASES_3D = [ + (-90.0, True, "nearest", "border", False), + (45, True, "bilinear", "border", False), + (-40, True, "nearest", "reflection", False), + (180, False, "nearest", "zeros", False), + (-90, False, "bilinear", "zeros", False), +] + +TEST_CASES_SHAPE_3D = [ + ([-90.0, 1.0, 2.0], "nearest", "border", False), + ([45, 0, 0], "bilinear", "border", False), + ([-40, -20, 20], "nearest", "reflection", False), ] -class TestRotate(NumpyImageTestCase2D): - @parameterized.expand(TEST_CASES) - def test_correct_results(self, angle, spatial_axes, reshape, order, mode, cval, prefilter): - rotate_fn = Rotate(angle, spatial_axes, reshape, order, mode, cval, prefilter) +class TestRotate2D(NumpyImageTestCase2D): + @parameterized.expand(TEST_CASES_2D) + def test_correct_results(self, angle, keep_size, order, mode, align_corners): + rotate_fn = Rotate(angle, keep_size, order, mode, align_corners) rotated = rotate_fn(self.imt[0]) + if keep_size: + np.testing.assert_allclose(self.imt[0].shape, rotated.shape) + _order = 0 if order == "nearest" else 1 + if mode == "border": + _mode = "nearest" + elif mode == "reflection": + _mode = "reflect" + else: + _mode = "constant" + expected = list() for channel in self.imt[0]: expected.append( - scipy.ndimage.rotate( - channel, angle, spatial_axes, reshape, order=order, mode=mode, cval=cval, prefilter=prefilter - ) + scipy.ndimage.rotate(channel, -angle, (0, 1), not keep_size, order=_order, mode=_mode, prefilter=False) ) expected = np.stack(expected).astype(np.float32) - self.assertTrue(np.allclose(expected, rotated)) + np.testing.assert_allclose(expected, rotated, atol=1e-1) + + +class TestRotate3D(NumpyImageTestCase3D): + @parameterized.expand(TEST_CASES_3D) + def test_correct_results(self, angle, keep_size, order, mode, align_corners): + rotate_fn = Rotate([angle, 0, 0], keep_size, order, mode, align_corners) + rotated = rotate_fn(self.imt[0]) + if keep_size: + np.testing.assert_allclose(self.imt[0].shape, rotated.shape) + _order = 0 if order == "nearest" else 1 + if mode == "border": + _mode = "nearest" + elif mode == "reflection": + _mode = "reflect" + else: + _mode = "constant" + + expected = list() + for channel in self.imt[0]: + expected.append( + scipy.ndimage.rotate(channel, -angle, (1, 2), not keep_size, order=_order, mode=_mode, prefilter=False) + ) + expected = np.stack(expected).astype(np.float32) + np.testing.assert_allclose(expected, rotated, atol=1e-1) + + @parameterized.expand(TEST_CASES_SHAPE_3D) + def test_correct_shape(self, angle, order, mode, align_corners): + rotate_fn = Rotate(angle, True, align_corners) + rotated = rotate_fn(self.imt[0], interp_order=order, mode=mode) + np.testing.assert_allclose(self.imt[0].shape, rotated.shape) + + def test_ill_case(self): + rotate_fn = Rotate(10, True) + with self.assertRaises(ValueError): # wrong shape + rotate_fn(self.imt) + + rotate_fn = Rotate(10, keep_size=False) + with self.assertRaises(ValueError): # wrong mode + rotate_fn(self.imt[0], mode="trilinear") if __name__ == "__main__": diff --git a/tests/test_rotated.py b/tests/test_rotated.py index 5d32ffadd05..34850a82f6a 100644 --- a/tests/test_rotated.py +++ b/tests/test_rotated.py @@ -10,36 +10,107 @@ # limitations under the License. import unittest -import numpy as np +import numpy as np import scipy.ndimage from parameterized import parameterized +from tests.utils import NumpyImageTestCase2D, NumpyImageTestCase3D from monai.transforms import Rotated -from tests.utils import NumpyImageTestCase2D -TEST_CASES = [ - (90, (0, 1), True, 1, "reflect", 0, True), - (-90, (1, 0), True, 3, "constant", 0, True), - (180, (1, 0), False, 2, "constant", 4, False), +TEST_CASES_2D = [ + (-30, False, "bilinear", "border", False), + (-45, True, "bilinear", "border", False), + (40, True, "nearest", "reflection", False), + (-180, False, "nearest", "zeros", False), + (90, False, "bilinear", "zeros", True), +] + +TEST_CASES_3D = [ + (-30, False, "bilinear", "border", False), + (-45, True, "bilinear", "border", False), + (40, True, "nearest", "reflection", False), + (-180, False, "nearest", "zeros", False), + (90, False, "bilinear", "zeros", True), ] -class TestRotated(NumpyImageTestCase2D): - @parameterized.expand(TEST_CASES) - def test_correct_results(self, angle, spatial_axes, reshape, interp_order, mode, cval, prefilter): - key = "img" - rotate_fn = Rotated(key, angle, spatial_axes, reshape, interp_order, mode, cval, prefilter) - rotated = rotate_fn({key: self.imt[0]}) - expected = list() - for channel in self.imt[0]: - expected.append( - scipy.ndimage.rotate( - channel, angle, spatial_axes, reshape, order=interp_order, mode=mode, cval=cval, prefilter=prefilter - ) - ) - expected = np.stack(expected).astype(np.float32) - self.assertTrue(np.allclose(expected, rotated[key])) +class TestRotated2D(NumpyImageTestCase2D): + @parameterized.expand(TEST_CASES_2D) + def test_correct_results(self, angle, keep_size, interp_order, mode, align_corners): + rotate_fn = Rotated(("img", "seg"), angle, keep_size, (interp_order, "nearest"), mode, align_corners) + rotated = rotate_fn({"img": self.imt[0], "seg": self.segn[0]}) + if keep_size: + np.testing.assert_allclose(self.imt[0].shape, rotated["img"].shape) + _order = 0 if interp_order == "nearest" else 1 + if mode == "border": + _mode = "nearest" + elif mode == "reflection": + _mode = "reflect" + else: + _mode = "constant" + expected = scipy.ndimage.rotate( + self.imt[0, 0], -angle, (0, 1), not keep_size, order=_order, mode=_mode, prefilter=False + ) + np.testing.assert_allclose(expected, rotated["img"][0], atol=1e-3) + + expected = scipy.ndimage.rotate( + self.segn[0, 0], -angle, (0, 1), not keep_size, order=0, mode=_mode, prefilter=False + ) + expected = np.stack(expected).astype(int) + self.assertLessEqual(np.count_nonzero(expected != rotated["seg"][0]), 20) + + +class TestRotated3D(NumpyImageTestCase3D): + @parameterized.expand(TEST_CASES_3D) + def test_correct_results(self, angle, keep_size, interp_order, mode, align_corners): + rotate_fn = Rotated(("img", "seg"), [0, angle, 0], keep_size, (interp_order, "nearest"), mode, align_corners) + rotated = rotate_fn({"img": self.imt[0], "seg": self.segn[0]}) + if keep_size: + np.testing.assert_allclose(self.imt[0].shape, rotated["img"].shape) + _order = 0 if interp_order == "nearest" else 1 + if mode == "border": + _mode = "nearest" + elif mode == "reflection": + _mode = "reflect" + else: + _mode = "constant" + expected = scipy.ndimage.rotate( + self.imt[0, 0], angle, (0, 2), not keep_size, order=_order, mode=_mode, prefilter=False + ) + np.testing.assert_allclose(expected, rotated["img"][0], atol=1e-3) + + expected = scipy.ndimage.rotate( + self.segn[0, 0], angle, (0, 2), not keep_size, order=0, mode=_mode, prefilter=False + ) + expected = np.stack(expected).astype(int) + self.assertLessEqual(np.count_nonzero(expected != rotated["seg"][0]), 100) + + +class TestRotated3DXY(NumpyImageTestCase3D): + @parameterized.expand(TEST_CASES_3D) + def test_correct_results(self, angle, keep_size, interp_order, mode, align_corners): + rotate_fn = Rotated(("img", "seg"), [0, 0, angle], keep_size, (interp_order, "nearest"), mode, align_corners) + rotated = rotate_fn({"img": self.imt[0], "seg": self.segn[0]}) + if keep_size: + np.testing.assert_allclose(self.imt[0].shape, rotated["img"].shape) + _order = 0 if interp_order == "nearest" else 1 + if mode == "border": + _mode = "nearest" + elif mode == "reflection": + _mode = "reflect" + else: + _mode = "constant" + expected = scipy.ndimage.rotate( + self.imt[0, 0], -angle, (0, 1), not keep_size, order=_order, mode=_mode, prefilter=False + ) + np.testing.assert_allclose(expected, rotated["img"][0], atol=1e-3) + + expected = scipy.ndimage.rotate( + self.segn[0, 0], -angle, (0, 1), not keep_size, order=0, mode=_mode, prefilter=False + ) + expected = np.stack(expected).astype(int) + self.assertLessEqual(np.count_nonzero(expected != rotated["seg"][0]), 100) if __name__ == "__main__": diff --git a/tests/utils.py b/tests/utils.py index a1ad79f2a67..efb5b252499 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -18,7 +18,7 @@ import numpy as np import torch -from monai.data.synthetic import create_test_image_2d +from monai.data.synthetic import create_test_image_2d, create_test_image_3d quick_test_var = "QUICKTEST" @@ -45,7 +45,7 @@ def make_nifti_image(array, affine=None): class NumpyImageTestCase2D(unittest.TestCase): - im_shape = (128, 128) + im_shape = (128, 64) input_channels = 1 output_channels = 4 num_classes = 3 @@ -66,6 +66,28 @@ def setUp(self): self.segn = torch.tensor(self.segn) +class NumpyImageTestCase3D(unittest.TestCase): + im_shape = (64, 48, 80) + input_channels = 1 + output_channels = 4 + num_classes = 3 + + def setUp(self): + im, msk = create_test_image_3d(self.im_shape[0], self.im_shape[1], self.im_shape[2], 4, 20, 0, self.num_classes) + + self.imt = im[None, None] + self.seg1 = (msk[None, None] > 0).astype(np.float32) + self.segn = msk[None, None] + + +class TorchImageTestCase3D(NumpyImageTestCase3D): + def setUp(self): + NumpyImageTestCase3D.setUp(self) + self.imt = torch.tensor(self.imt) + self.seg1 = torch.tensor(self.seg1) + self.segn = torch.tensor(self.segn) + + def expect_failure_if_no_gpu(test): if not torch.cuda.is_available(): return unittest.expectedFailure(test) From 582af1cadf0b6d9494a02406e3ee19a6c8221d79 Mon Sep 17 00:00:00 2001 From: Wenqi Li Date: Thu, 11 Jun 2020 15:54:14 +0100 Subject: [PATCH 2/5] fixes typing errors --- monai/transforms/spatial/array.py | 6 +++--- monai/transforms/spatial/dictionary.py | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/monai/transforms/spatial/array.py b/monai/transforms/spatial/array.py index af6e98b205d..97943e54b7f 100644 --- a/monai/transforms/spatial/array.py +++ b/monai/transforms/spatial/array.py @@ -519,13 +519,13 @@ def __init__( ): self.range_x = ensure_tuple(range_x) if len(self.range_x) == 1: - self.range_x = sorted((-self.range_x[0], self.range_x[0])) + self.range_x = tuple(sorted([-self.range_x[0], self.range_x[0]])) self.range_y = ensure_tuple(range_y) if len(self.range_y) == 1: - self.range_y = sorted((-self.range_y[0], self.range_y[0])) + self.range_y = tuple(sorted([-self.range_y[0], self.range_y[0]])) self.range_z = ensure_tuple(range_z) if len(self.range_z) == 1: - self.range_z = sorted((-self.range_z[0], self.range_z[0])) + self.range_z = tuple(sorted([-self.range_z[0], self.range_z[0]])) self.prob = prob self.keep_size = keep_size diff --git a/monai/transforms/spatial/dictionary.py b/monai/transforms/spatial/dictionary.py index 60ed6d695fd..f76eb8ba039 100644 --- a/monai/transforms/spatial/dictionary.py +++ b/monai/transforms/spatial/dictionary.py @@ -662,13 +662,13 @@ def __init__( super().__init__(keys) self.range_x = ensure_tuple(range_x) if len(self.range_x) == 1: - self.range_x = sorted((-self.range_x[0], self.range_x[0])) + self.range_x = tuple(sorted([-self.range_x[0], self.range_x[0]])) self.range_y = ensure_tuple(range_y) if len(self.range_y) == 1: - self.range_y = sorted((-self.range_y[0], self.range_y[0])) + self.range_y = tuple(sorted([-self.range_y[0], self.range_y[0]])) self.range_z = ensure_tuple(range_z) if len(self.range_z) == 1: - self.range_z = sorted((-self.range_z[0], self.range_z[0])) + self.range_z = tuple(sorted([-self.range_z[0], self.range_z[0]])) self.prob = prob self.keep_size = keep_size From b835b75bab2e234c05b1b71bf5fdba2fed6bef0e Mon Sep 17 00:00:00 2001 From: Wenqi Li Date: Thu, 11 Jun 2020 16:09:34 +0100 Subject: [PATCH 3/5] fixes integration tests --- examples/notebooks/mednist_tutorial.ipynb | 2 +- tests/test_integration_classification_2d.py | 8 ++++---- tests/test_rand_zoom.py | 2 +- tests/test_rand_zoomd.py | 2 +- tests/test_zoomd.py | 2 +- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/examples/notebooks/mednist_tutorial.ipynb b/examples/notebooks/mednist_tutorial.ipynb index 6fd1920cbe9..f5bb535b21c 100644 --- a/examples/notebooks/mednist_tutorial.ipynb +++ b/examples/notebooks/mednist_tutorial.ipynb @@ -235,7 +235,7 @@ " LoadPNG(image_only=True),\n", " AddChannel(),\n", " ScaleIntensity(),\n", - " RandRotate(degrees=15, prob=0.5, reshape=False),\n", + " RandRotate(range_x=15, prob=0.5, keep_size=True),\n", " RandFlip(spatial_axis=0, prob=0.5),\n", " RandZoom(min_zoom=0.9, max_zoom=1.1, prob=0.5),\n", " ToTensor()\n", diff --git a/tests/test_integration_classification_2d.py b/tests/test_integration_classification_2d.py index ac83b4f620f..af2c311d5d5 100644 --- a/tests/test_integration_classification_2d.py +++ b/tests/test_integration_classification_2d.py @@ -61,7 +61,7 @@ def run_training_test(root_dir, train_x, train_y, val_x, val_y, device=torch.dev LoadPNG(image_only=True), AddChannel(), ScaleIntensity(), - RandRotate(degrees=15, prob=0.5, reshape=False), + RandRotate(range_x=15, prob=0.5, keep_size=True), RandFlip(spatial_axis=0, prob=0.5), RandZoom(min_zoom=0.9, max_zoom=1.1, prob=0.5), ToTensor(), @@ -221,11 +221,11 @@ def test_training(self): # check training properties np.testing.assert_allclose( - losses, [0.8184022269431194, 0.17296756841954153, 0.07789294457264767, 0.04796914244960448], rtol=1e-3 + losses, [0.7797081090842083, 0.16179659706392105, 0.07446704363557184, 0.045996826011568875], rtol=1e-3 ) repeated[i].extend(losses) print("best metric", best_metric) - np.testing.assert_allclose(best_metric, 0.9999440132655022, rtol=1e-4) + np.testing.assert_allclose(best_metric, 0.9999268330306007, rtol=1e-4) repeated[i].append(best_metric) np.testing.assert_allclose(best_metric_epoch, 4) model_file = os.path.join(self.data_dir, "best_metric_model.pth") @@ -234,7 +234,7 @@ def test_training(self): infer_metric = run_inference_test(self.data_dir, self.test_x, self.test_y, device=self.device) # check inference properties - np.testing.assert_allclose(np.asarray(infer_metric), [1032, 895, 982, 1033, 959, 1047], atol=1) + np.testing.assert_allclose(np.asarray(infer_metric), [1031, 895, 981, 1033, 960, 1047], atol=1) repeated[i].extend(infer_metric) np.testing.assert_allclose(repeated[0], repeated[1]) diff --git a/tests/test_rand_zoom.py b/tests/test_rand_zoom.py index 6e995a98876..dcead410f89 100644 --- a/tests/test_rand_zoom.py +++ b/tests/test_rand_zoom.py @@ -18,7 +18,7 @@ from monai.transforms import RandZoom -VALID_CASES = [(0.9, 1.1, "nearest", False)] +VALID_CASES = [(0.8, 1.2, "nearest", False)] class TestRandZoom(NumpyImageTestCase2D): diff --git a/tests/test_rand_zoomd.py b/tests/test_rand_zoomd.py index 938051614e7..75a6e0ff365 100644 --- a/tests/test_rand_zoomd.py +++ b/tests/test_rand_zoomd.py @@ -18,7 +18,7 @@ from monai.transforms import RandZoomd -VALID_CASES = [(0.9, 1.1, "nearest", None, False)] +VALID_CASES = [(0.8, 1.2, "nearest", None, False)] class TestRandZoomd(NumpyImageTestCase2D): diff --git a/tests/test_zoomd.py b/tests/test_zoomd.py index e95617ca2f6..44d51aab0bf 100644 --- a/tests/test_zoomd.py +++ b/tests/test_zoomd.py @@ -21,7 +21,7 @@ VALID_CASES = [ (1.5, "nearest", False), - (0.4, "bilinear", False), + (0.3, "bilinear", False), (0.8, "bilinear", False), ] From d5db2b1f378302d410417a45bd166165cc2babda Mon Sep 17 00:00:00 2001 From: Wenqi Li Date: Thu, 11 Jun 2020 17:19:31 +0100 Subject: [PATCH 4/5] remove unused import/variables --- monai/data/utils.py | 19 ------------------- monai/engines/multi_gpu_supervised_trainer.py | 2 +- monai/engines/workflow.py | 1 - monai/handlers/roc_auc.py | 3 +++ monai/inferers/utils.py | 2 +- monai/transforms/croppad/array.py | 2 +- monai/transforms/croppad/dictionary.py | 2 +- monai/transforms/intensity/array.py | 2 +- monai/transforms/spatial/array.py | 4 ++-- monai/transforms/spatial/dictionary.py | 1 - monai/transforms/utility/dictionary.py | 2 +- monai/transforms/utils.py | 4 ++-- 12 files changed, 13 insertions(+), 31 deletions(-) diff --git a/monai/data/utils.py b/monai/data/utils.py index cc956656a08..c01e85f2904 100644 --- a/monai/data/utils.py +++ b/monai/data/utils.py @@ -22,24 +22,6 @@ from monai.utils import ensure_tuple_size from monai.networks.layers.simplelayers import GaussianFilter -import enum - - -class InterpolationCode(enum.IntEnum): - """ - A convenience enumeration to make code uses more expressive - """ - - SPLINE0 = 0 - NEARESTNEIGHBOR = 0 - SPLINE1 = 1 - LINEAR = 1 - SPLINE2 = 2 - CUBIC = 2 - SPLINE3 = 3 - SPLINE4 = 4 - SPLINE5 = 5 - def get_random_patch(dims, patch_size, rand_state: Optional[np.random.RandomState] = None): """ @@ -452,7 +434,6 @@ def compute_importance_map(patch_size, mode="constant", sigma_scale: float = 0.1 Returns: Tensor of size patch_size. """ - importance_map = None if mode == "constant": importance_map = torch.ones(patch_size, device=device).float() elif mode == "gaussian": diff --git a/monai/engines/multi_gpu_supervised_trainer.py b/monai/engines/multi_gpu_supervised_trainer.py index b250d3b4c3c..bc8e6359cf9 100644 --- a/monai/engines/multi_gpu_supervised_trainer.py +++ b/monai/engines/multi_gpu_supervised_trainer.py @@ -16,7 +16,7 @@ from .utils import get_devices_spec -def _default_transform(x, y, y_pred, loss): +def _default_transform(_x, _y, _y_pred, loss): return loss.item() diff --git a/monai/engines/workflow.py b/monai/engines/workflow.py index 9d25a89a91f..9b15e8d92ad 100644 --- a/monai/engines/workflow.py +++ b/monai/engines/workflow.py @@ -97,7 +97,6 @@ def __init__( def run_post_transform(engine): engine.state.output = apply_transform(post_transform, engine.state.output) - metrics = None if key_metric is not None: if not isinstance(key_metric, dict): diff --git a/monai/handlers/roc_auc.py b/monai/handlers/roc_auc.py index a96bae30d2b..90a8b225940 100644 --- a/monai/handlers/roc_auc.py +++ b/monai/handlers/roc_auc.py @@ -60,6 +60,9 @@ def __init__( self.softmax = softmax self.average = average + self._predictions = [] + self._targets = [] + def reset(self): self._predictions = [] self._targets = [] diff --git a/monai/inferers/utils.py b/monai/inferers/utils.py index 135bb17e3b3..9fd743ae31b 100644 --- a/monai/inferers/utils.py +++ b/monai/inferers/utils.py @@ -38,7 +38,7 @@ def sliding_window_inference( """ num_spatial_dims = len(inputs.shape) - 2 assert len(roi_size) == num_spatial_dims, f"roi_size {roi_size} does not match input dims." - assert overlap >= 0 and overlap < 1, "overlap must be >= 0 and < 1." + assert 0 <= overlap < 1, "overlap must be >= 0 and < 1." # determine image spatial size and batch size # Note: all input images must have the same image size and batch size diff --git a/monai/transforms/croppad/array.py b/monai/transforms/croppad/array.py index dc4989534d6..8787d576cbd 100644 --- a/monai/transforms/croppad/array.py +++ b/monai/transforms/croppad/array.py @@ -30,7 +30,7 @@ class SpatialPad(Transform): for additional details. Args: - spatial_size (list): the spatial size of output data after padding. + spatial_size (sequence of int): the spatial size of output data after padding. method (str): pad image symmetric on every side or only pad at the end sides. default is 'symmetric'. mode (str): one of the following string values or a user supplied function: {'constant', 'edge', 'linear_ramp', 'maximum', 'mean', 'median', 'minimum', 'reflect', 'symmetric', 'wrap', 'empty', } diff --git a/monai/transforms/croppad/dictionary.py b/monai/transforms/croppad/dictionary.py index 13244408248..d5ec73d0007 100644 --- a/monai/transforms/croppad/dictionary.py +++ b/monai/transforms/croppad/dictionary.py @@ -15,7 +15,7 @@ Class names are ended with 'd' to denote dictionary-based transforms. """ -from typing import Union, Optional, Callable, Iterable +from typing import Optional, Callable from monai.config.type_definitions import KeysCollection, IndexSelection from monai.data.utils import get_random_patch, get_valid_patch_size diff --git a/monai/transforms/intensity/array.py b/monai/transforms/intensity/array.py index 73529aa852b..5c2633eb8ab 100644 --- a/monai/transforms/intensity/array.py +++ b/monai/transforms/intensity/array.py @@ -13,7 +13,7 @@ https://github.com/Project-MONAI/MONAI/wiki/MONAI_Design """ -from typing import Union, Optional, Tuple +from typing import Optional, Tuple import numpy as np diff --git a/monai/transforms/spatial/array.py b/monai/transforms/spatial/array.py index 97943e54b7f..3e652231ab4 100644 --- a/monai/transforms/spatial/array.py +++ b/monai/transforms/spatial/array.py @@ -21,7 +21,7 @@ import torch from monai.config import get_torch_version_tuple -from monai.data.utils import InterpolationCode, compute_shape_offset, to_affine_nd, zoom_affine +from monai.data.utils import compute_shape_offset, to_affine_nd, zoom_affine from monai.networks.layers import AffineTransform, GaussianFilter from monai.transforms.compose import Randomizable, Transform from monai.transforms.utils import ( @@ -37,7 +37,7 @@ if get_torch_version_tuple() >= (1, 5): # additional argument since torch 1.5 (to avoid warnings) def _torch_interp(**kwargs): - return torch.nn.functional.interpolate(**kwargs, recompute_scale_factor=False) + return torch.nn.functional.interpolate(recompute_scale_factor=False, **kwargs) else: diff --git a/monai/transforms/spatial/dictionary.py b/monai/transforms/spatial/dictionary.py index f76eb8ba039..a2e2ee8290b 100644 --- a/monai/transforms/spatial/dictionary.py +++ b/monai/transforms/spatial/dictionary.py @@ -21,7 +21,6 @@ import torch from monai.config.type_definitions import KeysCollection -from monai.data.utils import InterpolationCode from monai.networks.layers.simplelayers import GaussianFilter from monai.transforms.compose import MapTransform, Randomizable diff --git a/monai/transforms/utility/dictionary.py b/monai/transforms/utility/dictionary.py index fd6e7b9c270..72fb7542803 100644 --- a/monai/transforms/utility/dictionary.py +++ b/monai/transforms/utility/dictionary.py @@ -22,7 +22,7 @@ from monai.config.type_definitions import KeysCollection from monai.transforms.compose import MapTransform -from monai.utils.misc import ensure_tuple_rep, ensure_tuple +from monai.utils.misc import ensure_tuple_rep from monai.transforms.utility.array import ( AddChannel, AsChannelFirst, diff --git a/monai/transforms/utils.py b/monai/transforms/utils.py index 8e689fcc2c0..7a075f1a14d 100644 --- a/monai/transforms/utils.py +++ b/monai/transforms/utils.py @@ -11,7 +11,7 @@ import random import warnings -from typing import Optional, Union, Callable +from typing import Optional, Callable import torch import numpy as np @@ -248,7 +248,7 @@ def apply_transform(transform: Callable, data, map_items: bool = True): Args: transform (callable): a callable to be used to transform `data` data (object): an object to be transformed. - map_item: whether to apply transform to each item in `data`, + map_items: whether to apply transform to each item in `data`, if `data` is a list or tuple. Defaults to True. """ try: From 675edb15b9e5734d2fc1fa360dd5fa37419521eb Mon Sep 17 00:00:00 2001 From: Wenqi Li Date: Thu, 11 Jun 2020 18:06:43 +0100 Subject: [PATCH 5/5] remove scipy dep from core --- docs/requirements.txt | 1 - requirements-dev.txt | 1 + requirements.txt | 1 - setup.cfg | 1 - 4 files changed, 1 insertion(+), 3 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 64f0bb91d4d..4037a207105 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -4,7 +4,6 @@ pytorch-ignite==0.3.0 numpy>=1.17 nibabel parameterized -scipy scikit-image>=0.14.2 tensorboard commonmark==0.9.1 diff --git a/requirements-dev.txt b/requirements-dev.txt index f8a1c00ccee..10743280340 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,5 +1,6 @@ # Requirements for testing -r requirements.txt +scipy flake8>=3.8.1 flake8-mypy flake8-bugbear diff --git a/requirements.txt b/requirements.txt index 1dc2e6e1f76..8c1bba3616a 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,5 +4,4 @@ numpy>=1.17 nibabel tensorboard pillow -scipy scikit-image>=0.14.2 diff --git a/setup.cfg b/setup.cfg index 9023ba3bff4..409ecb6480a 100644 --- a/setup.cfg +++ b/setup.cfg @@ -18,7 +18,6 @@ install_requires = nibabel tensorboard pillow - scipy scikit-image >=0.14.2 [flake8]