seqseg 2.2.1__tar.gz → 2.2.2__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seqseg"
-version = "2.2.1"
+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.1 → 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.1 → 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.1 → 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.1 → seqseg-2.2.2}/seqseg/modules/centerline.py

@@ -1339,19 +1339,36 @@ def backtracking_gradient(gradient, distance_map_surf_np,
     return points, success
 
 
-# Centerline grids are isotropic. Three voxels across the inscribed radius
-# keeps the lumen wide enough for the finite-difference gradient. The
-# spacing clamp refuses both a one-voxel tube and a needlessly fine grid,
-# and the voxel budget caps the float64 gradient.
-_VOXELS_PER_RADIUS = 3.0
-_MIN_SPACING_MM = 0.35
-_MAX_SPACING_MM = 1.0
-_MAX_CENTERLINE_VOXELS = 20_000_000
-_GRID_SIZE_TOLERANCE = 0.10
+# 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 centerline_grid_size(size, spacing, radius_mm):
-    """Choose an isotropic centerline grid from the inscribed radius.
+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
     ----------
@@ -1359,9 +1376,6 @@ def centerline_grid_size(size, spacing, radius_mm):
         Current voxel counts, one per axis.
     spacing : sequence of float
         Current spacing in millimeters, one per axis.
-    radius_mm : float
-        Maximum inscribed radius in millimeters. A non-positive or
-        non-finite radius keeps the input grid.
 
     Returns
     -------
@@ -1369,70 +1383,66 @@ def centerline_grid_size(size, spacing, radius_mm):
     new_spacing : tuple of float
         Millimeters. Equal to ``spacing`` when the input grid is kept.
     target_spacing : float or None
-        Spacing the radius and voxel budget asked for, before the
-        10% size check. None when the radius does not define a grid.
+        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))
-    radius = float(radius_mm)
-    if not np.isfinite(radius) or radius <= 0.0:
-        return size_in, spacing_in, None, False
-
     size_f = np.asarray(size_in, dtype=np.float64)
     spacing_f = np.asarray(spacing_in, dtype=np.float64)
     extent = size_f * spacing_f
-    target = float(np.clip(
-        radius / _VOXELS_PER_RADIUS, _MIN_SPACING_MM, _MAX_SPACING_MM))
-    extent_prod = float(np.prod(extent))
-    if extent_prod > 0.0 and target > 0.0:
-        if extent_prod / (target ** 3) > _MAX_CENTERLINE_VOXELS:
-            target = (extent_prod / _MAX_CENTERLINE_VOXELS) ** (1.0 / 3.0)
-    new_size = np.maximum(1, np.rint(extent / target)).astype(np.int64)
-    # Rounding can land a hair over the budget the closed form aimed at.
-    while (int(np.prod(new_size, dtype=np.int64)) > _MAX_CENTERLINE_VOXELS
-           and target < 1.0e6):
-        target *= 1.01
-        new_size = np.maximum(1, np.rint(extent / target)).astype(np.int64)
-    if np.all(np.abs(new_size.astype(np.float64) - size_f)
-              <= _GRID_SIZE_TOLERANCE * np.maximum(size_f, 1.0)):
-        return size_in, spacing_in, float(target), False
-    return (tuple(int(v) for v in new_size),
-            (float(target), float(target), float(target)),
-            float(target), True)
+    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.
 
-    The inscribed-radius distance map (positive inside) is returned when
-    the grid is unchanged, so the caller can skip a second distance
-    transform. A resampled image returns ``None`` for that map.
-
     Returns
     -------
     segmentation : sitk.Image
-    distance_map : sitk.Image or None
     was_resampled : bool
     """
-    distance = distance_map_from_seg(segmentation) * -1
-    radius = float(sitk.GetArrayViewFromImage(distance).max())
     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, radius)
+        old_size, old_spacing)
     n_voxels = int(np.prod(new_size, dtype=np.int64))
     if verbose:
