seqseg 2.2.0__tar.gz → 2.2.2__tar.gz

{seqseg-2.2.0 → seqseg-2.2.2}/PKG-INFO

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

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

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/api.py

@@ -122,7 +122,7 @@ class TracingOptions:
     write_samples: bool = False
     disk_io: bool = True
     simvascular: bool = False
-    unit: str = "cm"
+    unit: str = "mm"
     scale: float = 1.0
     fold: str = "all"
     force_cpu: bool = False

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/cli.py

@@ -129,7 +129,7 @@ def _add_classic_trace_args(p: argparse.ArgumentParser) -> None:
     p.add_argument("-max_n_steps", "--max_n_steps", default=1000, type=int)
     p.add_argument("-max_n_steps_per_branch", "--max_n_steps_per_branch", default=100, type=int)
     p.add_argument("-max_n_branches", "--max_n_branches", default=100, type=int)
-    p.add_argument("-unit", "--unit", default="cm", type=str)
+    p.add_argument("-unit", "--unit", default="mm", type=str)
     p.add_argument("-config_name", "--config_name", default="global", type=str)
     p.add_argument("-pt_centerline", "--pt_centerline", default=50, type=int)
     p.add_argument("-num_seeds_centerline", "--num_seeds_centerline", default=1, type=int)
@@ -1029,7 +1029,7 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     p_single.add_argument("--config-name", default="global", type=str)
     p_single.add_argument("--scale", default=1.0, type=float)
-    p_single.add_argument("--unit", default="cm", type=str)
+    p_single.add_argument("--unit", default="mm", type=str)
     p_single.add_argument("--max-n-steps", default=1000, type=int)
     p_single.add_argument("--max-n-branches", default=100, type=int)
     p_single.add_argument("--max-n-steps-per-branch", default=100, type=int)
@@ -1218,7 +1218,7 @@ def _build_parser() -> argparse.ArgumentParser:
     g1.add_argument("--config-name", default=None, type=str)
     g1.add_argument("--merge-method", default="clean", type=str)
     g1.add_argument("--directory-data", default=None, type=str)
