seqseg 2.1.4__tar.gz → 2.1.5__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seqseg"
-version = "2.1.4"
+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.4 → seqseg-2.1.5}/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.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.4 → 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.4 → 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
 
@@ -35,12 +37,84 @@ def _require_sampler():
     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:
-    """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 +131,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):
 

seqseg-2.1.5/seqseg/scripts/prepare_casx_dataset.py

@@ -0,0 +1,437 @@
+#!/usr/bin/env python3
+"""Convert ImageCAS / CAS-X coronary data into a SeqSeg dataset (native mm).
+
+Output layout under ``--path``:
+
+    images/{case}.nii.gz      CTA, mm, identity direction
+    truths/{case}.nii.gz      from source/segmentations/{id}.coronary.nii.gz only
+    centerlines/{case}.vtp    merged L/R anatomical, mm, with radius
+    surfaces/{case}.vtp       anatomical surfaces, mm
+    seeds.json
+
+Images are taken from ``source/images_*/{id}.img.nii.gz``.
+Does not use ``{id}.label.nii.gz``.
+
+vascular-segment-sampler maps points as ``(point - origin) / spacing`` and
+ignores the direction matrix. ImageCAS volumes are Y-flipped (dirY=-1); this
+script flips that axis and moves the origin so meshes and volumes share space.
+
+Examples::
+
+    python -m seqseg.scripts.prepare_casx_dataset --path /path/to/CAS_X_coronary_dataset
+    python -m seqseg.scripts.prepare_casx_dataset --path /path/to/CAS_X_coronary_dataset --fix-direction
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+
+import numpy as np
+import SimpleITK as sitk
+import vtk
+from vtk.util.numpy_support import numpy_to_vtk as n2v
+from vtk.util.numpy_support import vtk_to_numpy as v2n
+
+DEFAULT_RADIUS_MM = 2.0
+IDENTITY_DIRECTION = (1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
+
+
+def read_poly(path: Path) -> vtk.vtkPolyData:
+    path = Path(path)
+    if path.suffix.lower() == ".vtp":
+        reader = vtk.vtkXMLPolyDataReader()
+    else:
+        reader = vtk.vtkPolyDataReader()
+    reader.SetFileName(str(path))
+    reader.Update()
+    out = vtk.vtkPolyData()
+    out.DeepCopy(reader.GetOutput())
+    return out
+
+
+def write_vtp(poly: vtk.vtkPolyData, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    writer = vtk.vtkXMLPolyDataWriter()
+    writer.SetFileName(str(path))
+    writer.SetInputData(poly)
+    writer.SetDataModeToBinary()
+    writer.Write()
+
+
+def append_poly(*polys: vtk.vtkPolyData) -> vtk.vtkPolyData:
+    app = vtk.vtkAppendPolyData()
+    for p in polys:
+        if p is not None and p.GetNumberOfPoints() > 0:
+            app.AddInputData(p)
+    app.Update()
+    out = vtk.vtkPolyData()
+    out.DeepCopy(app.GetOutput())
+    return out
+
+
+def add_inscribed_radius(centerline: vtk.vtkPolyData, surface: vtk.vtkPolyData) -> None:
+    implicit = vtk.vtkImplicitPolyDataDistance()
+    implicit.SetInput(surface)
+    n = centerline.GetNumberOfPoints()
+    radii = np.empty(n, dtype=np.float64)
+    for i in range(n):
+        radii[i] = abs(implicit.EvaluateFunction(centerline.GetPoint(i)))
+    vtk_arr = n2v(radii, deep=True)
+    vtk_arr.SetName("MaximumInscribedSphereRadius")
+    centerline.GetPointData().AddArray(vtk_arr)
+
+
+def radius_at(poly: vtk.vtkPolyData, point_id: int, default: float = DEFAULT_RADIUS_MM) -> float:
+    rads = poly.GetPointData().GetArray("MaximumInscribedSphereRadius")
+    if rads is None:
+        return default
+    return max(float(rads.GetTuple1(point_id)), 0.5)
+
+
+def anatomical_ostia(poly: vtk.vtkPolyData) -> list:
+    starts = poly.GetPointData().GetArray("start_points")
+    if starts is None:
+        return []
+    sv = v2n(starts)
+    idx = np.where(sv > 0)[0]
+    seeds = []
+    for sid in idx:
+        sid = int(sid)
+        start = np.array(poly.GetPoint(sid))
+        direction = None
+        for c in range(poly.GetNumberOfCells()):
+            cell = poly.GetCell(c)
+            ids = [cell.GetPointId(k) for k in range(cell.GetNumberOfPoints())]
+            if sid not in ids:
+                continue
+            pos = ids.index(sid)
+            if pos + 8 < len(ids):
+                direction = np.array(poly.GetPoint(ids[pos + 8]))
+            elif pos - 8 >= 0:
+                direction = np.array(poly.GetPoint(ids[pos - 8]))
+            elif len(ids) > 1:
+                other = ids[-1] if pos == 0 else ids[0]
+                direction = np.array(poly.GetPoint(other))
+            break
+        if direction is None:
+            continue
+        seeds.append((start, direction, radius_at(poly, sid)))
+    return seeds
+
+
+def unique_ostia(poly: vtk.vtkPolyData, min_points: int = 20):
+    ostia = []
+    seen = []
+    for c in range(poly.GetNumberOfCells()):
+        cell = poly.GetCell(c)
+        n = cell.GetNumberOfPoints()
+        if n < min_points:
+            continue
+        ids = [cell.GetPointId(k) for k in range(n)]
+        rads = poly.GetPointData().GetArray("MaximumInscribedSphereRadius")
+        if rads is not None:
+            r0 = rads.GetTuple1(ids[0])
+            r1 = rads.GetTuple1(ids[-1])
+            if r1 > r0:
+                ids = list(reversed(ids))
+        start = np.array(poly.GetPoint(ids[0]))
+        if any(np.linalg.norm(start - s) < 1e-2 for s in seen):
+            continue
+        seen.append(start)
+        step = min(12, max(3, n // 20))
+        direction = np.array(poly.GetPoint(ids[step]))
+        ostia.append((start, direction, radius_at(poly, ids[0]), n))
+    ostia.sort(key=lambda t: t[2] * t[3], reverse=True)
+    return ostia[:2]
+
+
+def canonicalize_identity_direction(img: sitk.Image) -> sitk.Image:
+    """Flip negative-direction axes so origin+spacing matches mesh coordinates."""
+    direction = np.array(img.GetDirection(), dtype=float).reshape(3, 3)
+    if np.allclose(direction, np.eye(3)):
+        return img
+    size = np.array(img.GetSize(), dtype=float)
+    spacing = np.array(img.GetSpacing(), dtype=float)
+    origin = np.array(img.GetOrigin(), dtype=float)
+    arr = sitk.GetArrayFromImage(img)
+    new_origin = origin.copy()
+    # SimpleITK index axes (x, y, z) <-> numpy array axes (z, y, x)
+    for ax, np_ax in enumerate((2, 1, 0)):
+        if direction[ax, ax] >= 0:
+            continue
+        arr = np.flip(arr, axis=np_ax)
+        new_origin[ax] = origin[ax] + direction[ax, ax] * (size[ax] - 1) * spacing[ax]
+    out = sitk.GetImageFromArray(arr)
+    out.CopyInformation(img)
+    out.SetOrigin(tuple(float(v) for v in new_origin))
+    out.SetDirection(IDENTITY_DIRECTION)
+    return out
+
+
+def write_canonical_volume(src: Path, dst: Path) -> None:
+    img = canonicalize_identity_direction(sitk.ReadImage(str(src)))
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if dst.exists() or dst.is_symlink():
+        dst.unlink()
+    sitk.WriteImage(img, str(dst), useCompression=True)
+
+
+def fix_one_volume(path_str: str) -> tuple[str, str]:
+    path = Path(path_str)
+    img = sitk.ReadImage(str(path))
+    direction = img.GetDirection()
+    if all(abs(a - b) < 1e-9 for a, b in zip(direction, IDENTITY_DIRECTION)):
+        return path.name, "skip"
+    out = canonicalize_identity_direction(img)
+    if path.exists():
+        path.unlink()
+    sitk.WriteImage(out, str(path), useCompression=True)
+    return path.name, "wrote"
+
+
+def image_dirs(source: Path) -> list[Path]:
+    return sorted(p for p in source.glob("images_*") if p.is_dir())
+
+
+def find_image(case: str, source: Path) -> Path | None:
+    for d in image_dirs(source):
+        p = d / f"{case}.img.nii.gz"
+        if p.is_file():
+            return p
+    return None
+
+
+def move_originals(root: Path) -> dict:
+    source = root / "source"
+    mapping = {
+        root / "images" / "1-200": source / "images_1-200",
+        root / "images" / "sv_smooth_surface": source / "sv_smooth_surface",
+        root / "centerlines": source / "centerlines_anatomical",
+        root / "surfaces": source / "surfaces_anatomical",
+        root / "segmentations": source / "segmentations",
+    }
+    source.mkdir(exist_ok=True)
+    for src, dst in mapping.items():
+        if src.exists() and not dst.exists():
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.move(str(src), str(dst))
+            print(f"moved {src.relative_to(root)} -> {dst.relative_to(root)}")
+    (root / "images").mkdir(exist_ok=True)
+    dirs = image_dirs(source)
+    print("image source folders:", ", ".join(d.name for d in dirs) or "(none)")
+    return {
+        "root": root,
+        "source": source,
+        "image_dirs": dirs,
+        "cent_anat": source / "centerlines_anatomical",
+        "surf_anat": source / "surfaces_anatomical",
+        "segs": source / "segmentations",
+    }
+
+
+def case_ids(paths: dict) -> list[str]:
+    ids = set()
+    for p in paths["segs"].glob("*.coronary.nii.gz"):
+        ids.add(p.name.split(".")[0])
+    for d in paths["image_dirs"]:
+        for p in d.glob("*.img.nii.gz"):
+            ids.add(p.name.split(".")[0])
+    return sorted(ids, key=lambda x: int(x) if x.isdigit() else x)
+
+
+def refresh_seed_radii(seed_list: list, merged: vtk.vtkPolyData) -> list:
+    if not seed_list:
+        ostia = unique_ostia(merged)
+        return [(s, d, r) for s, d, r, _ in ostia]
+    pts = np.array([merged.GetPoint(i) for i in range(merged.GetNumberOfPoints())])
+    if pts.size == 0:
+        return seed_list
+    refreshed = []
+    for start, direction, radius in seed_list:
+        dist = np.linalg.norm(pts - np.asarray(start), axis=1)
+        pid = int(np.argmin(dist))
+        refreshed.append((start, direction, radius_at(merged, pid, radius)))
+    return refreshed
+
+
+def process_case(case: str, root_str: str) -> dict:
+    root = Path(root_str)
+    source = root / "source"
+    cent_anat = source / "centerlines_anatomical"
+    surf_anat = source / "surfaces_anatomical"
+    segs = source / "segmentations"
+
+    img_orig = find_image(case, source)
+    seg = segs / f"{case}.coronary.nii.gz"
+    surf_src = surf_anat / f"{case}.coronary_surface.vtk"
+    left = cent_anat / f"{case}.coronary_left_centerline.vtk"
+    right = cent_anat / f"{case}.coronary_right_centerline.vtk"
+
+    out_img = root / "images" / f"{case}.nii.gz"
+    out_truth = root / "truths" / f"{case}.nii.gz"
+    out_cent = root / "centerlines" / f"{case}.vtp"
+    out_surf = root / "surfaces" / f"{case}.vtp"
+
+    for d in ("images", "truths", "centerlines", "surfaces"):
+        (root / d).mkdir(exist_ok=True)
+
+    status = {
+        "case": case,
+        "image": False,
+        "truth": False,
+        "centerline": False,
+        "surface": False,
+        "seeds": [],
+    }
+
+    if img_orig is not None:
+        write_canonical_volume(img_orig, out_img)
+        status["image"] = True
+
+    if seg.exists():
+        write_canonical_volume(seg, out_truth)
+        status["truth"] = True
+
+    parts = []
+    seed_list = []
+    for branch in (left, right):
+        if not branch.exists():
+            continue
+        p = read_poly(branch)
+        parts.append(p)
+        seed_list.extend(anatomical_ostia(p))
+    if parts:
+        if out_cent.exists():
+            merged = read_poly(out_cent)
+            seed_list = refresh_seed_radii(seed_list, merged)
+        else:
+            merged = append_poly(*parts)
+            if surf_src.exists():
+                add_inscribed_radius(merged, read_poly(surf_src))
+                seed_list = refresh_seed_radii(seed_list, merged)
+            write_vtp(merged, out_cent)
+        status["centerline"] = True
+        status["seeds"] = [[s.tolist(), d.tolist(), float(r)] for s, d, r in seed_list]
+
+    if surf_src.exists():
+        if not out_surf.exists():
+            write_vtp(read_poly(surf_src), out_surf)
+        status["surface"] = True
+
+    return status
+
+
+def n_workers(requested: int | None) -> int:
+    if requested is not None and requested > 0:
+        return requested
+    return max(1, min(8, os.cpu_count() or 4))
+
+
+def fix_existing_volumes(root: Path, workers: int) -> None:
+    paths = [str(p) for p in sorted((root / "images").glob("*.nii.gz"))]
+    paths += [str(p) for p in sorted((root / "truths").glob("*.nii.gz"))]
+    print(f"Fixing direction on {len(paths)} volumes ({workers} workers)")
+    n_wrote = n_skip = 0
+    with ProcessPoolExecutor(max_workers=workers) as ex:
+        futs = {ex.submit(fix_one_volume, p): p for p in paths}
+        done = 0
+        for fut in as_completed(futs):
+            _name, status = fut.result()
+            n_wrote += int(status == "wrote")
+            n_skip += int(status == "skip")
+            done += 1
+            if done % 50 == 0 or done == len(paths):
+                print(f"  {done}/{len(paths)} wrote={n_wrote} skip={n_skip}")
+    print(f"direction fix done wrote={n_wrote} already_identity={n_skip}")
+
+
+def run_prepare(root: Path, workers: int) -> None:
+    paths = move_originals(root)
+    cases = case_ids(paths)
+    print(
+        f"{len(cases)} cases, {workers} workers "
+        "(mm, truths from segmentations/, images from source/images_*)"
+    )
+
+    results = []
+    with ProcessPoolExecutor(max_workers=workers) as ex:
+        futs = {ex.submit(process_case, c, str(root)): c for c in cases}
+        done = 0
+        for fut in as_completed(futs):
+            case = futs[fut]
+            try:
+                res = fut.result()
+            except Exception as e:  # noqa: BLE001
+                res = {"case": case, "error": str(e)}
+            results.append(res)
+            done += 1
+            if done % 25 == 0 or done == len(cases):
+                print(f"  {done}/{len(cases)}")
+
+    seeds = []
+    n_img = n_truth = n_cent = n_surf = n_err = 0
+    for r in sorted(
+        results,
+        key=lambda x: int(x.get("case", "0")) if str(x.get("case", "0")).isdigit() else 0,
+    ):
+        if r.get("error"):
+            n_err += 1
+            print("ERROR", r["case"], r["error"])
+            continue
+        n_img += int(bool(r.get("image")))
+        n_truth += int(bool(r.get("truth")))
+        n_cent += int(bool(r.get("centerline")))
+        n_surf += int(bool(r.get("surface")))
+        if r.get("image"):
+            seeds.append(
+                {
+                    "name": r["case"],
+                    "seeds": r.get("seeds") or [],
+                    "cardiac_mesh": False,
+                }
+            )
+
+    seeds.sort(key=lambda s: int(s["name"]) if str(s["name"]).isdigit() else s["name"])
+    seeds_path = root / "seeds.json"
+    with open(seeds_path, "w", encoding="utf-8") as f:
+        json.dump(seeds, f, indent=2)
+
+    print(
+        f"done images={n_img} truths={n_truth} centerlines={n_cent} "
+        f"surfaces={n_surf} errors={n_err} seeds={len(seeds)} -> {seeds_path}"
+    )
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        description="Convert ImageCAS / CAS-X coronary data into a SeqSeg dataset.",
+    )
+    parser.add_argument(
+        "--path",
+        type=str,
+        default=".",
+        help="Dataset root (contains source/ or native ImageCAS folders)",
+    )
+    parser.add_argument(
+        "--fix-direction",
+        action="store_true",
+        help="Rewrite existing images/ and truths/ to identity direction (mm)",
+    )
+    parser.add_argument("--num-cores", type=int, default=None, help="Worker processes")
+    args = parser.parse_args(argv)
+
+    root = Path(args.path).expanduser().resolve()
+    workers = n_workers(args.num_cores)
+    if args.fix_direction:
+        fix_existing_volumes(root, workers)
+        return
+    run_prepare(root, workers)
+
+
+if __name__ == "__main__":
+    main()

seqseg-2.1.5/seqseg/tests/test_prepare_casx_dataset.py

@@ -0,0 +1,45 @@
+"""Tests for ImageCAS / CAS-X direction canonicalization."""
+
+import numpy as np
+import SimpleITK as sitk
+
+from seqseg.scripts.prepare_casx_dataset import (
+    IDENTITY_DIRECTION,
+    canonicalize_identity_direction,
+)
+
+
+def test_canonicalize_flips_negative_y_and_keeps_physical_point():
+    arr = np.arange(2 * 4 * 3, dtype=np.int16).reshape(2, 4, 3)
+    img = sitk.GetImageFromArray(arr)
+    img.SetSpacing((0.5, 0.4, 1.0))
+    img.SetOrigin((1.0, 10.0, 3.0))
+    img.SetDirection((1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 1.0))
+
+    ijk = (1, 3, 0)
+    phys = np.array(img.TransformIndexToPhysicalPoint(ijk))
+
+    out = canonicalize_identity_direction(img)
+    assert tuple(round(v, 9) for v in out.GetDirection()) == IDENTITY_DIRECTION
+
+    ny = img.GetSize()[1]
+    ijk_flipped = (ijk[0], ny - 1 - ijk[1], ijk[2])
+    phys_out = np.array(out.TransformIndexToPhysicalPoint(ijk_flipped))
+    np.testing.assert_allclose(phys, phys_out)
+
+    # Sampler-style mapping (ignores direction) must land in-bounds.
+    origin = np.array(out.GetOrigin())
+    spacing = np.array(out.GetSpacing())
+    size = np.array(out.GetSize())
+    idx = (phys_out - origin) / spacing
+    assert np.all(idx >= 0) and np.all(idx <= size - 1)
+
+
+def test_canonicalize_noop_when_already_identity():
+    img = sitk.GetImageFromArray(np.ones((2, 2, 2), dtype=np.uint8))
+    img.SetDirection(IDENTITY_DIRECTION)
+    origin = img.GetOrigin()
+    out = canonicalize_identity_direction(img)
+    assert out.GetDirection() == IDENTITY_DIRECTION
+    assert out.GetOrigin() == origin
+    np.testing.assert_array_equal(sitk.GetArrayFromImage(img), sitk.GetArrayFromImage(out))

{seqseg-2.1.4 → seqseg-2.1.5}/seqseg/tests/test_resample_spacing.py

@@ -6,7 +6,9 @@ import SimpleITK as sitk
 
 from seqseg.config_models import AlgorithmConfig
 from seqseg.modules.sitk_functions import (
+    DEFAULT_MAX_RESAMPLE_VOXELS,
     capped_target_spacing,
+    fit_spacing_to_max_voxels,
     resample_to_spacing,
     resampled_grid_size,
 )
@@ -28,8 +30,8 @@ def test_capped_target_spacing_cm_is_tenfold_finer():
     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
+    # ~1e12 voxels — this is what SIGKILL'd the macos CI job.
+    assert n_vox > DEFAULT_MAX_RESAMPLE_VOXELS
 
 
 def test_resampled_grid_size_identity():
@@ -55,3 +57,35 @@ def test_resample_to_spacing_small_grid_runs():
     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))
+
+
+def test_fit_spacing_keeps_target_when_under_limit():
+    orig_size = (64, 256, 256)
+    orig_spacing = (0.15, 0.117188, 0.117188)
+    target = [0.03, 0.03, 0.03]
+    n_vox = int(np.prod(resampled_grid_size(orig_size, orig_spacing, target)))
+    assert n_vox == 320_000_000
+    fitted = fit_spacing_to_max_voxels(orig_size, orig_spacing, target)
+    assert fitted == pytest.approx(target)
+
+
+def test_fit_spacing_coarsens_to_voxel_budget():
+    orig_size = (512, 512, 258)
+    orig_spacing = (0.65, 0.65, 1.0)
+    target = [0.03, 0.03, 0.03]
+    fitted = fit_spacing_to_max_voxels(orig_size, orig_spacing, target)
+    assert fitted is not None
+    n_vox = int(np.prod(resampled_grid_size(orig_size, orig_spacing, fitted)))
+    assert n_vox <= DEFAULT_MAX_RESAMPLE_VOXELS
+    assert all(f <= s for f, s in zip(fitted, orig_spacing))
+    assert any(f < s for f, s in zip(fitted, orig_spacing))
+
+
+def test_fit_spacing_returns_none_if_original_already_over_budget():
+    fitted = fit_spacing_to_max_voxels(
+        (100, 100, 100),
+        (1.0, 1.0, 1.0),
+        (0.01, 0.01, 0.01),
+        max_voxels=1_000,
+    )
+    assert fitted is None

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

@@ -16,7 +16,10 @@ from seqseg.pipeline.train import (
     _dir_for_sampler,
     _harden_sampler_vtk,
     _normalize_img_ext,
+    _reduction_or_nan,
     _resolve_img_ext,
+    _safe_add_image_stats,
+    _safe_add_local_stats,
     dataset_id_from_name,
     expected_nnunet_dataset_name,
     prepare_training_dataset,
@@ -323,6 +326,58 @@ def test_harden_sampler_vtk_patches_collect_arrays():
 
     _harden_sampler_vtk()
     assert samp_fn.collect_arrays is collect_arrays
+    assert samp_fn.add_local_stats is _safe_add_local_stats
+    assert samp_fn.add_image_stats is _safe_add_image_stats
+
+
+def test_safe_add_local_stats_empty_blood_does_not_raise():
+    stats, extra = _safe_add_local_stats(
+        {},
+        np.array([1.0, 2.0, 3.0]),
+        0.0,
+        np.array([]),
+        np.zeros((2, 2, 2)),
+        [1],
+        None,
+        np.ones((2, 2, 2)),
+        0,
+    )
+    assert extra == 0
+    assert np.isnan(stats["BLOOD_MIN"])
+    assert np.isnan(stats["BLOOD_MEAN"])
+    assert stats["GT_MIN"] == 0.0
+    assert stats["POINT_CENT"] == [1.0, 2.0, 3.0]
+
+
+def test_safe_add_local_stats_empty_largest_component():
+    sitk = pytest.importorskip("SimpleITK")
+    empty = sitk.Image(2, 2, 2, sitk.sitkUInt8)
+    im = np.arange(8, dtype=float).reshape(2, 2, 2)
+    stats, extra = _safe_add_local_stats(
+        {},
+        [0, 0, 0],
+        0.0,
+        im.ravel(),
+        np.ones((2, 2, 2)),
+        [1, 2],
+        empty,
+        im,
+        0,
+    )
+    assert extra == 1
+    assert np.isnan(stats["LARGEST_MIN"])
+    assert np.isnan(stats["LARGEST_MEAN"])
+
+
+def test_safe_add_image_stats_empty_volume():
+    stats = _safe_add_image_stats({}, np.array([]))
+    assert np.isnan(stats["IM_MIN"])
+    assert np.isnan(stats["IM_MAX"])
+
+
+def test_reduction_or_nan_nonempty():
+    assert _reduction_or_nan(np.array([3.0, 1.0, 2.0]), np.amin) == 1.0
+    assert np.isnan(_reduction_or_nan(np.array([]), np.amin))
 
 
 def test_run_nnunet_training_requires_env(tmp_path, monkeypatch):

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

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

@@ -59,6 +59,7 @@ seqseg/pipeline/post.py
 seqseg/pipeline/single_trace.py
 seqseg/pipeline/train.py
 seqseg/scripts/__init__.py
+seqseg/scripts/prepare_casx_dataset.py
 seqseg/scripts/taubin_smooth.py
 seqseg/tests/conftest.py
 seqseg/tests/test_api_entry.py
@@ -68,6 +69,7 @@ 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_prepare_casx_dataset.py
 seqseg/tests/test_resample_spacing.py
 seqseg/tests/test_segmentation.py
 seqseg/tests/test_single_trace_staging.py