seqseg 2.1.3__tar.gz → 2.1.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqseg
-Version: 2.1.3
+Version: 2.1.4
 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.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seqseg"
-version = "2.1.3"
+version = "2.1.4"
 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.4}/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.4}/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.4}/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.4}/seqseg/modules/sitk_functions.py

@@ -55,7 +55,27 @@ def copy_settings(img, ref_img):
     return img
 
 
-def resample_to_spacing(image, new_spacing, is_label=False):
+# 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
+
+
+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 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 +83,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.4}/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.4}/seqseg/pipeline/train.py

@@ -31,9 +31,64 @@ def _require_sampler():
             "or:\n"
             "  pip install vascular-segment-sampler"
         ) from e
+    _harden_sampler_vtk()
     return extract_patches, write_nnunet_dataset
 
 
+def _harden_sampler_vtk() -> None:
+    """Skip non-numeric VTK arrays the sampler used to pass to vtk_to_numpy.
+
+    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'``.
+    """
+    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
+
+    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"]

seqseg-2.1.4/seqseg/tests/test_centerline_gradient.py

@@ -0,0 +1,49 @@
+"""World-frame FMM gradient conversion (overflow / direction)."""
+
+import numpy as np
+
+from seqseg.modules.centerline import world_frame_gradient
+
+
+def test_world_frame_gradient_identity_spacing():
+    # f(x,y,z) = 2x + 3y + 4z on a unit grid -> grad = (2, 3, 4)
+    x = np.arange(5)[:, None, None]
+    y = np.arange(5)[None, :, None]
+    z = np.arange(5)[None, None, :]
+    field = 2.0 * x + 3.0 * y + 4.0 * z
+    identity = (1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
+    grad = world_frame_gradient(field, (1.0, 1.0, 1.0), identity)
+    interior = grad[:, 1:-1, 1:-1, 1:-1]
+    np.testing.assert_allclose(interior[0], 2.0, atol=1e-12)
+    np.testing.assert_allclose(interior[1], 3.0, atol=1e-12)
+    np.testing.assert_allclose(interior[2], 4.0, atol=1e-12)
+
+
+def test_world_frame_gradient_scales_by_inv_spacing():
+    x = np.arange(5, dtype=np.float64)[:, None, None]
+    field = np.broadcast_to(x, (5, 5, 5)).copy()
+    identity = (1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
+    # Two voxels of +1 in x, spacing 2 mm -> 0.5 / mm
+    grad = world_frame_gradient(field, (2.0, 2.0, 2.0), identity)
+    np.testing.assert_allclose(grad[0, 1:-1, :, :], 0.5, atol=1e-12)
+
+
+def test_world_frame_gradient_float32_largevalue_does_not_overflow():
+    """ITK FastMarching unreached voxels are ~1e38 in float32."""
+    field = np.zeros((6, 6, 6), dtype=np.float32)
+    field[2:4, 2:4, 2:4] = 10.0
+    field[0, 0, 0] = np.float32(1.7e38)
+    identity = (1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
+    with np.errstate(over="raise"):
+        grad = world_frame_gradient(field, (0.65, 0.65, 1.0), identity)
+    assert np.isfinite(grad).all()
+
+
+def test_world_frame_gradient_applies_direction_flip():
+    x = np.arange(5, dtype=np.float64)[:, None, None]
+    field = np.broadcast_to(x, (5, 5, 5)).copy()
+    flip_x = (-1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
+    grad = world_frame_gradient(field, (1.0, 1.0, 1.0), flip_x)
+    np.testing.assert_allclose(grad[0, 1:-1, :, :], -1.0, atol=1e-12)
+    np.testing.assert_allclose(grad[1], 0.0, atol=1e-12)
+    np.testing.assert_allclose(grad[2], 0.0, atol=1e-12)

{seqseg-2.1.3 → seqseg-2.1.4}/seqseg/tests/test_cli_helpers.py

@@ -362,6 +362,46 @@ def test_cmd_train_prepare_missing_dep(tmp_path, capsys):
     assert "missing" in capsys.readouterr().err
 
 
+def test_cmd_train_prepare_getdatatype_hint(tmp_path, capsys):
+    ns = argparse.Namespace(
+        data_dir=str(tmp_path),
+        outdir=str(tmp_path / "out"),
+        name="MYDATA",
+        dataset_number=999,
+        modality="CT",
+        config_name="global",
+        nnunet_raw=None,
+        perc_dataset=1.0,
+        num_cores=1,
+        start_from=0,
+        end_at=-1,
+        testing=False,
+        validation_prop=None,
+        max_samples=None,
+        truth_from_surface=False,
+        truth_target_spacing=None,
+        truth_regenerate=False,
+        skip_sample=False,
+        skip_convert=False,
+        also_test=False,
+        yes=False,
+        verbose=False,
+        img_ext=None,
+    )
+    with patch(
+        "seqseg.cli.prepare_training_dataset",
+        side_effect=AttributeError(
+            "'NoneType' object has no attribute 'GetDataType'"
+        ),
+    ):
+        with pytest.raises(SystemExit) as exc:
+            _cmd_train_prepare(ns)
+    assert exc.value.code == 1
+    err = capsys.readouterr().err
+    assert "GetDataType" in err
+    assert "centerlines" in err
+
+
 def test_cmd_train_nnunet_resolves_name(monkeypatch):
     called = {}
 

seqseg-2.1.4/seqseg/tests/test_resample_spacing.py

@@ -0,0 +1,57 @@
+"""Assembly spacing cap and resample size guards (CI OOM prevention)."""
+
+import numpy as np
+import pytest
+import SimpleITK as sitk
+
+from seqseg.config_models import AlgorithmConfig
+from seqseg.modules.sitk_functions import (
+    capped_target_spacing,
+    resample_to_spacing,
+    resampled_grid_size,
+)
+
+
+def test_capped_target_spacing_mm_caps_coarse_dims():
+    target = capped_target_spacing((0.65, 0.65, 1.0), 0.3, "mm")
+    assert target == pytest.approx([0.3, 0.3, 0.3])
+
+
+def test_capped_target_spacing_already_fine_returns_none():
+    assert capped_target_spacing((0.2, 0.2, 0.2), 0.3, "mm") is None
+
+
+def test_capped_target_spacing_cm_is_tenfold_finer():
+    # Image spacing stored in mm, but -unit cm treats 0.3 mm as 0.03.
+    target = capped_target_spacing((0.65, 0.65, 1.0), 0.3, "cm")
+    assert target == pytest.approx([0.03, 0.03, 0.03])
+    n_vox = int(np.prod(resampled_grid_size(
+        (512, 512, 258), (0.65, 0.65, 1.0), target
+    )))
+    # ~1e9 voxels — this is what SIGKILL'd the macos CI job.
+    assert n_vox > 200_000_000
+
+
+def test_resampled_grid_size_identity():
+    size = resampled_grid_size((10, 20, 30), (1.0, 1.0, 1.0), (1.0, 1.0, 1.0))
+    np.testing.assert_array_equal(size, [10, 20, 30])
+
+
+def test_resample_to_spacing_refuses_huge_grid():
+    img = sitk.Image(8, 8, 8, sitk.sitkUInt8)
+    img.SetSpacing((1.0, 1.0, 1.0))
+    with pytest.raises(ValueError, match="max_voxels"):
+        resample_to_spacing(img, (0.01, 0.01, 0.01), max_voxels=1_000)
+
+
+def test_global_test_config_skips_assembly_upsample():
+    cfg = AlgorithmConfig.from_name("global_test")
+    assert cfg.get("CENT_MAX_SPACING") is None
+
+
+def test_resample_to_spacing_small_grid_runs():
+    img = sitk.Image(4, 4, 4, sitk.sitkFloat32)
+    img.SetSpacing((2.0, 2.0, 2.0))
+    out = resample_to_spacing(img, (1.0, 1.0, 1.0))
+    assert tuple(out.GetSize()) == (8, 8, 8)
+    assert out.GetSpacing() == pytest.approx((1.0, 1.0, 1.0))

{seqseg-2.1.3 → seqseg-2.1.4}/seqseg/tests/test_train_pipeline.py

@@ -8,10 +8,13 @@ import os
 
 from pathlib import Path
 
+import numpy as np
+
 from seqseg.pipeline.train import (
     TrainDependencyError,
     _detect_img_ext,
     _dir_for_sampler,
+    _harden_sampler_vtk,
     _normalize_img_ext,
     _resolve_img_ext,
     dataset_id_from_name,
@@ -266,6 +269,62 @@ def test_prepare_missing_stats_csv_without_patches_is_actionable(tmp_path):
     write.assert_not_called()
 
 
+def test_collect_arrays_skips_string_arrays():
+    import vtk
+    from vtk.util.numpy_support import numpy_to_vtk
+
+    from seqseg.modules.vtk_functions import collect_arrays
+
+    pts = vtk.vtkPoints()
+    pts.InsertNextPoint(0.0, 0.0, 0.0)
+    poly = vtk.vtkPolyData()
+    poly.SetPoints(pts)
+
+    rad = numpy_to_vtk(np.array([1.5], dtype=np.float64))
+    rad.SetName("MaximumInscribedSphereRadius")
+    poly.GetPointData().AddArray(rad)
+
+    names = vtk.vtkStringArray()
+    names.SetName("ModelName")
+    names.InsertNextValue("aorta")
+    poly.GetPointData().AddArray(names)
+
+    data = collect_arrays(poly.GetPointData())
+    assert "MaximumInscribedSphereRadius" in data
+    assert "ModelName" not in data
+    assert float(data["MaximumInscribedSphereRadius"][0]) == 1.5
+
+
+def test_convert_poly_to_image_without_scalars():
+    import vtk
+
+    from seqseg.modules.vtk_functions import convertPolyDataToImageData
+
+    sphere = vtk.vtkSphereSource()
+    sphere.SetCenter(4, 4, 4)
+    sphere.SetRadius(2.0)
+    sphere.Update()
+
+    ref = vtk.vtkImageData()
+    ref.SetDimensions(8, 8, 8)
+    ref.SetSpacing(1.0, 1.0, 1.0)
+    ref.SetOrigin(0, 0, 0)
+
+    out = convertPolyDataToImageData(sphere.GetOutput(), ref)
+    assert out.GetPointData().GetScalars() is not None
+    assert out.GetDimensions() == (8, 8, 8)
+
+
+def test_harden_sampler_vtk_patches_collect_arrays():
+    pytest.importorskip("vascular_segment_sampler")
+    import vascular_segment_sampler.sampling.functions as samp_fn
+
+    from seqseg.modules.vtk_functions import collect_arrays
+
+    _harden_sampler_vtk()
+    assert samp_fn.collect_arrays is collect_arrays
+
+
 def test_run_nnunet_training_requires_env(tmp_path, monkeypatch):
     monkeypatch.setenv("SEQSEG_PATHS_FILE", str(tmp_path / "no_paths.yaml"))
     for key in ("nnUNet_raw", "nnUNet_preprocessed", "nnUNet_results"):

{seqseg-2.1.3 → seqseg-2.1.4}/seqseg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqseg
-Version: 2.1.3
+Version: 2.1.4
 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.4}/seqseg.egg-info/SOURCES.txt

@@ -63,10 +63,12 @@ seqseg/scripts/taubin_smooth.py
 seqseg/tests/conftest.py
 seqseg/tests/test_api_entry.py
 seqseg/tests/test_centerline_get_end_points.py
+seqseg/tests/test_centerline_gradient.py
 seqseg/tests/test_cli_helpers.py
 seqseg/tests/test_datasets_paths.py
 seqseg/tests/test_nnunet2.py
 seqseg/tests/test_nnunet_device.py
+seqseg/tests/test_resample_spacing.py
 seqseg/tests/test_segmentation.py
 seqseg/tests/test_single_trace_staging.py
 seqseg/tests/test_start_seg.py