Merge branch 'dev' into fix-issue-8780

Signed-off-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com>

Author: ericspod

monai/losses/image_dissimilarity.py

@@ -15,7 +15,7 @@
 from torch.nn import functional as F
 from torch.nn.modules.loss import _Loss
 
-from monai.networks.layers import gaussian_1d, separable_filtering
+from monai.networks.layers import separable_filtering
 from monai.utils import LossReduction
 from monai.utils.module import look_up_option
 
@@ -34,11 +34,11 @@ def make_triangular_kernel(kernel_size: int) -> torch.Tensor:
 
 
 def make_gaussian_kernel(kernel_size: int) -> torch.Tensor:
-    sigma = torch.tensor(kernel_size / 3.0)
-    kernel = gaussian_1d(sigma=sigma, truncated=(kernel_size // 2) / sigma, approx="sampled", normalize=False) * (
-        2.5066282 * sigma
-    )
-    return kernel[:kernel_size]
+    sigma = kernel_size / 3.0
+    half = kernel_size // 2
+    x = torch.arange(-half, half + 1, dtype=torch.float)
+    kernel = torch.exp(-0.5 / (sigma * sigma) * x**2)
+    return kernel
 
 
 kernel_dict = {

tests/data/utils/test_compute_shape_offset.py

@@ -19,8 +19,8 @@
 from monai.data.utils import compute_shape_offset
 
 
-class TestComputeShapeOffsetRegression(unittest.TestCase):
-    """Regression tests for `compute_shape_offset` input-shape handling."""
+class TestComputeShapeOffset(unittest.TestCase):
+    """Unit tests for :func:`monai.data.utils.compute_shape_offset`."""
 
     def test_pytorch_size_input(self):
         """Validate `torch.Size` input produces expected shape and offset.
@@ -42,6 +42,39 @@ def test_pytorch_size_input(self):
         # 3. Prove it successfully processed the shape by checking its length
         self.assertEqual(len(shape), 3)
 
+    def setUp(self):
+        """Set up a 4x4 identity affine used across all test cases."""
+        self.affine = np.eye(4)
+
+    def test_numpy_array_input(self):
+        """Verify compute_shape_offset accepts a numpy array as spatial_shape."""
+        shape = np.array([64, 64, 64])
+        out_shape, _ = compute_shape_offset(shape, self.affine, self.affine)
+        self.assertEqual(len(out_shape), 3)
+
+    def test_list_input(self):
+        """Verify compute_shape_offset accepts a plain list as spatial_shape."""
+        shape = [64, 64, 64]
+        out_shape, _ = compute_shape_offset(shape, self.affine, self.affine)
+        self.assertEqual(len(out_shape), 3)
+
+    def test_torch_tensor_input(self):
+        """Verify compute_shape_offset accepts a torch.Tensor as spatial_shape.
+
+        This path broke in PyTorch >= 2.9 because np.array() relied on the
+        non-tuple sequence indexing protocol that PyTorch removed. Wrapping with
+        tuple() fixes it.
+        """
+        shape = torch.tensor([64, 64, 64])
+        out_shape, _ = compute_shape_offset(shape, self.affine, self.affine)
+        self.assertEqual(len(out_shape), 3)
+
+    def test_identity_affines_preserve_shape(self):
+        """Verify that identity in/out affines produce an output shape matching the input."""
+        shape = torch.tensor([32, 48, 16])
+        out_shape, _ = compute_shape_offset(shape, self.affine, self.affine)
+        np.testing.assert_allclose(np.array(out_shape, dtype=float), shape.numpy().astype(float), atol=1e-5)
+
 
 if __name__ == "__main__":
     unittest.main()

tests/losses/image_dissimilarity/test_local_normalized_cross_correlation_loss.py

@@ -17,7 +17,7 @@
 import torch
 from parameterized import parameterized
 
-from monai.losses.image_dissimilarity import LocalNormalizedCrossCorrelationLoss
+from monai.losses.image_dissimilarity import LocalNormalizedCrossCorrelationLoss, make_gaussian_kernel
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
@@ -113,6 +113,25 @@
         },
         -0.95406944,
     ],
+    # Regression tests for gh-8780: gaussian kernel_size > 3 was broken due to
+    # truncated parameter being passed as pixel radius instead of sigma multiplier.
+    # Identical images must yield loss == -1.0 for any kernel size.
+    [
+        {"spatial_dims": 1, "kernel_type": "gaussian", "kernel_size": 5},
+        {
+            "pred": torch.arange(0, 5).reshape(1, 1, -1).to(dtype=torch.float, device=device),
+            "target": torch.arange(0, 5).reshape(1, 1, -1).to(dtype=torch.float, device=device),
+        },
+        -1.0,
+    ],
+    [
+        {"spatial_dims": 1, "kernel_type": "gaussian", "kernel_size": 9},
+        {
+            "pred": torch.arange(0, 9).reshape(1, 1, -1).to(dtype=torch.float, device=device),
+            "target": torch.arange(0, 9).reshape(1, 1, -1).to(dtype=torch.float, device=device),
+        },
+        -1.0,
+    ],
 ]
 
 
@@ -138,6 +157,15 @@ def test_ill_shape(self):
                 torch.ones((1, 3, 4, 4, 4), dtype=torch.float, device=device),
             )
 
+    def test_gaussian_kernel_shape_and_symmetry(self):
+        # gh-8780: kernel must have correct length, be symmetric, and peak at center
+        for kernel_size in [3, 5, 7, 9, 11, 15]:
+            k = make_gaussian_kernel(kernel_size)
+            self.assertEqual(len(k), kernel_size)
+            self.assertTrue(torch.allclose(k, k.flip(0)), f"kernel_size={kernel_size} not symmetric")
+            self.assertEqual(k.argmax().item(), kernel_size // 2)
+            np.testing.assert_allclose(k.max().item(), 1.0, rtol=1e-6)
+
     def test_ill_opts(self):
         pred = torch.ones((1, 3, 3, 3, 3), dtype=torch.float)
         target = torch.ones((1, 3, 3, 3, 3), dtype=torch.float)