monai-weekly 1.5.dev2506__py3-none-any.whl → 1.5.dev2507__py3-none-any.whl

tests/inferers/test_wsi_sliding_window_splitter.py

@@ -0,0 +1,249 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import os
+import unittest
+from pathlib import Path
+from unittest import skipUnless
+
+import torch
+from parameterized import parameterized
+
+from monai.data import CuCIMWSIReader, ImageReader, OpenSlideWSIReader, WSIReader
+from monai.inferers import WSISlidingWindowSplitter
+from tests.test_utils import download_url_or_skip_test, optional_import, testing_data_config
+
+cucim, has_cucim = optional_import("cucim")
+has_cucim = has_cucim and hasattr(cucim, "CuImage")
+_, has_osl = optional_import("openslide")
+
+WSI_READER_STR = None
+WSI_READER_CLASS: type[CuCIMWSIReader] | type[OpenSlideWSIReader] | None = None
+if has_cucim:
+    WSI_READER_STR = "cuCIM"
+    WSI_READER_CLASS = CuCIMWSIReader
+elif has_osl:
+    WSI_READER_STR = "OpenSlide"
+    WSI_READER_CLASS = OpenSlideWSIReader
+
+WSI_GENERIC_TIFF_KEY = "wsi_generic_tiff"
+TESTS_PATH = Path(__file__).parents[1]
+WSI_GENERIC_TIFF_PATH = os.path.join(TESTS_PATH, "testing_data", f"temp_{WSI_GENERIC_TIFF_KEY}.tiff")
+
+HEIGHT = 32914
+WIDTH = 46000
+
+# ----------------------------------------------------------------------------
+# WSI test cases
+# ----------------------------------------------------------------------------
+
+TEST_CASE_WSI_0_BASE = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (1000, 1000), "reader": WSI_READER_STR},
+    {"locations": [(0, 0), (0, 1000), (0, 2000), (0, 3000)]},
+]
+
+TEST_CASE_WSI_1_BASE = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (1000, 1000), "level": 1, "reader": WSI_READER_STR},
+    {"locations": [(0, 0), (0, 1000), (0, 2000), (0, 3000)]},
+]
+
+# Check readers
+if WSI_READER_STR is not None:
+    TEST_CASE_WSI_2_READER = [
+        WSI_GENERIC_TIFF_PATH,
+        {"patch_size": (1000, 1000), "reader": WSIReader(backend=WSI_READER_STR)},
+        {"locations": [(0, 0), (0, 1000), (0, 2000), (0, 3000)]},
+    ]
+else:
+    TEST_CASE_WSI_2_READER = []
+TEST_CASE_WSI_3_READER = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (1000, 1000), "overlap": 0.0, "reader": WSIReader, "backend": WSI_READER_STR},
+    {"locations": [(0, 0), (0, 1000), (0, 2000), (0, 3000)]},
+]
+TEST_CASE_WSI_4_READER = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (1000, 1000), "overlap": 0.0, "reader": WSI_READER_CLASS},
+    {"locations": [(0, 0), (0, 1000), (0, 2000), (0, 3000)]},
+]
+TEST_CASE_WSI_5_READER = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (1000, 1000), "overlap": 0.0, "level": 1, "reader": WSI_READER_STR},
+    {"locations": [(0, 0), (0, 1000), (0, 2000), (0, 3000)]},
+]
+
+# Check overlaps
+TEST_CASE_WSI_6_OVERLAP = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (1000, 1000), "overlap": 0.0, "reader": WSI_READER_STR},
+    {"locations": [(0, 0), (0, 1000), (0, 2000), (0, 3000)]},
+]
+TEST_CASE_WSI_7_OVERLAP = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (1000, 1000), "overlap": 0.5, "reader": WSI_READER_STR},
+    {"locations": [(0, 0), (0, 500), (0, 1000), (0, 1500)]},
+]
+TEST_CASE_WSI_8_OVERLAP = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (1000, 1000), "overlap": 0.999, "reader": WSI_READER_STR},
+    {"locations": [(0, 0), (0, 1), (0, 2), (0, 3)]},
+]
+
+
+# Filtering functions test cases
+def gen_location_filter(locations):
+    def my_filter(patch, loc):
+        if loc in locations:
+            return False
+        return True
+
+    return my_filter
+
+
+TEST_CASE_WSI_9_FILTER = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (1000, 1000), "reader": WSI_READER_STR, "filter_fn": gen_location_filter([(0, 0), (0, 2000)])},
+    {"locations": [(0, 1000), (0, 3000)]},
+]
+
+
+# ----------------------------------------------------------------------------
+# Error test cases
+# ----------------------------------------------------------------------------
+def extra_parameter_filter(patch, location, extra):
+    return
+
+
+def missing_parameter_filter(patch):
+    return
+
+
+# invalid overlap: float 1.0
+TEST_CASE_ERROR_0 = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (2, 2), "overlap": 1.0, "reader": WSI_READER_STR},
+    ValueError,
+]
+# invalid overlap: negative float
+TEST_CASE_ERROR_1 = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (2, 2), "overlap": -0.1, "reader": WSI_READER_STR},
+    ValueError,
+]
+# invalid overlap: negative integer
+TEST_CASE_ERROR_2 = [WSI_GENERIC_TIFF_PATH, {"patch_size": (2, 2), "overlap": -1, "reader": WSI_READER_STR}, ValueError]
+# invalid overlap: integer larger than patch size
+TEST_CASE_ERROR_3 = [WSI_GENERIC_TIFF_PATH, {"patch_size": (2, 2), "overlap": 3, "reader": WSI_READER_STR}, ValueError]
+
+# invalid offset: positive and larger than image size
+TEST_CASE_ERROR_4 = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (2, 2), "offset": WIDTH, "reader": WSI_READER_STR},
+    ValueError,
+]
+# invalid offset: negative and larger than patch size (in magnitude)
+TEST_CASE_ERROR_5 = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (2, 2), "offset": -3, "pad_mode": "constant", "reader": WSI_READER_STR},
+    ValueError,
+]
+# invalid offset: negative and no padding
+TEST_CASE_ERROR_6 = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (2, 2), "pad_mode": None, "offset": -1, "reader": WSI_READER_STR},
+    ValueError,
+]
+
+# invalid filter function: with more than two positional parameters
+TEST_CASE_ERROR_7 = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (2, 2), "filter_fn": extra_parameter_filter, "reader": WSI_READER_STR},
+    ValueError,
+]
+# invalid filter function: with less than two positional parameters
+TEST_CASE_ERROR_8 = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (2, 2), "filter_fn": missing_parameter_filter, "reader": WSI_READER_STR},
+    ValueError,
+]
+# invalid filter function: non-callable
+TEST_CASE_ERROR_9 = [
+    WSI_GENERIC_TIFF_PATH,
+    {"patch_size": (2, 2), "filter_fn": 1, "reader": WSI_READER_STR},
+    ValueError,
+]
+
+# invalid reader
+TEST_CASE_ERROR_10 = [WSI_GENERIC_TIFF_PATH, {"patch_size": (2, 2), "reader": ImageReader}, ValueError]
+
+
+@skipUnless(WSI_READER_STR, "Requires cucim or openslide!")
+def setUpModule():
+    download_url_or_skip_test(
+        testing_data_config("images", WSI_GENERIC_TIFF_KEY, "url"),
+        WSI_GENERIC_TIFF_PATH,
+        hash_type=testing_data_config("images", WSI_GENERIC_TIFF_KEY, "hash_type"),
+        hash_val=testing_data_config("images", WSI_GENERIC_TIFF_KEY, "hash_val"),
+    )
+
+
+class WSISlidingWindowSplitterTests(unittest.TestCase):
+    @parameterized.expand(
+        [
+            TEST_CASE_WSI_0_BASE,
+            TEST_CASE_WSI_1_BASE,
+            TEST_CASE_WSI_2_READER,
+            TEST_CASE_WSI_3_READER,
+            TEST_CASE_WSI_4_READER,
+            TEST_CASE_WSI_5_READER,
+            TEST_CASE_WSI_6_OVERLAP,
+            TEST_CASE_WSI_7_OVERLAP,
+            TEST_CASE_WSI_8_OVERLAP,
+            TEST_CASE_WSI_9_FILTER,
+        ]
+    )
+    def test_split_patches_wsi(self, filepath, arguments, expected):
+        patches = WSISlidingWindowSplitter(**arguments)(filepath)
+        for sample, expected_loc in zip(patches, expected["locations"]):
+            patch = sample[0]
+            loc = sample[1]
+            self.assertTrue(isinstance(patch, torch.Tensor))
+            self.assertTupleEqual(patch.shape[2:], arguments["patch_size"])
+            self.assertTrue(isinstance(loc, tuple))
+            self.assertTupleEqual(loc, expected_loc)
+
+    @parameterized.expand(
+        [
+            TEST_CASE_ERROR_0,
+            TEST_CASE_ERROR_1,
+            TEST_CASE_ERROR_2,
+            TEST_CASE_ERROR_3,
+            TEST_CASE_ERROR_4,
+            TEST_CASE_ERROR_5,
+            TEST_CASE_ERROR_6,
+            TEST_CASE_ERROR_7,
+            TEST_CASE_ERROR_8,
+            TEST_CASE_ERROR_9,
+            TEST_CASE_ERROR_10,
+        ]
+    )
+    def test_split_patches_errors(self, image, arguments, expected_error):
+        with self.assertRaises(expected_error):
+            patches = WSISlidingWindowSplitter(**arguments)(image)
+            patches = list(patches)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/inferers/test_zarr_avg_merger.py

