seqseg 2.1.3__tar.gz → 2.1.5__tar.gz

{seqseg-2.1.3 → seqseg-2.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqseg
-Version: 2.1.3
+Version: 2.1.5
 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

{seqseg-2.1.3 → seqseg-2.1.5}/pyproject.toml

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

{seqseg-2.1.3 → seqseg-2.1.5}/seqseg/cli.py

@@ -677,7 +677,18 @@ def _cmd_train_prepare(ns: argparse.Namespace) -> None:
         print(str(e), file=sys.stderr)
         sys.exit(1)
     except Exception as e:  # noqa: BLE001
+        import traceback
+
+        traceback.print_exc()
         print(f"seqseg train prepare failed: {e}", file=sys.stderr)
+        if "GetDataType" in str(e):
+            print(
+                "A VTK array was None while reading centerlines/ (or "
+                "rasterizing surfaces/). Centerline .vtp files need points "
+                "and MaximumInscribedSphereRadius (VMTK/SimVascular). "
+                "Update SeqSeg and re-run with --num-cores 1.",
+                file=sys.stderr,
+            )
         sys.exit(1)
 
     print("\nPrepare complete.")

{seqseg-2.1.3 → seqseg-2.1.5}/seqseg/config/global_test.yaml

@@ -33,7 +33,9 @@ USE_BUFFER: True # buffer the assembly (so not to mess with retrace prevention)
 BUFFER_N: 20 # add to assembly steps buff_N steps ago
 WEIGHTED_ASSEMBLY: True # if assembly should be weighted
 WEIGHT_TYPE: gaussian # type of weighting for assembly
-CENT_MAX_SPACING: 0.3 # mm; max spacing per dim for final assembly (refine only)
+# Disabled for CI: the test CT is 512x512x258 (~0.65 mm). Refining the full
+# assembly to 0.3 mm is ~1e9 voxels and OOMs GitHub-hosted runners (exit 137).
+CENT_MAX_SPACING: null
 
 FORCEFUL_SIDEBRANCH: False
 FORCEFUL_SIDEBRANCH_MAGN_RADIUS: 1.1

{seqseg-2.1.3 → seqseg-2.1.5}/seqseg/modules/centerline.py

@@ -598,6 +598,25 @@ def gradient_matrix(x):
     return gradients
 
 
+def world_frame_gradient(grid_values, spacing, direction):
+    """
+    Convert a 3-D scalar field sampled on the image grid to a world-space
+    gradient (value per mm, components along the image direction axes).
+
+    ``np.gradient`` returns finite differences along array axes (per voxel).
+    Physical conversion is ``grad_world = D @ diag(1/spacing) @ grad_grid``.
+    Computation is in float64 so ITK FastMarching sentinels (~1e38 in
+    float32) do not overflow when scaled by ``1/spacing``.
+    """
+    values = np.asarray(grid_values, dtype=np.float64)
+    gradient = np.stack(np.gradient(values), axis=0)
+    spacing = np.asarray(spacing, dtype=np.float64).reshape(3)
+    inv_spacing = 1.0 / np.maximum(spacing, np.finfo(np.float64).tiny)
+    direction_matrix = np.asarray(direction, dtype=np.float64).reshape(3, 3)
+    gradient = gradient * inv_spacing[:, None, None, None]
+    return np.tensordot(direction_matrix, gradient, axes=([1], [0]))
+
+
 def hessian_matrix(x):
     """
     Calculate the hessian matrix with finite differences
@@ -1347,25 +1366,22 @@ def calc_centerline_fmm(segmentation, seed=None, targets=None,
                         os.path.join(out_dir, 'masked_out_fmm.mha'))
         sitk.WriteImage(segmentation,
                         os.path.join(out_dir, 'segmentation_from_fmm.mha'))
-    # Get gradient of distance map. ``np.gradient`` returns finite
-    # differences along the array (image-grid) axes, in units of "value
-    # per voxel". To use this to step a *physical* point we need a
-    # gradient in world-space units (value per mm, components along
-    # world axes). The conversion is:
+    # Gradient of the *masked* arrival-time map. Unreached FastMarching
+    # voxels keep ITK's float32 LargeValue (~1e38); differentiating that
+    # field and scaling by 1/spacing overflows float32 (CI RuntimeWarning)
+    # and yields inf/NaN steps. Mask + clip keeps the gradient inside the
+    # vessel and finite. Conversion to world mm^-1 is:
     #     grad_world = D @ diag(1/spacing) @ grad_grid
-    # where D is the SimpleITK direction matrix. Doing the conversion
-    # here once means every consumer (``backtracking_gradient``,
-    # ``interpolate_gradient``) gets a geometrically correct gradient
-    # without having to know about the image direction.
-    gradient = gradient_matrix(
-        sitk.GetArrayFromImage(output).transpose(2, 1, 0))
-    inv_spacing = 1.0 / np.asarray(segmentation.GetSpacing(),
-                                   dtype=np.float64)
-    direction_matrix = np.asarray(segmentation.GetDirection(),
-                                  dtype=np.float64).reshape(3, 3)
-    gradient = gradient * inv_spacing[:, None, None, None]
-    gradient = np.tensordot(direction_matrix, gradient,
-                            axes=([1], [0]))
+    arrival = np.clip(
+        np.asarray(
+            sitk.GetArrayFromImage(output_mask).transpose(2, 1, 0),
+            dtype=np.float64,
+        ),
+        -1.0e6,
+        1.0e6,
+    )
+    gradient = world_frame_gradient(
+        arrival, segmentation.GetSpacing(), segmentation.GetDirection())
     if verbose:
         # Calculate and print gradient magnitude statistics
         gradient_magnitude = np.sqrt(np.sum(gradient**2, axis=0))

{seqseg-2.1.3 → seqseg-2.1.5}/seqseg/modules/sitk_functions.py

@@ -55,7 +55,85 @@ def copy_settings(img, ref_img):
     return img
 
 
-def resample_to_spacing(image, new_spacing, is_label=False):
+# 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):
+    """Voxel size that :func:`resample_to_spacing` would produce."""
+    orig_size = np.asarray(orig_size, dtype=np.int64)
+    orig_spacing = np.asarray(orig_spacing, dtype=np.float64)
+    target_spacing = np.asarray(new_spacing, dtype=np.float64)
+    if np.any(target_spacing <= 0):
+        raise ValueError(f"new_spacing must be > 0, got {target_spacing.tolist()}")
+    return np.maximum(
+        1,
+        np.rint(orig_size * (orig_spacing / target_spacing)).astype(np.int64),
+    )
+
+
+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):
     """
     Resample a SITK image to a target spacing while preserving physical extent.
 
@@ -63,15 +141,23 @@ def resample_to_spacing(image, new_spacing, is_label=False):
         image (sitk.Image): Input image.
         new_spacing (iterable): Target spacing [sx, sy, sz].
         is_label (bool): Use nearest-neighbor interpolation for labels.
+        max_voxels (int | None): If set, raise ``ValueError`` when the
+            output grid would exceed this many voxels instead of allocating.
     """
     orig_size = np.array(image.GetSize(), dtype=np.int64)
     orig_spacing = np.array(image.GetSpacing(), dtype=np.float64)
     target_spacing = np.array(new_spacing, dtype=np.float64)
 
-    new_size = np.maximum(
-        1,
-        np.rint(orig_size * (orig_spacing / target_spacing)).astype(np.int64)
-    ).tolist()
+    new_size_arr = resampled_grid_size(orig_size, orig_spacing, target_spacing)
+    n_vox = int(np.prod(new_size_arr))
+    if max_voxels is not None and n_vox > int(max_voxels):
+        raise ValueError(
+            f"Resampling to spacing {target_spacing.tolist()} would create "
+            f"{tuple(int(s) for s in new_size_arr)} voxels ({n_vox:,}), "
+            f"exceeding max_voxels={int(max_voxels):,}. Check CENT_MAX_SPACING "
+            f"and -unit (mm vs cm) before refining a full-volume assembly."
+        )
+    new_size = new_size_arr.tolist()
 
     resample = sitk.ResampleImageFilter()
     resample.SetOutputSpacing(target_spacing.tolist())

{seqseg-2.1.3 → seqseg-2.1.5}/seqseg/modules/vtk_functions.py

@@ -87,10 +87,20 @@ class ClosestPoints:
 
 
 def collect_arrays(output):
+    """Convert VTK field/point/cell data arrays to numpy.
+
+    Skip unnamed arrays and non-numeric slots (``GetArray(i)`` is None for
+    string/abstract arrays). ``vtk_to_numpy(None)`` raises
+    ``'NoneType' object has no attribute 'GetDataType'``.
+    """
     res = {}
+    if output is None:
+        return res
     for i in range(output.GetNumberOfArrays()):
         name = output.GetArrayName(i)
         data = output.GetArray(i)
+        if name is None or data is None:
+            continue
         res[name] = v2n(data)
     return res
 
@@ -1284,8 +1294,18 @@ def convertPolyDataToImageData(poly, ref_im):
         output: resulted vtkImageData
     """
 
-    ref_im.GetPointData().SetScalars(
-        n2v(np.zeros(v2n(ref_im.GetPointData().GetScalars()).shape)))
+    sc = ref_im.GetPointData().GetScalars()
+    if sc is None:
+        dims = ref_im.GetDimensions()
+        n = int(dims[0]) * int(dims[1]) * int(dims[2])
+        if n <= 0:
+            raise RuntimeError(
+                f"VTK image has no scalars and empty dimensions {dims}"
+            )
+        shape = n
+    else:
+        shape = v2n(sc).shape
+    ref_im.GetPointData().SetScalars(n2v(np.zeros(shape)))
     ply2im = vtk.vtkPolyDataToImageStencil()
     ply2im.SetTolerance(0.05)
     ply2im.SetInputData(poly)

{seqseg-2.1.3 → seqseg-2.1.5}/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.3 → seqseg-2.1.5}/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.3 → seqseg-2.1.5}/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
 
