minor updates

  - `_pending_operations` defaults to `MetaObj.get_default_applied_operations()`
  - removes the unused `Apply` class
  - fixes unit tests, style checks
  - torch.pi doesn't exist before torch 1.10

Signed-off-by: Wenqi Li <wenqil@nvidia.com>

Author: wyli

monai/data/meta_obj.py

@@ -214,7 +214,7 @@ def pop_pending_operation(self) -> Any:
         return self._pending_operations.pop()
 
     def clear_pending_operations(self) -> Any:
-        self._pending_operations = list()
+        self._pending_operations = MetaObj.get_default_applied_operations()
 
     @property
     def is_batch(self) -> bool:

monai/transforms/__init__.py

@@ -227,7 +227,6 @@
 from .inverse_batch_transform import BatchInverseTransform, Decollated, DecollateD, DecollateDict
 from .io.array import SUPPORTED_READERS, LoadImage, SaveImage
 from .io.dictionary import LoadImaged, LoadImageD, LoadImageDict, SaveImaged, SaveImageD, SaveImageDict
-from .lazy.array import Apply
 from .lazy.functional import apply
 from .meta_matrix import Grid, Matrix, MatrixFactory, MetaMatrix, matmul
 from .meta_utility.dictionary import (

monai/transforms/lazy/array.py

@@ -904,16 +904,10 @@ def _create_rotate_90(
     else:
         raise ValueError(f"'spatial_dims' must be 2 or 3 but is {spatial_dims}")
 
-    steps_ = steps % 4
-
     affine = eye_func(spatial_dims + 1)
 
-    if spatial_dims == 2:
-        a, b = 0, 1
-    else:
-        a, b = axis
-
-    affine[a, a], affine[a, b], affine[b, a], affine[b, b] = values[steps]
+    a, b = (0, 1) if spatial_dims == 2 else axis
+    affine[a, a], affine[a, b], affine[b, a], affine[b, b] = values[steps % 4]
     return affine
 
 

monai/transforms/utils.py

@@ -11,6 +11,7 @@
 
 import unittest
 
+import numpy as np
 import torch
 
 from monai.transforms.lazy.functional import apply
@@ -22,10 +23,10 @@ def single_2d_transform_cases():
     f = MatrixFactory(2, TransformBackends.TORCH, "cpu")
 
     cases = [
-        (torch.randn((1, 32, 32)), [MetaMatrix(f.rotate_euler(torch.pi / 4).matrix, {"id": "rotate"})], (1, 32, 32)),
+        (torch.randn((1, 32, 32)), [MetaMatrix(f.rotate_euler(np.pi / 4).matrix, {"id": "rotate"})], (1, 32, 32)),
         (
             torch.randn((1, 16, 16)),
-            [MetaMatrix(f.rotate_euler(torch.pi / 4).matrix, {"id": "rotate", "shape_override": (1, 45, 45)})],
+            [MetaMatrix(f.rotate_euler(np.pi / 4).matrix, {"id": "rotate", "shape_override": (1, 45, 45)})],
             (1, 45, 45),
         ),
     ]
@@ -34,15 +35,15 @@ def single_2d_transform_cases():
 
 
 class TestApply(unittest.TestCase):
-    def _test_apply_impl(self, tensor, pending_transforms):
-        print(tensor.shape)
-        result = tensor(*pending_transforms)
+    def _test_apply_impl(self, tensor, pending_transforms, expected_shape):
+        result = apply(tensor, pending_transforms)
         self.assertListEqual(result[1], pending_transforms)
+        self.assertEqual(result[0].shape, expected_shape)
 
     def _test_apply_metatensor_impl(self, tensor, pending_transforms, expected_shape, pending_as_parameter):
         tensor_ = convert_to_tensor(tensor, track_meta=True)
         if pending_as_parameter:
-            result, transforms = tensor_(*pending_transforms)
+            result, transforms = apply(tensor_, pending_transforms)
         else:
             for p in pending_transforms:
                 tensor_.push_pending_operation(p)

tests/test_apply.py

@@ -146,17 +146,17 @@ def get_matmul_2d_test_cases():
     f = MatrixFactory(2, TransformBackends.TORCH, "cpu")
     cases = [
         (
-            f.rotate_euler(torch.pi / 4),
+            f.rotate_euler(np.pi / 4),
             f.scale((0.5, 0.5)),
             torch.FloatTensor([[0.35355339, -0.35355339, 0], [0.35355339, 0.35355339, 0], [0, 0, 1]]),
         ),
         (
             f.scale((0.5, 0.5)),
-            f.rotate_euler(torch.pi / 4),
+            f.rotate_euler(np.pi / 4),
             torch.FloatTensor([[0.35355339, -0.35355339, 0], [0.35355339, 0.35355339, 0], [0, 0, 1]]),
         ),
-        (f.translate((8, 8)), f.rotate_euler(torch.pi / 2), torch.FloatTensor([[0, -1, 8], [1, 0, 8], [0, 0, 1]])),
-        (f.rotate_euler(torch.pi / 2), f.translate((8, 8)), torch.FloatTensor([[0, -1, -8], [1, 0, 8], [0, 0, 1]])),
+        (f.translate((8, 8)), f.rotate_euler(np.pi / 2), torch.FloatTensor([[0, -1, 8], [1, 0, 8], [0, 0, 1]])),
+        (f.rotate_euler(np.pi / 2), f.translate((8, 8)), torch.FloatTensor([[0, -1, -8], [1, 0, 8], [0, 0, 1]])),
     ]
 
     return cases

tests/test_matmul.py

@@ -27,8 +27,7 @@ def rotate_45_2d():
 
 class TestResampleFunction(unittest.TestCase):
     def _test_resample_function_impl(self, img, matrix):
-        result = resample(convert_to_tensor(img), matrix)
-        print(result)
+        resample(convert_to_tensor(img), matrix)
 
     RESAMPLE_FUNCTION_CASES = [(get_arange_img((1, 16, 16)), rotate_45_2d())]