seqseg 2.1.4__tar.gz → 2.1.6__tar.gz

{seqseg-2.1.4 → seqseg-2.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqseg
-Version: 2.1.4
+Version: 2.1.6
 Summary: A deep learning-based medical image blood vessel tracking and segmentation tool.
 Author-email: Numi Sveinsson Cepero <numi@berkeley.com>
 License: Apache-2.0
@@ -84,7 +84,7 @@ SeqSeg **2.0** refactors the package around a clearer CLI and a stable Python AP
 | **`seqseg run plus batch`** | Global nnU-Net sweep, then SeqSeg (replaces monolithic `seqseg_plus` script flow) |
 | **`seqseg init dataset`** | Scaffold `images/`, `centerlines/`, `truths/`, and template `seeds.json` |
 | **`seqseg paths init` / `set` / `show`** | Save default nnU-Net / data / out dirs in `~/.seqseg/paths.yaml` |
-| **`seqseg train prepare`** | Extract patches + build nnU-Net Dataset (needs `pip install "seqseg[train]"`) |
+| **`seqseg train prepare`** | Extract patches or whole volumes + build nnU-Net Dataset (needs `pip install "seqseg[train]"`) |
 | **`seqseg train nnunet`** | Run nnU-Net plan/preprocess and training |
 | **`seqseg doctor`** | Check imports (SimpleITK, vtk, nnunetv2, scipy, optional sampler) and paths |
 | **`seqseg config dump` / `fingerprint`** | Inspect or diff packaged YAML configs |

{seqseg-2.1.4 → seqseg-2.1.6}/README.md

@@ -51,7 +51,7 @@ SeqSeg **2.0** refactors the package around a clearer CLI and a stable Python AP
 | **`seqseg run plus batch`** | Global nnU-Net sweep, then SeqSeg (replaces monolithic `seqseg_plus` script flow) |
 | **`seqseg init dataset`** | Scaffold `images/`, `centerlines/`, `truths/`, and template `seeds.json` |
 | **`seqseg paths init` / `set` / `show`** | Save default nnU-Net / data / out dirs in `~/.seqseg/paths.yaml` |
-| **`seqseg train prepare`** | Extract patches + build nnU-Net Dataset (needs `pip install "seqseg[train]"`) |
+| **`seqseg train prepare`** | Extract patches or whole volumes + build nnU-Net Dataset (needs `pip install "seqseg[train]"`) |
 | **`seqseg train nnunet`** | Run nnU-Net plan/preprocess and training |
 | **`seqseg doctor`** | Check imports (SimpleITK, vtk, nnunetv2, scipy, optional sampler) and paths |
 | **`seqseg config dump` / `fingerprint`** | Inspect or diff packaged YAML configs |

{seqseg-2.1.4 → seqseg-2.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seqseg"
-version = "2.1.4"
+version = "2.1.6"
 description = "A deep learning-based medical image blood vessel tracking and segmentation tool."
 readme = "README.md"
 requires-python = ">=3.9"

{seqseg-2.1.4 → seqseg-2.1.6}/seqseg/cli.py

@@ -672,6 +672,7 @@ def _cmd_train_prepare(ns: argparse.Namespace) -> None:
             yes=ns.yes,
             verbose=ns.verbose,
             img_ext=ns.img_ext,
+            global_volumes=ns.global_volumes,
         )
     except TrainDependencyError as e:
         print(str(e), file=sys.stderr)
@@ -692,7 +693,8 @@ def _cmd_train_prepare(ns: argparse.Namespace) -> None:
         sys.exit(1)
 
     print("\nPrepare complete.")
-    print(f"  Patches: {result.extracted_dir}")
+    kind = "Whole volumes" if ns.global_volumes else "Patches"
+    print(f"  {kind}: {result.extracted_dir}")
     for name, path in zip(result.dataset_names, result.dataset_dirs):
         try:
             ds_id = dataset_id_from_name(name)
@@ -990,13 +992,13 @@ def _build_parser() -> argparse.ArgumentParser:
 
     train_p = sub.add_parser(
         "train",
-        help="Prepare patch datasets and train nnU-Net models for SeqSeg",
+        help="Prepare patch or whole-volume datasets and train nnU-Net models",
     )
     train_sub = train_p.add_subparsers(dest="train_cmd", required=True)
 
     p_prep = train_sub.add_parser(
         "prepare",
-        help="Extract vascular patches and convert to nnU-Net DatasetXXX format",
+        help="Prepare patches or whole volumes and convert to nnU-Net DatasetXXX format",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
     p_prep.add_argument(
@@ -1012,7 +1014,7 @@ def _build_parser() -> argparse.ArgumentParser:
         "-outdir",
         default=None,
         type=str,
-        help="Directory for extracted patches "
+        help="Directory for extracted patches or whole volumes "
         "(default: seqseg paths outdir, else ./extracted_data/)",
     )
     p_prep.add_argument(
@@ -1078,15 +1080,21 @@ def _build_parser() -> argparse.ArgumentParser:
         default=None,
     )
     p_prep.add_argument("--truth-regenerate", action="store_true")
+    p_prep.add_argument(
+        "--global-volumes",
+        "--whole-volumes",
+        action="store_true",
+        help="Copy each case's full image and label instead of sampling patches",
+    )
     p_prep.add_argument(
         "--skip-sample",
         action="store_true",
-        help="Only convert existing patches in --outdir",
+        help="Only convert existing volumes in --outdir",
     )
     p_prep.add_argument(
         "--skip-convert",
         action="store_true",
-        help="Only extract patches; skip nnU-Net Dataset conversion",
+        help="Only write volumes; skip nnU-Net Dataset conversion",
     )
     p_prep.add_argument(
         "--also-test",

{seqseg-2.1.4 → seqseg-2.1.6}/seqseg/modules/sitk_functions.py

@@ -55,10 +55,10 @@ def copy_settings(img, ref_img):
     return img
 
 
-# Refuse pathological upsampling (e.g. CENT_MAX_SPACING in mm applied with
-# ``-unit cm``) before SimpleITK tries to allocate a multi-billion-voxel grid
-# and the process is SIGKILL'd (exit 137) on CI runners.
-DEFAULT_MAX_RESAMPLE_VOXELS = 200_000_000
+# Cap assembly upsampling (e.g. CENT_MAX_SPACING in mm applied with ``-unit cm``)
+# before SimpleITK tries to allocate a multi-billion-voxel grid and the process
+# is SIGKILL'd (exit 137). 500M float32 voxels is ~2 GB for one volume.
+DEFAULT_MAX_RESAMPLE_VOXELS = 500_000_000
 
 
 def resampled_grid_size(orig_size, orig_spacing, new_spacing):
@@ -74,6 +74,64 @@ def resampled_grid_size(orig_size, orig_spacing, new_spacing):
     )
 
 
+def fit_spacing_to_max_voxels(
+    orig_size,
+    orig_spacing,
+    target_spacing,
+    max_voxels=DEFAULT_MAX_RESAMPLE_VOXELS,
+):
+    """
+    Coarsen ``target_spacing`` so the resampled grid has at most ``max_voxels``.
+
+    Axes that are already at ``orig_spacing`` are left unchanged. Remaining
+    (finer) axes are scaled uniformly. Never coarsens past ``orig_spacing``.
+
+    Returns
+    -------
+    list[float] | None
+        Spacing to resample to, or ``None`` if no axis can be refined without
+        exceeding ``max_voxels`` (caller should skip resampling).
+    """
+    if max_voxels is None:
+        return [float(s) for s in target_spacing]
+
+    orig_size = np.asarray(orig_size, dtype=np.float64).reshape(3)
+    orig_spacing = np.asarray(orig_spacing, dtype=np.float64).reshape(3)
+    target = np.asarray(target_spacing, dtype=np.float64).reshape(3)
+    max_voxels = int(max_voxels)
+    if max_voxels <= 0:
+        raise ValueError("max_voxels must be > 0")
+
+    def n_vox_for(spacing):
+        return int(np.prod(resampled_grid_size(orig_size, orig_spacing, spacing)))
+
+    n_vox = n_vox_for(target)
+    if n_vox <= max_voxels:
+        return target.tolist()
+
+    for _ in range(32):
+        finer = target < orig_spacing * (1.0 - 1e-12)
+        n_fine = int(np.count_nonzero(finer))
+        if n_fine == 0:
+            return None
+        k = (n_vox / float(max_voxels)) ** (1.0 / n_fine)
+        new_target = target.copy()
+        new_target[finer] = np.minimum(orig_spacing[finer], target[finer] * k)
+        if np.allclose(new_target, target):
+            new_target[finer] = np.minimum(
+                orig_spacing[finer], target[finer] * 1.001
+            )
+            if np.allclose(new_target, target):
+                return None
+        target = new_target
+        n_vox = n_vox_for(target)
+        if n_vox <= max_voxels:
+            if not np.any(target < orig_spacing):
+                return None
+            return target.tolist()
+    return None
+
+
 def resample_to_spacing(image, new_spacing, is_label=False,
                         max_voxels=DEFAULT_MAX_RESAMPLE_VOXELS):
     """

{seqseg-2.1.4 → seqseg-2.1.6}/seqseg/pipeline/classic.py

@@ -175,17 +175,38 @@ def run_classic_batch(
                 assembly.GetSpacing(), cent_max_spacing, unit
             )
             if target_spacing is not None:
-                print(
-                    f"Resampling final assembly to spacing <= "
-                    f"{float(cent_max_spacing)} mm: {target_spacing}"
+                fitted = sf.fit_spacing_to_max_voxels(
+                    assembly.GetSize(),
+                    assembly.GetSpacing(),
+                    target_spacing,
                 )
-                assembly = sf.resample_to_spacing(
-                    assembly, target_spacing, is_label=False
-                )
-                if write_samples:
-                    n_udpates = sf.resample_to_spacing(
-                        n_udpates, target_spacing, is_label=True
+                if fitted is None:
+                    print(
+                        "Skipping assembly upsample: even a coarsened grid "
+                        f"would exceed {sf.DEFAULT_MAX_RESAMPLE_VOXELS:,} voxels"
+                    )
+                else:
+                    if any(
+                        abs(a - b) > 1e-12
+                        for a, b in zip(fitted, target_spacing)
+                    ):
+                        print(
+                            "Relaxed assembly spacing from "
+                            f"{target_spacing} to {fitted} to stay <= "
+                            f"{sf.DEFAULT_MAX_RESAMPLE_VOXELS:,} voxels"
+                        )
+                    target_spacing = fitted
+                    print(
+                        f"Resampling final assembly to spacing <= "
+                        f"{float(cent_max_spacing)} mm: {target_spacing}"
+                    )
+                    assembly = sf.resample_to_spacing(
+                        assembly, target_spacing, is_label=False
                     )
+                    if write_samples:
+                        n_udpates = sf.resample_to_spacing(
+                            n_udpates, target_spacing, is_label=True
+                        )
 
         assembly_binary = sitk.BinaryThreshold(
             assembly,

{seqseg-2.1.4 → seqseg-2.1.6}/seqseg/pipeline/plus.py

@@ -206,13 +206,34 @@ def run_plus_batch(
                 assembly.GetSpacing(), cent_max_spacing, unit
             )
             if target_spacing is not None:
-                print(
-                    f"Resampling final assembly to spacing <= "
-                    f"{float(cent_max_spacing)} mm: {target_spacing}"
-                )
-                assembly = sf.resample_to_spacing(
-                    assembly, target_spacing, is_label=False
+                fitted = sf.fit_spacing_to_max_voxels(
+                    assembly.GetSize(),
+                    assembly.GetSpacing(),
+                    target_spacing,
                 )
+                if fitted is None:
+                    print(
+                        "Skipping assembly upsample: even a coarsened grid "
+                        f"would exceed {sf.DEFAULT_MAX_RESAMPLE_VOXELS:,} voxels"
+                    )
+                else:
+                    if any(
+                        abs(a - b) > 1e-12
+                        for a, b in zip(fitted, target_spacing)
+                    ):
+                        print(
+                            "Relaxed assembly spacing from "
+                            f"{target_spacing} to {fitted} to stay <= "
+                            f"{sf.DEFAULT_MAX_RESAMPLE_VOXELS:,} voxels"
+                        )
+                    target_spacing = fitted
+                    print(
+                        f"Resampling final assembly to spacing <= "
+                        f"{float(cent_max_spacing)} mm: {target_spacing}"
+                    )
+                    assembly = sf.resample_to_spacing(
+                        assembly, target_spacing, is_label=False
+                    )
 
         assembly_binary = sitk.BinaryThreshold(
             assembly,

{seqseg-2.1.4 → seqseg-2.1.6}/seqseg/pipeline/train.py

@@ -8,7 +8,9 @@ import subprocess
 from contextlib import contextmanager
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Iterator, List, Optional, Sequence, Union
+from typing import Any, Callable, Iterator, List, Optional, Sequence, Union
+
+import numpy as np
 
 from seqseg.user_paths import apply_nnunet_env, ensure_nnunet_dirs, resolve_path
 
@@ -35,12 +37,99 @@ def _require_sampler():
     return extract_patches, write_nnunet_dataset
 
 
+def _require_gather_global_volumes():
+    try:
+        from vascular_segment_sampler.sampling import gather_global_volumes
+    except ImportError as e:
+        raise TrainDependencyError(
+            "Whole-volume dataset construction requires gather_global_volumes "
+            "from a recent vascular-segment-sampler.\n"
+            "Upgrade with:\n"
+            '  pip install -U "seqseg[train]"\n'
+            "or:\n"
+            "  pip install -U vascular-segment-sampler"
+        ) from e
+    return gather_global_volumes
+
+
+def _reduction_or_nan(arr: Any, fn: Callable[[Any], Any]) -> float:
+    """``np.amin``/``mean`` on an empty crop raise; treat that as missing."""
+    arr = np.asarray(arr)
+    if arr.size == 0:
+        return float("nan")
+    return float(fn(arr))
+
+
+def _point_list(location: Any) -> list:
+    if hasattr(location, "tolist"):
+        return location.tolist()
+    return list(location)
+
+
+def _safe_add_image_stats(stats: dict, im_np: Any) -> dict:
+    stats.update(
+        {
+            "IM_MEAN": _reduction_or_nan(im_np, np.mean),
+            "IM_MIN": _reduction_or_nan(im_np, np.amin),
+            "IM_STD": _reduction_or_nan(im_np, np.std),
+            "IM_MAX": _reduction_or_nan(im_np, np.amax),
+        }
+    )
+    return stats
+
+
+def _safe_add_local_stats(
+    stats: dict,
+    location: Any,
+    diff_cent: Any,
+    blood_np: Any,
+    ground_truth: Any,
+    means: Sequence,
+    removed_seg: Any,
+    im_np: Any,
+    O: int,
+) -> tuple[dict, int]:
+    """Same stats as the sampler, but empty labeled crops become NaN not errors."""
+    stats.update(
+        {
+            "DIFF_CENT": diff_cent,
+            "POINT_CENT": _point_list(location),
+            "BLOOD_MEAN": _reduction_or_nan(blood_np, np.mean),
+            "BLOOD_MIN": _reduction_or_nan(blood_np, np.amin),
+            "BLOOD_STD": _reduction_or_nan(blood_np, np.std),
+            "BLOOD_MAX": _reduction_or_nan(blood_np, np.amax),
+            "GT_MEAN": _reduction_or_nan(ground_truth, np.mean),
+            "GT_STD": _reduction_or_nan(ground_truth, np.std),
+            "GT_MAX": _reduction_or_nan(ground_truth, np.amax),
+            "GT_MIN": _reduction_or_nan(ground_truth, np.amin),
+        }
+    )
+    if len(means) != 1:
+        import SimpleITK as sitk
+
+        larg_np = sitk.GetArrayFromImage(removed_seg)
+        rem_np = np.asarray(im_np)[np.asarray(larg_np) > 0.1]
+        stats.update(
+            {
+                "LARGEST_MEAN": _reduction_or_nan(rem_np, np.mean),
+                "LARGEST_STD": _reduction_or_nan(rem_np, np.std),
+                "LARGEST_MAX": _reduction_or_nan(rem_np, np.amax),
+                "LARGEST_MIN": _reduction_or_nan(rem_np, np.amin),
+            }
+        )
+        O += 1
+    return stats, O
+
+
 def _harden_sampler_vtk() -> None:
-    """Skip non-numeric VTK arrays the sampler used to pass to vtk_to_numpy.
+    """Patch sampler helpers that break on common SeqSeg datasets.
 
     Centerline .vtp files from SimVascular/Slicer often include string/abstract
     arrays. ``GetArray(i)`` is None for those, which became
     ``'NoneType' object has no attribute 'GetDataType'``.
+
+    Crops with no labeled voxels used to raise
+    ``zero-size array to reduction operation minimum`` in ``add_local_stats``.
     """
     try:
         import vascular_segment_sampler.sampling.extract as extract_mod
@@ -57,6 +146,13 @@ def _harden_sampler_vtk() -> None:
     samp_fn.collect_arrays = collect_arrays
     vf.convertPolyDataToImageData = convertPolyDataToImageData
 
+    if not getattr(samp_fn.add_local_stats, "_seqseg_hardened", False):
+        _safe_add_local_stats._seqseg_hardened = True  # type: ignore[attr-defined]
+        samp_fn.add_local_stats = _safe_add_local_stats
+    if not getattr(samp_fn.add_image_stats, "_seqseg_hardened", False):
+        _safe_add_image_stats._seqseg_hardened = True  # type: ignore[attr-defined]
+        samp_fn.add_image_stats = _safe_add_image_stats
+
     orig_sort = getattr(samp_fn, "sort_centerline", None)
     if orig_sort is not None and not getattr(orig_sort, "_seqseg_hardened", False):
 
@@ -268,11 +364,22 @@ def _preflight_training_data(
             )
 
 
-def _missing_patches_error(outdir: str, modalities: Sequence[str]) -> RuntimeError:
-    lines = [
-        "Patch extraction finished without writing any samples.",
-        f"  outdir: {os.path.abspath(outdir)}",
-    ]
+def _missing_volumes_error(
+    outdir: str,
+    modalities: Sequence[str],
+    *,
+    global_volumes: bool = False,
+) -> RuntimeError:
+    if global_volumes:
+        lines = [
+            "Whole-volume gathering finished without writing any cases.",
+            f"  outdir: {os.path.abspath(outdir)}",
+        ]
+    else:
+        lines = [
+            "Patch extraction finished without writing any samples.",
+            f"  outdir: {os.path.abspath(outdir)}",
+        ]
     for mod in modalities:
         img_dir = os.path.join(outdir, f"{mod.lower()}_train")
         mask_dir = os.path.join(outdir, f"{mod.lower()}_train_masks")
@@ -280,29 +387,47 @@ def _missing_patches_error(outdir: str, modalities: Sequence[str]) -> RuntimeErr
             f"  {mod}: {_count_volume_files(img_dir)} images in {img_dir}, "
             f"{_count_volume_files(mask_dir)} masks in {mask_dir}"
         )
-    lines.extend(
-        [
-            "",
-            "vascular-segment-sampler always opens "
-            "{modality}_train_Sample_stats.csv at the end, even when no case "
-            "completed (so that FileNotFoundError is a symptom, not the cause).",
-            "Typical causes:",
-            "  - Worker crashes with --num-cores > 1 (exceptions are not re-raised).",
-            "    Re-run with --num-cores 1 to see the real error.",
-            "  - Image extension mismatch (pass --img-ext, e.g. .nii.gz).",
-            "  - Missing truths/ (or surfaces/ when using --truth-from-surface).",
-            "  - All cases listed in outdir/done.txt, so they were skipped.",
-        ]
-    )
+    if global_volumes:
+        lines.extend(
+            [
+                "",
+                "Typical causes:",
+                "  - Image extension mismatch (pass --img-ext, e.g. .nii.gz).",
+                "  - Missing truths/ (or surfaces/ when using --truth-from-surface).",
+                "  - All cases listed in outdir/done.txt, so they were skipped.",
+            ]
+        )
+    else:
+        lines.extend(
+            [
+                "",
+                "vascular-segment-sampler always opens "
+                "{modality}_train_Sample_stats.csv at the end, even when no case "
+                "completed (so that FileNotFoundError is a symptom, not the cause).",
+                "Typical causes:",
+                "  - Worker crashes with --num-cores > 1 (exceptions are not re-raised).",
+                "    Re-run with --num-cores 1 to see the real error.",
+                "  - Image extension mismatch (pass --img-ext, e.g. .nii.gz).",
+                "  - Missing truths/ (or surfaces/ when using --truth-from-surface).",
+                "  - All cases listed in outdir/done.txt, so they were skipped.",
+            ]
+        )
     return RuntimeError("\n".join(lines))
 
 
-def _assert_patches_extracted(outdir: str, modalities: Sequence[str]) -> None:
+def _assert_volumes_written(
+    outdir: str,
+    modalities: Sequence[str],
+    *,
+    global_volumes: bool = False,
+) -> None:
     for mod in modalities:
         img_dir = os.path.join(outdir, f"{mod.lower()}_train")
         mask_dir = os.path.join(outdir, f"{mod.lower()}_train_masks")
         if _count_volume_files(img_dir) == 0 or _count_volume_files(mask_dir) == 0:
-            raise _missing_patches_error(outdir, modalities)
+            raise _missing_volumes_error(
+                outdir, modalities, global_volumes=global_volumes
+            )
 
 
 @contextmanager
@@ -394,9 +519,13 @@ def prepare_training_dataset(
     yes: bool = False,
     verbose: bool = False,
     img_ext: Optional[str] = None,
+    global_volumes: bool = False,
 ) -> PrepareResult:
     """
-    Extract SeqSeg-style patches and convert them to nnU-Net raw datasets.
+    Prepare training volumes and convert them to nnU-Net raw datasets.
+
+    By default extracts SeqSeg-style patches. With ``global_volumes=True``,
+    copies each case's full image and label instead (``gather_global_volumes``).
 
     Uses ``vascular-segment-sampler`` (``pip install seqseg[train]``).
     """
@@ -432,35 +561,70 @@ def prepare_training_dataset(
             truth_from_surface=truth_from_surface,
         )
         print("=" * 72)
-        print("Extracting vascular segment patches")
+        if global_volumes:
+            print("Gathering whole-case volumes (no patch sampling)")
+        else:
+            print("Extracting vascular segment patches")
         print(f"  data_dir: {data_dir}")
         print(f"  outdir:   {outdir}")
         print(f"  IMG_EXT:  {resolved_img_ext}")
         print("=" * 72)
-        _run_extract_patches(
-            extract_patches,
-            data_dir=data_dir,
-            outdir=outdir,
-            config=sampler_config,
-            perc_dataset=perc_dataset,
-            num_cores=num_cores,
-            start_from=start_from,
-            end_at=end_at,
-            testing=testing,
-            validation_prop=validation_prop,
-            max_samples=max_samples,
-            modality=modality_arg,
-            truth_from_surface=truth_from_surface,
-            truth_target_spacing=(
-                list(truth_target_spacing) if truth_target_spacing is not None else None
-            ),
-            truth_regenerate=truth_regenerate,
-            yes=yes,
-            verbose=verbose,
+        if global_volumes:
+            gather_global_volumes = _require_gather_global_volumes()
+            gather_global_volumes(
+                data_dir=data_dir,
+                outdir=outdir,
+                config=sampler_config,
+                perc_dataset=perc_dataset,
+                num_cores=num_cores,
+                start_from=start_from,
+                end_at=end_at,
+                testing=testing,
+                validation_prop=validation_prop,
+                modality=modality_arg,
+                truth_from_surface=truth_from_surface,
+                truth_target_spacing=(
+                    list(truth_target_spacing)
+                    if truth_target_spacing is not None
+                    else None
+                ),
+                truth_regenerate=truth_regenerate,
+                yes=yes,
+                verbose=verbose,
+            )
+        else:
+            _run_extract_patches(
+                extract_patches,
+                data_dir=data_dir,
+                outdir=outdir,
+                config=sampler_config,
+                perc_dataset=perc_dataset,
+                num_cores=num_cores,
+                start_from=start_from,
+                end_at=end_at,
+                testing=testing,
+                validation_prop=validation_prop,
+                max_samples=max_samples,
+                modality=modality_arg,
+                truth_from_surface=truth_from_surface,
+                truth_target_spacing=(
+                    list(truth_target_spacing)
+                    if truth_target_spacing is not None
+                    else None
+                ),
+                truth_regenerate=truth_regenerate,
+                yes=yes,
+                verbose=verbose,
+            )
+        _assert_volumes_written(
+            outdir, modalities, global_volumes=global_volumes
         )
-        _assert_patches_extracted(outdir, modalities)
     else:
-        print("Skipping patch extraction (--skip-sample)")
+        print(
+            "Skipping volume gathering (--skip-sample)"
+            if global_volumes
+            else "Skipping patch extraction (--skip-sample)"
+        )
 
     dataset_dirs: List[str] = []
     dataset_names: List[str] = []
@@ -474,7 +638,10 @@ def prepare_training_dataset(
         os.makedirs(convert_outdir, exist_ok=True)
 
         print("=" * 72)
-        print(f"Converting patches to nnU-Net format under {convert_outdir}")
+        print(
+            f"Converting {'volumes' if global_volumes else 'patches'} "
+            f"to nnU-Net format under {convert_outdir}"
+        )
         print("=" * 72)
 
         # Dataset numbers must be unique per modality when converting several.