@@ -31,9 +33,143 @@ def _require_sampler():
             "or:\n"
             "  pip install vascular-segment-sampler"
         ) from e
+    _harden_sampler_vtk()
     return extract_patches, write_nnunet_dataset
 
 
+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:
+    """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
+        import vascular_segment_sampler.sampling.functions as samp_fn
+        import vascular_segment_sampler.vtk_functions as vf
+        from seqseg.modules.vtk_functions import (
+            collect_arrays,
+            convertPolyDataToImageData,
+        )
+    except ImportError:
+        return
+
+    vf.collect_arrays = collect_arrays
+    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):
+
+        def _sort_centerline(centerline, *args, **kwargs):
+            if centerline is None or centerline.GetNumberOfPoints() == 0:
+                raise RuntimeError(
+                    "Centerline has no points. Each case needs a non-empty .vtp "
+                    "in centerlines/ (VMTK/SimVascular)."
+                )
+            pts = centerline.GetPoints()
+            if pts is None or pts.GetData() is None:
+                raise RuntimeError(
+                    "Centerline vtkPoints are empty. Check centerlines/*.vtp."
+                )
+            try:
+                return orig_sort(centerline, *args, **kwargs)
+            except KeyError as e:
+                key = str(e).strip("'\"")
+                if key in ("f", "MaximumInscribedSphereRadius", "Radius"):
+                    raise RuntimeError(
+                        "Centerline has no MaximumInscribedSphereRadius (or "
+                        "Radius) point-data array. Export VMTK/SimVascular "
+                        "centerlines."
+                    ) from e
+                raise
+
+        _sort_centerline._seqseg_hardened = True
+        samp_fn.sort_centerline = _sort_centerline
+
+    extract_mod.sort_centerline = samp_fn.sort_centerline
+
+
 def _parse_modalities(modality: Optional[str]) -> List[str]:
     if not modality:
         return ["CT"]