@@ -0,0 +1,326 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+from torch.nn.functional import pad
+
+from monai.inferers import ZarrAvgMerger
+from monai.utils import get_package_version, optional_import, version_geq
+from tests.test_utils import assert_allclose
+
+np.seterr(divide="ignore", invalid="ignore")
+zarr, has_zarr = optional_import("zarr")
+if has_zarr:
+    if version_geq(get_package_version("zarr"), "3.0.0"):
+        directory_store = zarr.storage.LocalStore("test.zarr")
+    else:
+        directory_store = zarr.storage.DirectoryStore("test.zarr")
+else:
+    directory_store = None
+numcodecs, has_numcodecs = optional_import("numcodecs")
+
+TENSOR_4x4 = torch.randint(low=0, high=255, size=(2, 3, 4, 4), dtype=torch.float32)
+TENSOR_4x4_WITH_NAN = TENSOR_4x4.clone()
+TENSOR_4x4_WITH_NAN[..., 2:, 2:] = float("nan")
+
+# no-overlapping 2x2
+TEST_CASE_0_DEFAULT_DTYPE = [
+    dict(merged_shape=TENSOR_4x4.shape),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+# overlapping 2x2
+TEST_CASE_1_DEFAULT_DTYPE = [
+    dict(merged_shape=TENSOR_4x4.shape),
+    [
+        (TENSOR_4x4[..., 0:2, 0:2], (0, 0)),
+        (TENSOR_4x4[..., 0:2, 1:3], (0, 1)),
+        (TENSOR_4x4[..., 0:2, 2:4], (0, 2)),
+        (TENSOR_4x4[..., 1:3, 0:2], (1, 0)),
+        (TENSOR_4x4[..., 1:3, 1:3], (1, 1)),
+        (TENSOR_4x4[..., 1:3, 2:4], (1, 2)),
+        (TENSOR_4x4[..., 2:4, 0:2], (2, 0)),
+        (TENSOR_4x4[..., 2:4, 1:3], (2, 1)),
+        (TENSOR_4x4[..., 2:4, 2:4], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+# overlapping 3x3 (non-divisible)
+TEST_CASE_2_DEFAULT_DTYPE = [
+    dict(merged_shape=TENSOR_4x4.shape),
+    [
+        (TENSOR_4x4[..., :3, :3], (0, 0)),
+        (TENSOR_4x4[..., :3, 1:], (0, 1)),
+        (TENSOR_4x4[..., 1:, :3], (1, 0)),
+        (TENSOR_4x4[..., 1:, 1:], (1, 1)),
+    ],
+    TENSOR_4x4,
+]
+
+#  overlapping 2x2 with NaN values
+TEST_CASE_3_DEFAULT_DTYPE = [
+    dict(merged_shape=TENSOR_4x4_WITH_NAN.shape),
+    [
+        (TENSOR_4x4_WITH_NAN[..., 0:2, 0:2], (0, 0)),
+        (TENSOR_4x4_WITH_NAN[..., 0:2, 1:3], (0, 1)),
+        (TENSOR_4x4_WITH_NAN[..., 0:2, 2:4], (0, 2)),
+        (TENSOR_4x4_WITH_NAN[..., 1:3, 0:2], (1, 0)),
+        (TENSOR_4x4_WITH_NAN[..., 1:3, 1:3], (1, 1)),
+        (TENSOR_4x4_WITH_NAN[..., 1:3, 2:4], (1, 2)),
+        (TENSOR_4x4_WITH_NAN[..., 2:4, 0:2], (2, 0)),
+        (TENSOR_4x4_WITH_NAN[..., 2:4, 1:3], (2, 1)),
+        (TENSOR_4x4_WITH_NAN[..., 2:4, 2:4], (2, 2)),
+    ],
+    TENSOR_4x4_WITH_NAN,
+]
+
+# non-overlapping 2x2 with missing patch
+TEST_CASE_4_DEFAULT_DTYPE = [
+    dict(merged_shape=TENSOR_4x4.shape),
+    [(TENSOR_4x4[..., :2, :2], (0, 0)), (TENSOR_4x4[..., :2, 2:], (0, 2)), (TENSOR_4x4[..., 2:, :2], (2, 0))],
+    TENSOR_4x4_WITH_NAN,
+]
+
+# with value_dtype set to half precision
+TEST_CASE_5_VALUE_DTYPE = [
+    dict(merged_shape=TENSOR_4x4.shape, value_dtype=np.float16),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+# with count_dtype set to int32
+TEST_CASE_6_COUNT_DTYPE = [
+    dict(merged_shape=TENSOR_4x4.shape, count_dtype=np.int32),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+# with both value_dtype, count_dtype set to double precision
+TEST_CASE_7_COUNT_VALUE_DTYPE = [
+    dict(merged_shape=TENSOR_4x4.shape, value_dtype=np.float64, count_dtype=np.float64),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+# with both value_dtype, count_dtype set to double precision
+TEST_CASE_8_DTYPE = [
+    dict(merged_shape=TENSOR_4x4.shape, dtype=np.float64),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+# shape larger than what is covered by patches
+TEST_CASE_9_LARGER_SHAPE = [
+    dict(merged_shape=(2, 3, 4, 6)),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    pad(TENSOR_4x4, (0, 2), value=float("nan")),
+]
+
+# explicit directory store
+TEST_CASE_10_DIRECTORY_STORE = [
+    dict(merged_shape=TENSOR_4x4.shape, store=directory_store),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+# memory store for all arrays
+TEST_CASE_11_MEMORY_STORE = [
+    dict(
+        merged_shape=TENSOR_4x4.shape,
+        store=zarr.storage.MemoryStore(),
+        value_store=zarr.storage.MemoryStore(),
+        count_store=zarr.storage.MemoryStore(),
+    ),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+# explicit chunk size
+TEST_CASE_12_CHUNKS = [
+    dict(merged_shape=TENSOR_4x4.shape, chunks=(1, 1, 2, 2)),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+# test for LZ4 compressor
+TEST_CASE_13_COMPRESSOR_LZ4 = [
+    dict(merged_shape=TENSOR_4x4.shape, compressor="LZ4"),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+# test for pickle compressor
+TEST_CASE_14_COMPRESSOR_PICKLE = [
+    dict(merged_shape=TENSOR_4x4.shape, compressor="Pickle"),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+# test for LZMA compressor
+TEST_CASE_15_COMPRESSOR_LZMA = [
+    dict(merged_shape=TENSOR_4x4.shape, compressor="LZMA"),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+# test with thread locking
+TEST_CASE_16_WITH_LOCK = [
+    dict(merged_shape=TENSOR_4x4.shape, thread_locking=True),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+# test without thread locking
+TEST_CASE_17_WITHOUT_LOCK = [
+    dict(merged_shape=TENSOR_4x4.shape, thread_locking=False),
+    [
+        (TENSOR_4x4[..., :2, :2], (0, 0)),
+        (TENSOR_4x4[..., :2, 2:], (0, 2)),
+        (TENSOR_4x4[..., 2:, :2], (2, 0)),
+        (TENSOR_4x4[..., 2:, 2:], (2, 2)),
+    ],
+    TENSOR_4x4,
+]
+
+ALL_TESTS = [
+    TEST_CASE_0_DEFAULT_DTYPE,
+    TEST_CASE_1_DEFAULT_DTYPE,
+    TEST_CASE_2_DEFAULT_DTYPE,
+    TEST_CASE_3_DEFAULT_DTYPE,
+    TEST_CASE_4_DEFAULT_DTYPE,
+    TEST_CASE_5_VALUE_DTYPE,
+    TEST_CASE_6_COUNT_DTYPE,
+    TEST_CASE_7_COUNT_VALUE_DTYPE,
+    TEST_CASE_8_DTYPE,
+    TEST_CASE_9_LARGER_SHAPE,
+    TEST_CASE_10_DIRECTORY_STORE,
+    TEST_CASE_11_MEMORY_STORE,
+    TEST_CASE_12_CHUNKS,
+    TEST_CASE_16_WITH_LOCK,
+    TEST_CASE_17_WITHOUT_LOCK,
+]
+
+# add compression tests only when using Zarr version before 3.0
+if not version_geq(get_package_version("zarr"), "3.0.0"):
+    ALL_TESTS += [TEST_CASE_13_COMPRESSOR_LZ4, TEST_CASE_14_COMPRESSOR_PICKLE, TEST_CASE_15_COMPRESSOR_LZMA]
+
+
+@unittest.skipUnless(has_zarr and has_numcodecs, "Requires zarr (and numcodecs) packages.)")
+class ZarrAvgMergerTests(unittest.TestCase):
+
+    @parameterized.expand(ALL_TESTS)
+    def test_zarr_avg_merger_patches(self, arguments, patch_locations, expected):
+        codec_reg = numcodecs.registry.codec_registry
+        if "compressor" in arguments:
+            if arguments["compressor"] != "default":
+                arguments["compressor"] = codec_reg[arguments["compressor"].lower()]()
+        if "value_compressor" in arguments:
+            if arguments["value_compressor"] != "default":
+                arguments["value_compressor"] = codec_reg[arguments["value_compressor"].lower()]()
+        if "count_compressor" in arguments:
+            if arguments["count_compressor"] != "default":
+                arguments["count_compressor"] = codec_reg[arguments["count_compressor"].lower()]()
+        merger = ZarrAvgMerger(**arguments)
+        for pl in patch_locations:
+            merger.aggregate(pl[0], pl[1])
+        output = merger.finalize()
+        if "value_dtype" in arguments:
+            self.assertTrue(merger.get_values().dtype, arguments["value_dtype"])
+        if "count_dtype" in arguments:
+            self.assertTrue(merger.get_counts().dtype, arguments["count_dtype"])
+        # check for multiple call of finalize
+        self.assertIs(output, merger.finalize())
+        # check if the result is matching the expectation
+        assert_allclose(output[:], expected.numpy())
+
+    def test_zarr_avg_merger_finalized_error(self):
+        with self.assertRaises(ValueError):
+            merger = ZarrAvgMerger(merged_shape=(1, 3, 2, 3))
+            merger.finalize()
+            merger.aggregate(torch.zeros(1, 3, 2, 2), (3, 3))
+
+    def test_zarr_avg_merge_none_merged_shape_error(self):
+        with self.assertRaises(ValueError):
+            ZarrAvgMerger(merged_shape=None)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.