-        target_text = "n/a" if target is None else f"{target:.4f} mm"
+        target_text = "native" if target is None else f"{target:.4f} mm"
         print(
             f"    Centerline grid: size {old_size} spacing {old_spacing} "
-            f"radius {radius:.3f} mm target spacing {target_text} "
-            f"-> size {new_size} ({n_voxels} voxels)"
+            f"-> size {new_size} spacing {new_spacing} "
+            f"({n_voxels} voxels, target {target_text})"
         )
     if not resample:
-        return segmentation, distance, False
+        return segmentation, False
 
     resampled = sitk.Resample(
         segmentation,
@@ -1444,7 +1454,7 @@ def resample_for_centerline(segmentation, verbose=False):
         segmentation.GetDirection(),
         0,
         segmentation.GetPixelID())
-    return resampled, None, True
+    return resampled, True
 
 
 def calc_centerline_fmm(segmentation, seed=None, targets=None,
@@ -1492,7 +1502,7 @@ def calc_centerline_fmm(segmentation, seed=None, targets=None,
     if verbose:
         print(f"Resolution of segmentation: {segmentation.GetSize()}")
 
-    segmentation, distance_map_surf, was_resampled = resample_for_centerline(
+    segmentation, was_resampled = resample_for_centerline(
         segmentation, verbose=verbose)
 
     # Keep user-provided index coordinates anatomically consistent with
@@ -1516,9 +1526,7 @@ def calc_centerline_fmm(segmentation, seed=None, targets=None,
                     segmentation.TransformPhysicalPointToIndex(target_phys))
                 targets_resampled.append(target_resampled)
             targets = targets_resampled
-    # The radius check already built this map when the grid was kept.
-    if distance_map_surf is None:
-        distance_map_surf = distance_map_from_seg(segmentation) * -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()
@@ -3495,8 +3503,9 @@ def calc_multi_component_centerlines(segmentation, nr_seeds=None,
     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.
-       Each component's grid is chosen from its inscribed radius and a
-       voxel budget; see :func:`centerline_grid_size`.
+       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

{seqseg-2.2.1 → 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.1 → 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.1 → 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

{seqseg-2.2.1 → 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.1 → 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.1 → seqseg-2.2.2}/seqseg/tests/test_centerline_backtracking.py

@@ -168,39 +168,52 @@ def test_automatic_targets_reach_a_seed_away_from_the_widest_voxel():
     assert all(successes)
 
 
-def test_centerline_grid_keeps_a_fine_isotropic_crop():
-    """A 0.5 mm crop with a 1.18 mm radius is already within 10% of the target."""
+def test_centerline_grid_refines_the_s008_crop_to_260_million():
     size, spacing, _target, resample = centerline_grid_size(
-        (320, 289, 184), (0.5, 0.5, 0.5), 1.18)
-    assert resample is False
-    assert size == (320, 289, 184)
-    assert spacing == (0.5, 0.5, 0.5)
+        (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), 2.0)
+        (256, 256, 40), (0.7, 0.7, 3.0))
     assert resample is True
-    assert size == (269, 269, 180)
-    assert int(np.prod(size)) <= 20_000_000
+    assert size == (722, 722, 484)
+    assert int(np.prod(size)) <= 260_000_000
     assert spacing[0] == spacing[1] == spacing[2]
-    assert spacing[2] < 1.0
+    assert spacing[2] < 0.7
 
 
-def test_centerline_grid_coarsens_to_the_voxel_budget():
+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), 3.0)
+        (1000, 1000, 1000), (0.5, 0.5, 0.5))
     assert resample is True
-    assert int(np.prod(size)) <= 20_000_000
-    assert spacing[0] > 1.0
-    assert size[0] < 1000
-
-
-def test_centerline_grid_keeps_the_input_when_radius_is_non_positive():
-    for radius in (0.0, -1.0, float("nan")):
-        size, spacing, target, resample = centerline_grid_size(
-            (40, 30, 20), (0.8, 0.8, 2.0), radius)
-        assert resample is False
-        assert target is None
-        assert size == (40, 30, 20)
-        assert spacing == (0.8, 0.8, 2.0)
+    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.1 → 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.1 → seqseg-2.2.2}/seqseg.egg-info/PKG-INFO

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