monai-weekly 1.7.dev2641__tar.gz → 1.7.dev2642__tar.gz

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monai-weekly
-Version: 1.7.dev2641
+Version: 1.7.dev2642
 Summary: AI Toolkit for Healthcare Imaging
 Author-email: MONAI Consortium <monai.contact@gmail.com>
 License: Apache License 2.0

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/__init__.py

@@ -136,4 +136,4 @@ except Exception:
 
     if MONAIEnvVars.debug():
         raise
-__commit_id__ = "eedf5fad1e1c802e8ade5736c8ecf071f9dca0b7"
+__commit_id__ = "8de81226c971dd27b5826d4bd60849d46aae9ff2"

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-10-11T02:25:27+0000",
+ "date": "2026-10-18T02:14:29+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "7bfe671ffaf469a0b2a44c800abe101d1f3447b4",
- "version": "1.7.dev2641"
+ "full-revisionid": "4835c649a66849125f1e656543264f5fa7d261c0",
+ "version": "1.7.dev2642"
 }
 '''  # END VERSION_JSON
 

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/apps/utils.py

@@ -30,6 +30,7 @@ from urllib.request import urlopen, urlretrieve
 
 from monai.config.type_definitions import PathLike
 from monai.utils import look_up_option, min_version, optional_import
+from monai.utils.deprecate_utils import warn_deprecated
 
 requests, has_requests = optional_import("requests")
 gdown, has_gdown = optional_import("gdown", "4.7.3")
@@ -177,6 +178,9 @@ def check_hash(filepath: PathLike, val: str | None = None, hash_type: str = "sha
             The supported hash types are `"md5"`, `"sha1"`, `"sha256"`, `"sha512"`.
             See also: :py:data:`monai.apps.utils.SUPPORTED_HASH_TYPES`.
 
+    .. versionchanged:: 1.7
+        The default `hash_type` changed from "md5" to "sha256" for stronger integrity verification.
+        Pass `hash_type="md5"` explicitly to verify against MD5 hashes.
     """
     if val is None:
         warnings.warn(f"No hash value provided for {filepath}; file integrity is NOT verified.", stacklevel=2)
@@ -204,7 +208,7 @@ def download_url(
     url: str,
     filepath: PathLike = "",
     hash_val: str | None = None,
-    hash_type: str = "sha256",
+    hash_type: str | None = None,
     progress: bool = True,
     **gdown_kwargs: Any,
 ) -> None:
@@ -217,7 +221,7 @@ def download_url(
             If undefined, `os.path.basename(url)` will be used.
         hash_val: expected hash value to validate the downloaded file.
             if None, skip hash validation.
-        hash_type: type of hash algorithm to use, default is `"sha256"`.
+        hash_type: type of hash algorithm to use, default is None which will select `"sha256"`.
             The supported hash types are `"md5"`, `"sha1"`, `"sha256"`, `"sha512"`.
         progress: whether to display a progress bar.
         gdown_kwargs: other args for `gdown` except for the `url`, `output` and `quiet`.
@@ -234,7 +238,23 @@ def download_url(
         ContentTooShortError: See urllib.request.urlretrieve.
         IOError: See urllib.request.urlretrieve.
         HashCheckError: When the hash validation of the ``url`` downloaded file fails.
+
+    .. versionchanged:: 1.7
+        The default `hash_type` changed from "md5" to None for stronger integrity verification. If this is left None
+        when a `hash_val` value is provided, this will warn to explicitly set `hash_type` then choose sha256 hashing.
+        Pass `hash_type="md5"` explicitly to verify against MD5 hashes and suppress the warning. In MONAI 1.8 the
+        default will be set to "sha256".
     """
+    if hash_val is not None and hash_type is None:
+        warn_deprecated(
+            "monai.apps.utils.download_url",
+            'Default `hash_type` value changed to `None` from "md5" in MONAI 1.7, '
+            "set to explicit value to suppress this warning. Defaulting to sha256 checking. In MONAI 1.8 the "
+            'default will be set to "sha256".',
+            stacklevel=3,
+        )
+        hash_type = "sha256"
+
     if not filepath:
         filepath = Path(".", _basename(url)).resolve()
         logger.info(f"Default downloading to '{filepath}'")
@@ -316,7 +336,7 @@ def extractall(
     filepath: PathLike,
     output_dir: PathLike = ".",
     hash_val: str | None = None,
-    hash_type: str = "sha256",
+    hash_type: str | None = None,
     file_type: str = "",
     has_base: bool = True,
 ) -> None:
@@ -329,7 +349,7 @@ def extractall(
         output_dir: target directory to save extracted files.
         hash_val: expected hash value to validate the compressed file.
             if None, skip hash validation.
-        hash_type: type of hash algorithm to use, default is `"sha256"`.
+        hash_type: type of hash algorithm to use, default is None which will select `"sha256"`.
         file_type: string of file type for decompressing. Leave it empty to infer the type from the filepath basename.
         has_base: whether the extracted files have a base folder. This flag is used when checking if the existing
             folder is a result of `extractall`, if it is, the extraction is skipped. For example, if A.zip is unzipped
@@ -340,7 +360,22 @@ def extractall(
         HashCheckError: When the hash validation of the ``filepath`` compressed file fails.
         NotImplementedError: When the ``filepath`` file extension is not one of [zip", "tar.gz", "tar"].
 
+    .. versionchanged:: 1.6.1
+        The default `hash_type` changed from "md5" to None for stronger integrity verification. If this is left None
+        when a `hash_val` value is provided, this will warn to explicitly set `hash_type` then choose sha256 hashing.
+        Pass `hash_type="md5"` explicitly to verify against MD5 hashes and suppress the warning. In MONAI 1.8 the
+        default will be set to "sha256".
     """
+    if hash_val is not None and hash_type is None:
+        warn_deprecated(
+            "monai.apps.utils.extractall",
+            'Default `hash_type` value changed to `None` from "md5" in MONAI 1.7, '
+            "set to an explicit value to suppress this warning. Defaulting to sha256 checking. In MONAI 1.8 the "
+            'default will be set to "sha256".',
+            stacklevel=3,
+        )
+        hash_type = "sha256"
+
     filepath = Path(filepath)
     if hash_val and not check_hash(filepath, hash_val, hash_type):
         raise HashCheckError(
@@ -395,7 +430,7 @@ def download_and_extract(
     filepath: PathLike = "",
     output_dir: PathLike = ".",
     hash_val: str | None = None,
-    hash_type: str = "sha256",
+    hash_type: str | None = None,
     file_type: str = "",
     has_base: bool = True,
     progress: bool = True,
@@ -411,7 +446,7 @@ def download_and_extract(
             default is the current directory.
         hash_val: expected hash value to validate the downloaded file.
             if None, skip hash validation.
-        hash_type: type of hash algorithm to use, default is `"sha256"`.
+        hash_type: type of hash algorithm to use, default is None which will select `"sha256"`.
         file_type: string of file type for decompressing. Leave it empty to infer the type from url's base file name.
         has_base: whether the extracted files have a base folder. This flag is used when checking if the existing
             folder is a result of `extractall`, if it is, the extraction is skipped. For example, if A.zip is unzipped

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/data/grid_dataset.py

@@ -257,6 +257,8 @@ class GridPatchDataset(IterableDataset):
             self.first_random = self.patch_transform.get_index_of_first(
                 lambda t: isinstance(t, RandomizableTrait) or not isinstance(t, Transform)
             )
+            if self.first_random is None:
+                self.first_random = len(self.patch_transform.transforms)
 
         if self.cache:
             if isinstance(data, Iterator):
@@ -279,7 +281,11 @@ class GridPatchDataset(IterableDataset):
         self.cache_num = min(int(self.set_num), int(len(mapping) * self.set_rate), len(mapping))
         self._hash_keys = list(mapping)[: self.cache_num]
         indices = list(mapping.values())[: self.cache_num]
-        self._cache, self._cache_other = zip(*self._fill_cache(indices))  # type: ignore
+        cache_items = self._fill_cache(indices)
+        if cache_items:
+            self._cache, self._cache_other = zip(*cache_items)  # type: ignore
+        else:
+            self._cache, self._cache_other = [], []
 
     def _fill_cache(self, indices=None) -> list:
         """
@@ -339,12 +345,9 @@ class GridPatchDataset(IterableDataset):
 
     def __iter__(self):
         if self.cache:
-            cache_index = None
             for image in super().__iter__():
                 key = self.hash_func(image)
-                if key in self._hash_keys:
-                    # if existing in cache, try to get the index in cache
-                    cache_index = self._hash_keys.index(key)
+                cache_index = self._hash_keys.index(key) if key in self._hash_keys else None
                 if cache_index is None:
                     # no cache for this index, execute all the transforms directly
                     yield from self._generate_patches(self.patch_iter(image))
@@ -354,11 +357,11 @@ class GridPatchDataset(IterableDataset):
                             "Cache buffer is not initialized, please call `set_data()` before epoch begins."
                         )
                     data = self._cache[cache_index]
-                    other = self._cache_other[cache_index]
 
                     # load data from cache and execute from the first random transform
                     data = deepcopy(data) if self.copy_cache else data
-                    yield from self._generate_patches(zip(data, other), start=self.first_random)
+                    cached_patches = zip(data, self._cache_other[cache_index]) if self.with_coordinates else zip(data)
+                    yield from self._generate_patches(cached_patches, start=self.first_random)
         else:
             for image in super().__iter__():
                 yield from self._generate_patches(self.patch_iter(image))

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/data/synthetic.py

@@ -28,7 +28,8 @@ def create_test_image_2d(
     num_seg_classes: int = 5,
     channel_dim: int | None = None,
     random_state: np.random.RandomState | None = None,
-) -> tuple[np.ndarray, np.ndarray]:
+    return_instance_id: bool = False,
+) -> tuple[np.ndarray, np.ndarray] | tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
     Return a noisy 2D image with `num_objs` circles and a 2D mask image. The maximum and minimum radii of the circles
     are given as `rad_max` and `rad_min`. The mask will have `num_seg_classes` number of classes for segmentations labeled
@@ -48,9 +49,13 @@ def create_test_image_2d(
         channel_dim: if None, create an image without channel dimension, otherwise create
             an image with channel dimension as first dim or last dim. Defaults to `None`.
         random_state: the random generator to use. Defaults to `np.random`.
+        return_instance_id: if True, also return an instance ID mask where every generated
+            object is assigned a unique positive integer. Later objects overwrite earlier IDs
+            where they overlap, so fully covered objects may not appear in the mask. Defaults to `False`.
 
     Returns:
-        Randomised Numpy array with shape (`height`, `width`)
+        A tuple of image and segmentation label arrays. If `return_instance_id=True`, also returns
+        an instance ID array as the third element.
     """
 
     if rad_max <= rad_min:
@@ -62,9 +67,10 @@ def create_test_image_2d(
         raise ValueError(f"the minimal size {min_size} of the image should be larger than `2 * rad_max` 2x{rad_max}.")
 
     image = np.zeros((height, width))
+    instance_ids = np.zeros((height, width), dtype=np.int32) if return_instance_id else None
     rs: np.random.RandomState = np.random.random.__self__ if random_state is None else random_state  # type: ignore
 
-    for _ in range(num_objs):
+    for obj_id in range(1, num_objs + 1):
         x = rs.randint(rad_max, height - rad_max)
         y = rs.randint(rad_max, width - rad_max)
         rad = rs.randint(rad_min, rad_max)
@@ -75,6 +81,8 @@ def create_test_image_2d(
             image[circle] = np.ceil(rs.random() * num_seg_classes)
         else:
             image[circle] = rs.random() * 0.5 + 0.5
+        if instance_ids is not None:
+            instance_ids[circle] = obj_id
 
     labels = np.ceil(image).astype(np.int32, copy=False)
 
@@ -87,10 +95,16 @@ def create_test_image_2d(
         if channel_dim == 0:
             noisyimage = noisyimage[None]
             labels = labels[None]
+            if instance_ids is not None:
+                instance_ids = instance_ids[None]
         else:
             noisyimage = noisyimage[..., None]
             labels = labels[..., None]
+            if instance_ids is not None:
+                instance_ids = instance_ids[..., None]
 
+    if instance_ids is not None:
+        return noisyimage, labels, instance_ids
     return noisyimage, labels
 
 
@@ -105,7 +119,8 @@ def create_test_image_3d(
     num_seg_classes: int = 5,
     channel_dim: int | None = None,
     random_state: np.random.RandomState | None = None,
-) -> tuple[np.ndarray, np.ndarray]:
+    return_instance_id: bool = False,
+) -> tuple[np.ndarray, np.ndarray] | tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
     Return a noisy 3D image and segmentation.
 
@@ -122,9 +137,13 @@ def create_test_image_3d(
         channel_dim: if None, create an image without channel dimension, otherwise create
             an image with channel dimension as first dim or last dim. Defaults to `None`.
         random_state: the random generator to use. Defaults to `np.random`.
+        return_instance_id: if True, also return an instance ID mask where every generated
+            object is assigned a unique positive integer. Later objects overwrite earlier IDs
+            where they overlap, so fully covered objects may not appear in the mask. Defaults to `False`.
 
     Returns:
-        Randomised Numpy array with shape (`height`, `width`, `depth`)
+        A tuple of image and segmentation label arrays. If `return_instance_id=True`, also returns
+        an instance ID array as the third element.
 
     See also:
         :py:meth:`~create_test_image_2d`
@@ -139,9 +158,10 @@ def create_test_image_3d(
         raise ValueError(f"the minimal size {min_size} of the image should be larger than `2 * rad_max` 2x{rad_max}.")
 
     image = np.zeros((height, width, depth))
+    instance_ids = np.zeros((height, width, depth), dtype=np.int32) if return_instance_id else None
     rs: np.random.RandomState = np.random.random.__self__ if random_state is None else random_state  # type: ignore
 
-    for _ in range(num_objs):
+    for obj_id in range(1, num_objs + 1):
         x = rs.randint(rad_max, height - rad_max)
         y = rs.randint(rad_max, width - rad_max)
         z = rs.randint(rad_max, depth - rad_max)
@@ -153,6 +173,8 @@ def create_test_image_3d(
             image[circle] = np.ceil(rs.random() * num_seg_classes)
         else:
             image[circle] = rs.random() * 0.5 + 0.5
+        if instance_ids is not None:
+            instance_ids[circle] = obj_id
 
     labels = np.ceil(image).astype(np.int32, copy=False)
 
@@ -162,8 +184,17 @@ def create_test_image_3d(
     if channel_dim is not None:
         if not (isinstance(channel_dim, int) and channel_dim in (-1, 0, 3)):
             raise AssertionError("invalid channel dim.")
-        noisyimage, labels = (
-            (noisyimage[None], labels[None]) if channel_dim == 0 else (noisyimage[..., None], labels[..., None])
-        )
+        if channel_dim == 0:
+            noisyimage = noisyimage[None]
+            labels = labels[None]
+            if instance_ids is not None:
+                instance_ids = instance_ids[None]
+        else:
+            noisyimage = noisyimage[..., None]
+            labels = labels[..., None]
+            if instance_ids is not None:
+                instance_ids = instance_ids[..., None]
 
+    if instance_ids is not None:
+        return noisyimage, labels, instance_ids
     return noisyimage, labels

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/inferers/merger.py

@@ -307,7 +307,13 @@ class ZarrAvgMerger(Merger):
             self.value_store = zarr.storage.TempStore() if value_store is None else value_store  # type: ignore
             self.count_store = zarr.storage.TempStore() if count_store is None else count_store  # type: ignore
 
-        self.chunks = chunks
+        # zarr 3.3 rejects boolean chunk arguments; `None` there means auto-chunking,
+        # which is what `chunks=True` meant before. On zarr < 3.3 `None` instead means
+        # a single whole-shape chunk, so the substitution must not be applied there.
+        if chunks is True and version_geq(get_package_version("zarr"), "3.3.0"):
+            self.chunks: Sequence[int] | bool | None = None
+        else:
+            self.chunks = chunks
 
         # Initialize codecs/compressor attributes with proper types
         self.codecs: list | None = None

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/metrics/embedding_collapse.py

@@ -51,8 +51,10 @@ class EmbeddingCollapseMetric(Metric):
     Args:
         reduction: how to aggregate individual scores into ``aggregate``.
             ``"max"`` returns the worst-case score (recommended for
-            safety-critical use). ``"mean"`` returns the average of
-            available scores. ``"none"`` omits the ``aggregate`` key.
+            safety-critical use), including the most collapsed class.
+            ``"mean"`` returns the average of available scores, where all
+            per-class scores contribute a single term. ``"none"`` omits the
+            ``aggregate`` key.
         include_indicators: optional list of indicator names to compute.
             If ``None``, all applicable indicators are computed.
             Valid names: ``"centroid_similarity"``, ``"effective_rank"``,
@@ -162,7 +164,8 @@ def compute_embedding_collapse(
           ``None`` if ``target_embeddings`` not provided.
         - ``separation``: silhouette-based inter-class separation score.
           ``None`` if sklearn unavailable or fewer than 2 classes.
-        - ``aggregate``: reduced score. Omitted when ``reduction="none"``.
+        - ``aggregate``: reduced over the global indicators plus the worst
+          ``per_class_rank_<cls>``. Omitted when ``reduction="none"``.
 
     Raises:
         ValueError: if inputs are invalid (shape, reduction, indicators).
@@ -180,6 +183,7 @@ def compute_embedding_collapse(
 
     inc = set(include_indicators) if include_indicators is not None else None
     scores: dict[str, torch.Tensor | None] = {}
+    per_class_scores: dict[str, torch.Tensor | None] = {}
 
     # -- Label-dependent indicators
     if labels is not None:
@@ -191,7 +195,8 @@ def compute_embedding_collapse(
             scores["centroid_similarity"] = _centroid_similarity(emb, lbl)
 
         if inc is None or "per_class_rank" in inc:
-            scores.update(_per_class_rank(emb, lbl))
+            per_class_scores = _per_class_rank(emb, lbl)
+            scores.update(per_class_scores)
 
         if inc is None or "separation" in inc:
             scores["separation"] = _separation(emb, lbl)
@@ -218,6 +223,11 @@ def compute_embedding_collapse(
     if reduction != "none":
         primary = {"centroid_similarity", "effective_rank_score", "domain_shift", "separation"}
         available = [v.to(device=emb.device) for k, v in scores.items() if k in primary and v is not None]
+        # Per-class collapse is reduced to its worst class before joining the pool, so that
+        # `mean` keeps one vote per indicator regardless of how many classes are present.
+        by_class = [v.to(device=emb.device) for v in per_class_scores.values() if v is not None]
+        if by_class:
+            available.append(torch.stack(by_class).max())
         if not available:
             scores["aggregate"] = None
         elif reduction == "max":

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/metrics/fid.py

@@ -82,7 +82,7 @@ def _cov(input_data: torch.Tensor, rowvar: bool = True) -> torch.Tensor:
 
 def _sqrtm(input_data: torch.Tensor) -> torch.Tensor:
     """Compute the square root of a matrix."""
-    scipy_res, _ = scipy.linalg.sqrtm(input_data.detach().cpu().numpy().astype(np.float64), disp=False)
+    scipy_res = scipy.linalg.sqrtm(input_data.detach().cpu().numpy().astype(np.float64))
     return torch.from_numpy(scipy_res)
 
 

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/metrics/meaniou.py

@@ -152,16 +152,10 @@ def compute_iou(
     if y.shape != y_pred.shape:
         raise ValueError(f"y_pred and y should have same shapes, got {y_pred.shape} and {y.shape}.")
 
-    if ignore_index is not None and 0 <= ignore_index < (y_pred.shape[1] + (0 if include_background else 1)):
-        ignore_channel = ignore_index if include_background else ignore_index - 1
-        if 0 <= ignore_channel < y_pred.shape[1]:
-            y_pred = y_pred.clone()
-            y = y.clone()
-            y_pred[:, ignore_channel] = 0
-            y[:, ignore_channel] = 0
-        mask = None
-    else:
-        mask = create_ignore_mask(original_y if ignore_index is not None else y, ignore_index)
+    # Use the same spatial masking as DiceHelper so both metrics exclude the
+    # same voxels: zeroing the ignored channel alone would leave voxels of the
+    # ignored class counting as false positives for the other classes
+    mask = create_ignore_mask(original_y, ignore_index)
     if mask is not None:
         if mask.shape != y_pred.shape:
             mask = mask.expand_as(y_pred)

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/networks/nets/dints.py

@@ -350,7 +350,7 @@ class DiNTS(nn.Module):
         use_downsample: use downsample in the stem.
             If ``False``, the search space will be in resolution [1, 1/2, 1/4, 1/8],
             if ``True``, the search space will be in resolution [1/2, 1/4, 1/8, 1/16].
-        node_a: node activation numpy matrix. Its shape is `(num_depths, num_blocks + 1)`.
+        node_a: node activation matrix (numpy array or tensor). Its shape is `(num_blocks + 1, num_depths)`.
             +1 for multi-resolution inputs.
             In model searching stage, ``node_a`` can be None. In deployment stage, ``node_a`` cannot be None.
     """
@@ -544,8 +544,8 @@ class TopologyConstruction(nn.Module):
     The base class for `TopologyInstance` and `TopologySearch`.
 
     Args:
-        arch_code: `[arch_code_a, arch_code_c]`, numpy arrays or torch tensors. The architecture codes defining
-            the model.
+        arch_code: `[arch_code_a, arch_code_c]`, numpy arrays, torch tensors or nested lists (anything
+            accepted by ``torch.as_tensor``). The architecture codes defining the model.
             For example, for a ``num_depths=4, num_blocks=12`` search space:
 
             - `arch_code_a` is a 12x10 (10 paths) binary matrix representing if a path is activated.
@@ -631,8 +631,12 @@ class TopologyConstruction(nn.Module):
             arch_code_a = torch.ones((self.num_blocks, len(self.arch_code2out))).to(self.device)
             arch_code_c = torch.ones((self.num_blocks, len(self.arch_code2out), self.num_cell_ops)).to(self.device)
         else:
-            arch_code_a = torch.as_tensor(arch_code[0]).to(self.device)
-            arch_code_c = F.one_hot(torch.as_tensor(arch_code[1]).to(torch.int64), self.num_cell_ops).to(self.device)
+            # accept numpy arrays (legacy search checkpoints), torch tensors (checkpoints that are
+            # loadable with ``torch.load(weights_only=True)``) or nested lists (JSON/YAML configs)
+            arch_code_a = torch.as_tensor(arch_code[0], device=self.device)
+            arch_code_c = F.one_hot(
+                torch.as_tensor(arch_code[1], device=self.device).to(torch.int64), self.num_cell_ops
+            )
 
         self.arch_code_a = arch_code_a
         self.arch_code_c = arch_code_c

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/networks/nets/regunet.py

@@ -294,8 +294,19 @@ class AffineHead(nn.Module):
         return grid_warped
 
     def forward(self, x: list[torch.Tensor], image_size: list[int]) -> torch.Tensor:
+        """
+        Predict an affine transform from the first feature map and return it as a displacement field.
+
+        Args:
+            x: feature maps from the network; only the first, ``x[0]``, is used. The reference grid is moved to its
+                device and dtype, so a network cast to half precision stays in half precision.
+            image_size: spatial size of the input image; not used by this head.
+
+        Returns:
+            The displacement field, the warped reference grid minus the reference grid.
+        """
         f = x[0]
-        self.grid = self.grid.to(device=f.device)
+        self.grid = self.grid.to(device=f.device, dtype=f.dtype)
         theta = self.fc(f.reshape(f.shape[0], -1))
         if self.save_theta:
             self.theta = theta.detach()

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/transforms/__init__.py

@@ -298,6 +298,7 @@ from .post.array import (
     KeepLargestConnectedComponent,
     LabelFilter,
     LabelToContour,
+    MarchingCubes,
     MeanEnsemble,
     ProbNMS,
     RemoveSmallObjects,
@@ -335,6 +336,9 @@ from .post.dictionary import (
     LabelToContourD,
     LabelToContourd,
     LabelToContourDict,
+    MarchingCubesD,
+    MarchingCubesd,
+    MarchingCubesDict,
     MeanEnsembleD,
     MeanEnsembled,
     MeanEnsembleDict,

{monai_weekly-1.7.dev2641 → monai_weekly-1.7.dev2642}/monai/transforms/post/array.py

@@ -34,6 +34,7 @@ from monai.transforms.utils import (
     distance_transform_edt,
     fill_holes,
     get_largest_connected_component_mask,
+    get_marching_cubes_surface,
     get_unique_labels,
     remove_small_objects,
 )
@@ -63,6 +64,7 @@ __all__ = [
     "Invert",
     "GenerateHeatmap",
     "DistanceTransformEDT",
+    "MarchingCubes",
 ]
 
 
@@ -644,7 +646,6 @@ class LabelToContour(Transform):
 
 
 class Ensemble:
-
     @staticmethod
     def get_stacked_torch(img: Sequence[NdarrayOrTensor] | NdarrayOrTensor) -> torch.Tensor:
         """Get either a sequence or single instance of np.ndarray/torch.Tensor. Return single torch.Tensor."""
@@ -1187,3 +1188,90 @@ class DistanceTransformEDT(Transform):
             An array with the same shape and data type as img
         """
         return distance_transform_edt(img=img, sampling=self.sampling)  # type: ignore
+
+
+class MarchingCubes(Transform):
+    """
+    Extract a surface mesh from a 3D segmentation using marching cubes.
+
+    Thin wrapper around :func:`monai.transforms.utils.get_marching_cubes_surface`
+    (`skimage.measure.marching_cubes`). The input is a channel-first volume with
+    shape ``(C, M, N, P)``; marching cubes runs per channel on the CPU (scikit-image
+    has no GPU kernel, CUDA inputs are moved to CPU first).
+
+    Note:
+        The output is a mesh, not an image, so it cannot be composed with further
+        image transforms or inverted. Place it at the end of the pipeline.
+        For STL export, smoothing, or physical-space
+        mapping see ``monai.deploy`` ``STLConversionOperator``.
+
+    Args:
+        level: isosurface value, defaults to 0.5 for binary masks.
+        spacing: voxel spacing along each spatial dim. A single number is used for
+            all axes. If ``None`` and the input is a MetaTensor, its pixdim is used,
+            otherwise unity spacing is assumed.
+        step_size: step size in voxels for marching cubes. Larger steps are faster
+            but yield coarser meshes.
+        allow_degenerate: allow degenerate triangles in the mesh.
+        method: one of ("lewiner", "lorensen"), see scikit-image docs.
+        return_normals_values: if ``True``, also return vertex normals and values,
+            i.e. ``(verts, faces, normals, values)`` matching scikit-image output.
+            Defaults to ``False`` (``(verts, faces)`` only).
+
+    Example:
+        >>> import numpy as np
+        >>> from monai.transforms import MarchingCubes
+        >>> vol = np.zeros((1, 10, 10, 10), np.float32); vol[0, 3:7, 3:7, 3:7] = 1.0
+        >>> verts, faces = MarchingCubes(level=0.5)(vol)
+        >>> verts.shape[1], faces.shape[1]
+        (3, 3)
+    """
+
+    backend = [TransformBackends.NUMPY, TransformBackends.TORCH]
+
+    def __init__(
+        self,
+        level: float | None = 0.5,
+        spacing: Sequence[float] | float | None = None,
+        step_size: int = 1,
+        allow_degenerate: bool = True,
+        method: str = "lewiner",
+        return_normals_values: bool = False,
+    ) -> None:
+        super().__init__()
+        self.level = level
+        self.spacing = spacing
+        self.step_size = step_size
+        self.allow_degenerate = allow_degenerate
+        self.method = method
+        self.return_normals_values = return_normals_values
+
+    def __call__(self, img: NdarrayOrTensor):
+        """
+        Args:
+            img: channel-first volume with shape (C, M, N, P).
+
+        Returns:
+            ``(vertices, faces)`` tuple for single-channel input, or a list of one
+            such tuple per channel for multi-channel input. Items have shapes ``(V, 3)``
+            and ``(F, 3)`` and match the input type: numpy arrays for array input, plain
+            ``torch.Tensor`` on the input device for tensor input. With ``return_normals_values=True`` each item
+            is ``(verts, faces, normals, values)`` instead.
+
+        Raises:
+            ValueError: when ``img`` is not a channel-first 3D volume or has no channels.
+        """
+        if img.ndim != 4 or img.shape[0] == 0:
+            raise ValueError(f"MarchingCubes requires a channel-first 3D volume (C, M, N, P), got shape {img.shape}.")
+        results = []
+        for c in range(img.shape[0]):
+            verts, faces, normals, values = get_marching_cubes_surface(
+                img[c],
+                level=self.level,
+                spacing=self.spacing,
+                step_size=self.step_size,
+                allow_degenerate=self.allow_degenerate,
+                method=self.method,
+            )
+            results.append((verts, faces, normals, values) if self.return_normals_values else (verts, faces))
+        return results[0] if len(results) == 1 else results