seqseg 2.1.2__tar.gz → 2.1.4__tar.gz

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

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

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

@@ -671,12 +671,24 @@ def _cmd_train_prepare(ns: argparse.Namespace) -> None:
             also_test=ns.also_test,
             yes=ns.yes,
             verbose=ns.verbose,
+            img_ext=ns.img_ext,
         )
     except TrainDependencyError as e:
         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.")
@@ -1038,6 +1050,14 @@ def _build_parser() -> argparse.ArgumentParser:
         help="Write DatasetXXX_* here "
         "(default: seqseg paths nnunet_raw / $nnUNet_raw; else --outdir)",
     )
+    p_prep.add_argument(
+        "--img-ext",
+        "-img_ext",
+        default=None,
+        type=str,
+        help="Image/label suffix (.nii.gz, .mha, .nrrd, …). "
+        "Default: detect from data_dir/images/; else sampler YAML IMG_EXT",
+    )
     p_prep.add_argument("--perc-dataset", default=1.0, type=float)
     p_prep.add_argument("--num-cores", default=1, type=int)
     p_prep.add_argument("--start-from", default=0, type=int)
@@ -1075,7 +1095,7 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     p_prep.add_argument("--yes", action="store_true", help="Non-interactive confirms")
     p_prep.add_argument("--verbose", action="store_true")
-    p_prep.set_defaults(_handler=_cmd_train_prepare)
+    p_prep.set_defaults(_handler=_cmd_train_prepare, img_ext=None)
 
     p_nn = train_sub.add_parser(
         "nnunet",

{seqseg-2.1.2 → 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.2 → 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.2 → 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.2 → 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)