-    g1.add_argument("--unit", default="cm", type=str)
+    g1.add_argument("--unit", default="mm", type=str)
     g1.set_defaults(_handler=_cmd_post_gcl_single)
 
     g2 = gcl_sub.add_parser("batch", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
@@ -1234,7 +1234,7 @@ def _build_parser() -> argparse.ArgumentParser:
     g2.add_argument("--config-name", default=None, type=str)
     g2.add_argument("--merge-method", default="clean", type=str)
     g2.add_argument("--directory-data", default=None, type=str)
-    g2.add_argument("--unit", default="cm", type=str)
+    g2.add_argument("--unit", default="mm", type=str)
     g2.set_defaults(_handler=_cmd_post_gcl_batch)
 
     sv = sub.add_parser("simvascular", help="SimVascular project layout")

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/config_models.py

@@ -118,7 +118,7 @@ class TracingLimits:
     max_n_branches: int = 100
     max_n_steps_per_branch: int = 100
     write_samples: bool = False
-    unit: str = "cm"
+    unit: str = "mm"
     scale: float = 1.0
 
 

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/modules/assembly.py

@@ -1004,7 +1004,6 @@ def calc_centerline_global(predicted_vessels, initial_seeds,
     centerline_poly, success_info = calc_multi_component_centerlines(
         predicted_vessels,
         nr_seeds=nr_seeds,
-        min_res=500,
         out_dir=None,
         write_files=False,
         move_target_if_fail=False,

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/modules/centerline.py

@@ -1339,8 +1339,126 @@ def backtracking_gradient(gradient, distance_map_surf_np,
     return points, success
 
 
+# Prefer an isotropic grid of about 260 million voxels when that is finer
+# than the segmentation. Never exceed 260 million voxels. On the S-008
+# crop, 250 million still dropped distal tips and 260 million kept every
+# end cluster.
+_TARGET_CENTERLINE_VOXELS = 260_000_000
+_MAX_CENTERLINE_VOXELS = 260_000_000
+
+
+def _isotropic_grid(extent, n_voxels):
+    """Round ``extent`` onto an isotropic spacing of at most ``n_voxels``."""
+    extent = np.asarray(extent, dtype=np.float64).reshape(3)
+    extent_prod = float(np.prod(extent))
+    if extent_prod <= 0.0 or n_voxels < 1:
+        return np.ones(3, dtype=np.int64), 1.0
+    spacing = (extent_prod / float(n_voxels)) ** (1.0 / 3.0)
+    new_size = np.maximum(1, np.rint(extent / spacing)).astype(np.int64)
+    while (int(np.prod(new_size, dtype=np.int64)) > n_voxels
+           and spacing < 1.0e6):
+        spacing *= 1.01
+        new_size = np.maximum(1, np.rint(extent / spacing)).astype(np.int64)
+    return new_size, float(spacing)
+
+
+def centerline_grid_size(size, spacing):
+    """Choose the centerline grid from the native size and a voxel budget.
+
+    The native grid is compared with an isotropic grid of
+    ``_TARGET_CENTERLINE_VOXELS`` voxels. The one with more voxels is kept.
+    A result above ``_MAX_CENTERLINE_VOXELS`` is replaced by an isotropic
+    grid of that many voxels.
+
+    Parameters
+    ----------
+    size : sequence of int
+        Current voxel counts, one per axis.
+    spacing : sequence of float
+        Current spacing in millimeters, one per axis.
+
+    Returns
+    -------
+    new_size : tuple of int
+    new_spacing : tuple of float
+        Millimeters. Equal to ``spacing`` when the input grid is kept.
+    target_spacing : float or None
+        Isotropic spacing in millimeters when the grid changes. None when
+        the input grid is kept.
+    resample : bool
+        False when ``new_size`` is the input size.
+    """
+    size_in = tuple(int(v) for v in np.asarray(size, dtype=np.int64).reshape(3))
+    spacing_in = tuple(
+        float(v) for v in np.asarray(spacing, dtype=np.float64).reshape(3))
+    size_f = np.asarray(size_in, dtype=np.float64)
+    spacing_f = np.asarray(spacing_in, dtype=np.float64)
+    extent = size_f * spacing_f
+    native_voxels = int(np.prod(np.asarray(size_in, dtype=np.int64)))
+
+    budget_size, budget_spacing = _isotropic_grid(
+        extent, _TARGET_CENTERLINE_VOXELS)
+    budget_voxels = int(np.prod(budget_size, dtype=np.int64))
+    if budget_voxels > native_voxels:
+        chosen_size = budget_size
+        chosen_spacing = (budget_spacing, budget_spacing, budget_spacing)
+        chosen_voxels = budget_voxels
+    else:
+        chosen_size = np.asarray(size_in, dtype=np.int64)
+        chosen_spacing = spacing_in
+        chosen_voxels = native_voxels
+
+    if chosen_voxels > _MAX_CENTERLINE_VOXELS:
+        cap_size, cap_spacing = _isotropic_grid(
+            extent, _MAX_CENTERLINE_VOXELS)
+        chosen_size = cap_size
+        chosen_spacing = (cap_spacing, cap_spacing, cap_spacing)
+
+    chosen_size_t = tuple(int(v) for v in chosen_size)
+    if chosen_size_t == size_in:
+        return size_in, spacing_in, None, False
+    return chosen_size_t, tuple(float(v) for v in chosen_spacing), float(
+        chosen_spacing[0]), True
+
+
+def resample_for_centerline(segmentation, verbose=False):
+    """Resample ``segmentation`` onto the centerline grid.
+
+    Returns
+    -------
+    segmentation : sitk.Image
+    was_resampled : bool
+    """
+    old_size = tuple(int(v) for v in segmentation.GetSize())
+    old_spacing = tuple(float(v) for v in segmentation.GetSpacing())
+    new_size, new_spacing, target, resample = centerline_grid_size(
+        old_size, old_spacing)
+    n_voxels = int(np.prod(new_size, dtype=np.int64))
+    if verbose:
+        target_text = "native" if target is None else f"{target:.4f} mm"
+        print(
+            f"    Centerline grid: size {old_size} spacing {old_spacing} "
+            f"-> size {new_size} spacing {new_spacing} "
+            f"({n_voxels} voxels, target {target_text})"
+        )
+    if not resample:
+        return segmentation, False
+
+    resampled = sitk.Resample(
+        segmentation,
+        list(new_size),
+        sitk.Transform(),
+        sitk.sitkNearestNeighbor,
+        segmentation.GetOrigin(),
+        list(new_spacing),
+        segmentation.GetDirection(),
+        0,
+        segmentation.GetPixelID())
+    return resampled, True
+
+
 def calc_centerline_fmm(segmentation, seed=None, targets=None,
-                        min_res=300, out_dir=None, write_files=False,
+                        out_dir=None, write_files=False,
                         move_target_if_fail=False,
                         relax_factor=1, return_target=False,
                         return_target_all=False,
@@ -1381,27 +1499,11 @@ def calc_centerline_fmm(segmentation, seed=None, targets=None,
     """
     output = None
     original_segmentation = segmentation
-    was_resampled = False
     if verbose:
         print(f"Resolution of segmentation: {segmentation.GetSize()}")
 
-    # Resample if segmentation resolution is too low
-    if segmentation.GetSize()[2] < min_res:
-        print(f"    Resampling segmentation from size {segmentation.GetSize()} to size {min_res}")
-        # Divide spacing so that the size is at least 50
-        divide = segmentation.GetSize()[2] / min_res
-        segmentation = sitk.Resample(segmentation,
-                                     [int(x/divide) for x in segmentation
-                                      .GetSize()],
-                                     sitk.Transform(),
-                                     sitk.sitkNearestNeighbor,
-                                     segmentation.GetOrigin(),
-                                     [x*divide for x in segmentation
-                                      .GetSpacing()],
-                                     segmentation.GetDirection(), 0,
-                                     segmentation.GetPixelID())
-        was_resampled = True
-        print(f"    New size: {segmentation.GetSize()}")
+    segmentation, was_resampled = resample_for_centerline(
+        segmentation, verbose=verbose)
 
     # Keep user-provided index coordinates anatomically consistent with
     # the resampled grid by mapping old-index -> physical -> new-index.
@@ -1424,10 +1526,7 @@ def calc_centerline_fmm(segmentation, seed=None, targets=None,
                     segmentation.TransformPhysicalPointToIndex(target_phys))
                 targets_resampled.append(target_resampled)
             targets = targets_resampled
-    # Create distance map
-    distance_map_surf = distance_map_from_seg(segmentation)
-    # Switch sign of distance map
-    distance_map_surf = distance_map_surf * -1
+    distance_map_surf = distance_map_from_seg(segmentation) * -1
     distance_map_surf_np = sitk.GetArrayFromImage(distance_map_surf).transpose(2, 1, 0)
     # Get maximum value of distance map
     max_surf = distance_map_surf_np.max()
@@ -3392,7 +3491,7 @@ def snap_end_points_to_lumen(end_points, radius_np, spacing, direction=None):
 
 
 def calc_multi_component_centerlines(segmentation, nr_seeds=None,
-                                   min_res=300, out_dir=None, write_files=False,
+                                   out_dir=None, write_files=False,
                                    move_target_if_fail=False, relax_factor=1,
                                    verbose=False, return_failed=False,
                                    post_process_kwargs=None):
@@ -3403,7 +3502,10 @@ def calc_multi_component_centerlines(segmentation, nr_seeds=None,
     This function:
     1. Analyzes the segmentation to find disconnected bodies
     2. Creates optimal seed points for each disconnected body
-    3. Calculates centerlines using fast marching method for each seed
+    3. Calculates centerlines using fast marching method for each seed.
+       Each component's grid is the native grid or an isotropic 260 million
+       voxel grid, whichever has more voxels, and is never larger than
+       260 million voxels. See :func:`centerline_grid_size`.
     4. Combines all centerlines into a unified polydata structure
     
     Parameters
@@ -3414,9 +3516,6 @@ def calc_multi_component_centerlines(segmentation, nr_seeds=None,
         Number of seeds to generate. If None, creates one seed per disconnected body.
         If the requested number exceeds the number of disconnected bodies, it will be
         automatically reduced to match the number of available bodies with a warning.
-    min_res : int, optional
-        Minimum resolution for centerline calculation. If segmentation resolution
-        is lower, it will be resampled. Defaults to 300.
     out_dir : str, optional
         Output directory for intermediate files. Defaults to None.
     write_files : bool, optional
@@ -3592,7 +3691,6 @@ def calc_multi_component_centerlines(segmentation, nr_seeds=None,
                 segmentation_body, 
                 seed=seed,
                 targets=None,  # Let calc_centerline_fmm find targets automatically
-                min_res=min_res,
                 out_dir=out_dir,
                 write_files=write_files,
                 move_target_if_fail=move_target_if_fail,
@@ -3944,7 +4042,6 @@ if __name__ == '__main__':
             centerline_multi, success_info = calc_multi_component_centerlines(
                 segmentation,
                 nr_seeds=None,
-                min_res=700,
                 out_dir=out_dir,
                 write_files=write_files,
                 move_target_if_fail=False,

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/modules/initialization.py

@@ -255,7 +255,6 @@ def initialize_from_seg(segmentation,
     centerline, success_info = calc_multi_component_centerlines(
         segmentation,
         nr_seeds=2,
-        min_res=500,
         out_dir=dir_output,
         write_files=write_samples,
         move_target_if_fail=False,

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/modules/simvascular.py

@@ -261,7 +261,7 @@ def resample_path_like_simvascular(
     return spline_points
 
 
-def reslice_size_for_unit(unit: str = "cm") -> str:
+def reslice_size_for_unit(unit: str = "mm") -> str:
     """SimVascular XML ``reslice_size`` for the project's physical units.
 
     SimVascular expects ``5`` when coordinates are in centimeters and ``50``
@@ -279,7 +279,7 @@ _MM_CONTOUR_POINT_2D = 3.0
 _MM_CONTOUR_POINT_3D = 5.0
 
 
-def _physical_unit_scale(unit: str = "cm") -> float:
+def _physical_unit_scale(unit: str = "mm") -> float:
     """Scale factor from mm-native display sizes to project ``unit``."""
     if str(unit).strip().lower() == "mm":
         return 1.0
@@ -294,7 +294,7 @@ def _format_sv_display_size(value: float) -> str:
     return f"{v:g}"
 
 
-def path_point_display_sizes_for_unit(unit: str = "cm") -> tuple:
+def path_point_display_sizes_for_unit(unit: str = "mm") -> tuple:
     """
     SimVascular path XML ``point_2D_display_size`` and ``point_size`` (3D).
 
@@ -307,7 +307,7 @@ def path_point_display_sizes_for_unit(unit: str = "cm") -> tuple:
     )
 
 
-def contour_point_display_sizes_for_unit(unit: str = "cm") -> tuple:
+def contour_point_display_sizes_for_unit(unit: str = "mm") -> tuple:
     """
     SimVascular contour group XML ``point_2D_display_size`` and ``point_size`` (3D).
 
@@ -523,7 +523,7 @@ def create_pth(
     calculation_number=100,
     spacing=0.0,
     further_subdivision_number=10,
-    unit="cm",
+    unit="mm",
 ):
     """Create a SimVascular-style .pth XML file given a list of (x,y,z) points.
 

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/modules/simvascular_contour.py

@@ -38,6 +38,7 @@ from .simvascular import (
     _perpendicular_normal_unit,
     compute_tangents,
     contour_point_display_sizes_for_unit,
+    reslice_size_for_unit,
     indent,
     resample_path_like_simvascular,
 )
@@ -669,12 +670,12 @@ def write_ctgr(
     contours_xyz: Sequence[Optional[np.ndarray]],
     output_path: str,
     *,
-    reslice_size: str = "5",
+    reslice_size: Optional[str] = None,
     lofting_attribs: Optional[Dict[str, str]] = None,
     contour_method: str = "LevelSet",
     n_control_points: int = DEFAULT_SPLINE_POLYGON_N_CONTROL,
     subdivision_spacing: Optional[float] = None,
-    unit: str = "cm",
+    unit: str = "mm",
 ) -> str:
     """
     Write a SimVascular ``.ctgr`` contour group XML.
@@ -690,6 +691,8 @@ def write_ctgr(
     """
     if len(path_points) != len(contours_xyz):
         raise ValueError("path_points and contours_xyz must have the same length")
+    if reslice_size is None:
+        reslice_size = reslice_size_for_unit(unit)
 
     loft = dict(_DEFAULT_LOFTING_ATTRIBS)
     if lofting_attribs:
@@ -712,7 +715,10 @@ def write_ctgr(
     ET.SubElement(ts, "lofting_parameters", loft)
 
     if subdivision_spacing is None or float(subdivision_spacing) <= 0.0:
-        subdivision_spacing = 0.078125
+        # ~0.8 mm between contour samples; centimeter projects use one tenth.
+        subdivision_spacing = (
+            0.78125 if str(unit).strip().lower() == "mm" else 0.078125
+        )
     subdiv_str = _fmt_coord(float(subdivision_spacing))
     n_spline = max(4, int(n_control_points))
     n_xml_ctrl = n_spline + SIMVASCULAR_SPLINE_RESERVED_CONTROLS
@@ -862,7 +868,7 @@ def write_ctgr_for_pth(
     contour_method: str = "LevelSet",
     component_selection: str = "closest_to_path",
     n_control_points: int = DEFAULT_SPLINE_POLYGON_N_CONTROL,
-    unit: str = "cm",
+    unit: str = "mm",
 ) -> str:
     """
     Parse ``pth_path``, extract contours from ``sitk_volume``, write ``.ctgr``.

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/modules/tracing.py

@@ -95,7 +95,7 @@ class TracingContext:
     max_n_branches: int
     max_n_steps_per_branch: int
     global_config: Mapping[str, Any]
-    unit: str = "cm"
+    unit: str = "mm"
     scale: float = 1.0
     seg_file: Optional[Union[str, sitk.Image]] = None
     start_seg: Any = None
@@ -193,7 +193,7 @@ def trace_centerline(
     max_n_branches,
     max_n_steps_per_branch,
     global_config,
-    unit='cm',
+    unit='mm',
     scale=1,
     seg_file=None,
     start_seg=None,
@@ -244,7 +244,7 @@ def trace_centerline(
     global_config : dict
         Configuration parameters
     unit : str, optional
-        Image units ('cm' or 'mm'), default 'cm'
+        Image units ('mm' or 'cm'), default 'mm'
     scale : float, optional
         Scaling factor for image data, default 1
     seg_file : str or sitk.Image, optional
@@ -745,7 +745,6 @@ def trace_centerline(
                  success) = calc_centerline_fmm(predicted_vessel,
                                                 seed,
                                                 targets,
-                                                min_res=40,
                                                 post_process_kwargs={
                                                     'merge_method': global_config.get(
                                                         'CENTERLINE_MERGE_METHOD',

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/pipeline/post.py

@@ -109,7 +109,7 @@ def run_global_centerline_single(
     case_name: Optional[str] = None,
     merge_method: str = "clean",
     directory_data: Optional[str] = None,
-    unit: str = "cm",
+    unit: str = "mm",
     global_config: Optional[Mapping[str, Any]] = None,
 ) -> None:
     """
@@ -193,7 +193,7 @@ def run_global_centerline_batch(
     out_dir: Optional[str] = None,
     merge_method: str = "clean",
     directory_data: Optional[str] = None,
-    unit: str = "cm",
+    unit: str = "mm",
     global_config: Optional[Mapping[str, Any]] = None,
 ) -> None:
     """Batch variant of :func:`run_global_centerline_single` using filename-derived case ids.

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/tests/test_api_entry.py

@@ -67,6 +67,8 @@ def test_tracing_options_defaults():
     assert opts.max_n_steps == 1000
     assert opts.fold == "all"
     assert opts.force_cpu is False
+    assert opts.unit == "mm"
+    assert opts.scale == 1.0
 
 
 def test_run_tracing_builds_context_and_calls_tracing(monkeypatch):

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/tests/test_centerline_backtracking.py

@@ -6,6 +6,7 @@ import SimpleITK as sitk
 from seqseg.modules.centerline import (
     backtracking_gradient,
     calc_centerline_fmm,
+    centerline_grid_size,
     cluster_map,
     masked_world_frame_gradient,
     snap_end_points_to_lumen,
@@ -160,8 +161,59 @@ def test_automatic_targets_reach_a_seed_away_from_the_widest_voxel():
     seed = np.array([10.0, 6.0, 6.0])
 
     _centerline, success, successes = calc_centerline_fmm(
-        image, seed=seed, targets=None, min_res=10,
+        image, seed=seed, targets=None,
         return_success_list=True)
 
     assert success
     assert all(successes)
+
+
+def test_centerline_grid_refines_the_s008_crop_to_260_million():
+    size, spacing, _target, resample = centerline_grid_size(
+        (325, 294, 252), (0.39453125, 0.39453125, 0.4))
+    assert resample is True
+    assert size == (715, 647, 562)
+    assert spacing[0] == spacing[1] == spacing[2]
+    assert abs(spacing[0] - 0.179) < 0.01
+    assert int(np.prod(size)) <= 260_000_000
+    assert size[0] > 325 and size[2] > 252
+
+
+def test_centerline_grid_refines_a_half_millimeter_crop_to_260_million():
+    size, spacing, _target, resample = centerline_grid_size(
+        (320, 289, 184), (0.5, 0.5, 0.5))
+    assert resample is True
+    assert size == (786, 710, 452)
+    assert spacing[0] == spacing[1] == spacing[2]
+    assert abs(spacing[0] - 0.204) < 0.01
+    assert int(np.prod(size)) <= 260_000_000
+
+
+def test_centerline_grid_refines_a_thick_slice_axis():
+    size, spacing, _target, resample = centerline_grid_size(
+        (256, 256, 40), (0.7, 0.7, 3.0))
+    assert resample is True
+    assert size == (722, 722, 484)
+    assert int(np.prod(size)) <= 260_000_000
+    assert spacing[0] == spacing[1] == spacing[2]
+    assert spacing[2] < 0.7
+
+
+def test_centerline_grid_caps_a_billion_voxels_at_260_million():
+    size, spacing, _target, resample = centerline_grid_size(
+        (1000, 1000, 1000), (0.5, 0.5, 0.5))
+    assert resample is True
+    assert size == (638, 638, 638)
+    assert spacing[0] == spacing[1] == spacing[2]
+    assert abs(spacing[0] - 0.783) < 0.01
+    assert int(np.prod(size)) <= 260_000_000
+
+
+def test_centerline_grid_keeps_a_native_grid_at_the_budget():
+    size, spacing, target, resample = centerline_grid_size(
+        (638, 638, 638), (0.5, 0.5, 0.5))
+    assert resample is False
+    assert target is None
+    assert size == (638, 638, 638)
+    assert spacing == (0.5, 0.5, 0.5)
+    assert int(np.prod(size)) <= 260_000_000

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg/tests/test_cli_helpers.py

@@ -356,6 +356,39 @@ def test_parser_run_single_cpu_flag():
         ]
     )
     assert ns.force_cpu is True
+    assert ns.unit == "mm"
+
+
+def test_parser_unit_defaults_to_mm():
+    parser = _build_parser()
+    batch = parser.parse_args(["run", "batch"])
+    assert batch.unit == "mm"
+    plus = parser.parse_args(["run", "plus", "batch"])
+    assert plus.unit == "mm"
+    post = parser.parse_args(
+        [
+            "post",
+            "global-centerline",
+            "single",
+            "--seg",
+            "/tmp/seg.mha",
+            "--out",
+            "/tmp/out.vtp",
+        ]
+    )
+    assert post.unit == "mm"
+    post_batch = parser.parse_args(
+        [
+            "post",
+            "global-centerline",
+            "batch",
+            "--seg-dir",
+            "/tmp/segs",
+            "--seg-glob",
+            "*.mha",
+        ]
+    )
+    assert post_batch.unit == "mm"
 
 
 def test_parser_init_dataset():

{seqseg-2.2.0 → seqseg-2.2.2}/seqseg.egg-info/PKG-INFO

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