voidspace 0.1.0__tar.gz → 0.1.4__tar.gz

{voidspace-0.1.0/src/voidspace.egg-info → voidspace-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidspace
-Version: 0.1.0
+Version: 0.1.4
 Summary: Spacing-aware voidspace analysis for HR-pQCT segmentations
 Author: Matthias Walle
 License-Expression: MIT
@@ -36,8 +36,10 @@ Dynamic: license-file
 Spacing-aware voidspace analysis for HR-pQCT segmentations.
 
 `voidspace` is a standalone logic package. It does not segment bone, register
-scans, create common regions, or resample images. It expects inputs that are
-already in the image space to analyze.
+scans or create common regions. It expects inputs already in the same physical
+space. File workflows place cropped masks on the reference grid with
+nearest-neighbor resampling using origin, spacing, and direction; this does not
+estimate registration between scans.
 
 The command line interface reads common SimpleITK image formats and Scanco AIM
 masks. AIM masks are read in native scaling, interpreted as foreground where
@@ -55,8 +57,19 @@ nonzero, and written back as native binary AIM masks using the input geometry.
 
 When no periosteal mask is supplied, the segmentation-only workflow estimates
 the analysis domain from the closed segmentation by excluding background
-connected to the image border. Supplying an explicit mask remains preferred
-when that contour is available.
+connected to lateral (in-plane) image borders, not the two scan ends. Supplying
+an explicit full bone mask remains preferred, especially for breached cortex.
+
+Closing and erosion use edge continuation along the scan axis before cropping
+back to the acquired volume. This assumes the endpoint cross-sections continue
+beyond the scan, rather than treating acquisition ends as empty biological space.
+Physical morphology radii and volume thresholds are unchanged. This boundary
+policy is not a validation of exact scanner/IPL equivalence.
+
+All voidspace includes large voidspace: the large map is a size-filtered subset.
+For common-region reporting, compute maps on the full bone domain with `run-case`,
+then use `analyze-maps` to clip and measure without recomputing morphology at the
+common-region boundaries. Force-rerun old outputs to apply these corrections.
 
 ## Algorithm
 
@@ -91,6 +104,14 @@ voidspace run-case \
   --output-dir voidspace-out
 ```
 
+```bash
+voidspace analyze-maps \
+  --large-void voidspace-out/voidspace_large_mask.AIM \
+  --all-void voidspace-out/voidspace_all_mask.AIM \
+  --mask common_region.AIM \
+  --output-dir voidspace-common-region
+```
+
 ```bash
 voidspace compare \
   --baseline-void baseline_voidspace_large_mask.AIM \
@@ -99,8 +120,8 @@ voidspace compare \
   --output-dir voidspace-change
 ```
 
-`--mask` is optional for both commands. Use `--force` to overwrite existing
-outputs.
+`--mask` is optional for `run-case` and `compare`, and required for
+`analyze-maps`. Use `--force` to overwrite existing outputs.
 
 ## Python
 
@@ -128,6 +149,18 @@ result = compare(
 print(result.metrics.net_change_volume_mm3)
 ```
 
+```python
+from voidspace import analyze_maps
+
+result = analyze_maps(
+    large_void_path="voidspace-out/voidspace_large_mask.AIM",
+    all_void_path="voidspace-out/voidspace_all_mask.AIM",
+    mask_path="common_region.AIM",
+    output_dir="voidspace-common-region",
+)
+print(result.metrics.vstv_percent)
+```
+
 ## Citation
 
 For cross-sectional voidspace analysis, cite:

{voidspace-0.1.0 → voidspace-0.1.4}/README.md

@@ -3,8 +3,10 @@
 Spacing-aware voidspace analysis for HR-pQCT segmentations.
 
 `voidspace` is a standalone logic package. It does not segment bone, register
-scans, create common regions, or resample images. It expects inputs that are
-already in the image space to analyze.
+scans or create common regions. It expects inputs already in the same physical
+space. File workflows place cropped masks on the reference grid with
+nearest-neighbor resampling using origin, spacing, and direction; this does not
+estimate registration between scans.
 
 The command line interface reads common SimpleITK image formats and Scanco AIM
 masks. AIM masks are read in native scaling, interpreted as foreground where
@@ -22,8 +24,19 @@ nonzero, and written back as native binary AIM masks using the input geometry.
 
 When no periosteal mask is supplied, the segmentation-only workflow estimates
 the analysis domain from the closed segmentation by excluding background
-connected to the image border. Supplying an explicit mask remains preferred
-when that contour is available.
+connected to lateral (in-plane) image borders, not the two scan ends. Supplying
+an explicit full bone mask remains preferred, especially for breached cortex.
+
+Closing and erosion use edge continuation along the scan axis before cropping
+back to the acquired volume. This assumes the endpoint cross-sections continue
+beyond the scan, rather than treating acquisition ends as empty biological space.
+Physical morphology radii and volume thresholds are unchanged. This boundary
+policy is not a validation of exact scanner/IPL equivalence.
+
+All voidspace includes large voidspace: the large map is a size-filtered subset.
+For common-region reporting, compute maps on the full bone domain with `run-case`,
+then use `analyze-maps` to clip and measure without recomputing morphology at the
+common-region boundaries. Force-rerun old outputs to apply these corrections.
 
 ## Algorithm
 
@@ -58,6 +71,14 @@ voidspace run-case \
   --output-dir voidspace-out
 ```
 
+```bash
+voidspace analyze-maps \
+  --large-void voidspace-out/voidspace_large_mask.AIM \
+  --all-void voidspace-out/voidspace_all_mask.AIM \
+  --mask common_region.AIM \
+  --output-dir voidspace-common-region
+```
+
 ```bash
 voidspace compare \
   --baseline-void baseline_voidspace_large_mask.AIM \
@@ -66,8 +87,8 @@ voidspace compare \
   --output-dir voidspace-change
 ```
 
-`--mask` is optional for both commands. Use `--force` to overwrite existing
-outputs.
+`--mask` is optional for `run-case` and `compare`, and required for
+`analyze-maps`. Use `--force` to overwrite existing outputs.
 
 ## Python
 
@@ -95,6 +116,18 @@ result = compare(
 print(result.metrics.net_change_volume_mm3)
 ```
 
+```python
+from voidspace import analyze_maps
+
+result = analyze_maps(
+    large_void_path="voidspace-out/voidspace_large_mask.AIM",
+    all_void_path="voidspace-out/voidspace_all_mask.AIM",
+    mask_path="common_region.AIM",
+    output_dir="voidspace-common-region",
+)
+print(result.metrics.vstv_percent)
+```
+
 ## Citation
 
 For cross-sectional voidspace analysis, cite:

{voidspace-0.1.0 → voidspace-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "voidspace"
-version = "0.1.0"
+version = "0.1.4"
 description = "Spacing-aware voidspace analysis for HR-pQCT segmentations"
 readme = "README.md"
 requires-python = ">=3.11"

{voidspace-0.1.0 → voidspace-0.1.4}/src/voidspace/__init__.py

@@ -10,9 +10,9 @@ from voidspace.models import (
     VoidspaceRunResult,
 )
 from voidspace.segment import segment_voidspace
-from voidspace.workflows import compare, run_case
+from voidspace.workflows import analyze_maps, compare, intersect_masks, run_case
 
-__version__ = "0.1.0"
+__version__ = "0.1.4"
 
 __all__ = [
     "VoidspaceChangeMasks",
@@ -23,8 +23,10 @@ __all__ = [
     "VoidspaceParameters",
     "VoidspaceRunResult",
     "__version__",
+    "analyze_maps",
     "classify_voidspace_change",
     "compare",
+    "intersect_masks",
     "measure_voidspace",
     "measure_voidspace_change",
     "run_case",

{voidspace-0.1.0 → voidspace-0.1.4}/src/voidspace/cli.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from typing import Sequence
 
 from voidspace.models import VoidspaceParameters
-from voidspace.workflows import compare, run_case
+from voidspace.workflows import analyze_maps, compare, intersect_masks, run_case
 
 
 def _parameters_from_args(args: argparse.Namespace) -> VoidspaceParameters:
@@ -64,6 +64,20 @@ def build_parser() -> argparse.ArgumentParser:
     _add_parameter_arguments(run_case)
     run_case.set_defaults(func=_cmd_run_case)
 
+    analyze = subparsers.add_parser("analyze-maps", help="Measure existing voidspace maps inside a mask.")
+    analyze.add_argument("--large-void", type=Path, required=True)
+    analyze.add_argument("--all-void", type=Path, required=True)
+    analyze.add_argument(
+        "--mask",
+        type=Path,
+        required=True,
+        help="Analysis-domain mask aligned with both voidspace maps.",
+    )
+    analyze.add_argument("--output-dir", type=Path, required=True)
+    analyze.add_argument("--connectivity", type=int, choices=(1, 2, 3), default=VoidspaceParameters.xtremectii_defaults().connectivity)
+    analyze.add_argument("--force", action="store_true")
+    analyze.set_defaults(func=_cmd_analyze_maps)
+
     compare = subparsers.add_parser("compare", help="Compare already aligned voidspace masks.")
     compare.add_argument("--baseline-void", type=Path, required=True)
     compare.add_argument("--followup-void", type=Path, required=True)
@@ -76,6 +90,18 @@ def build_parser() -> argparse.ArgumentParser:
     compare.add_argument("--force", action="store_true")
     compare.set_defaults(func=_cmd_compare)
 
+    intersect = subparsers.add_parser("intersect-masks", help="Write the intersection of aligned masks.")
+    intersect.add_argument(
+        "--mask",
+        type=Path,
+        required=True,
+        action="append",
+        help="Mask to include in the intersection. Pass at least two.",
+    )
+    intersect.add_argument("--output", type=Path, required=True)
+    intersect.add_argument("--force", action="store_true")
+    intersect.set_defaults(func=_cmd_intersect_masks)
+
     return parser
 
 
@@ -90,6 +116,18 @@ def _cmd_run_case(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_analyze_maps(args: argparse.Namespace) -> int:
+    analyze_maps(
+        large_void_path=args.large_void,
+        all_void_path=args.all_void,
+        mask_path=args.mask,
+        output_dir=args.output_dir,
+        connectivity=args.connectivity,
+        force=args.force,
+    )
+    return 0
+
+
 def _cmd_compare(args: argparse.Namespace) -> int:
     compare(
         baseline_void_path=args.baseline_void,
@@ -101,6 +139,11 @@ def _cmd_compare(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_intersect_masks(args: argparse.Namespace) -> int:
+    intersect_masks(args.mask, output_path=args.output, force=args.force)
+    return 0
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)

{voidspace-0.1.0 → voidspace-0.1.4}/src/voidspace/io.py

@@ -113,14 +113,14 @@ def _write_aim_mask(mask: np.ndarray, reference: AimReference, path: Path) -> No
 def write_mask_like(mask: np.ndarray, reference: ImageReference, path: Path | str) -> Path:
     output = Path(path)
     output.parent.mkdir(parents=True, exist_ok=True)
-    if isinstance(reference, AimReference) or is_aim_path(output):
+    if is_aim_path(output):
         if not isinstance(reference, AimReference):
             raise ValueError("AIM output requires an AIM reference image.")
         _write_aim_mask(mask, reference, output)
         return output
 
     image = sitk.GetImageFromArray(np.asarray(mask, dtype=np.uint8))
-    image.CopyInformation(reference)
+    image.CopyInformation(reference.image if isinstance(reference, AimReference) else reference)
     sitk.WriteImage(image, str(output))
     return output
 

{voidspace-0.1.0 → voidspace-0.1.4}/src/voidspace/morphology.py

@@ -66,7 +66,7 @@ def remove_small_components(mask: np.ndarray, min_voxels: int, connectivity: int
     return keep[labels]
 
 
-def remove_border_connected_components(mask: np.ndarray, connectivity: int = 3) -> np.ndarray:
+def remove_border_connected_components(mask: np.ndarray, connectivity: int = 3, *, axes=(0, 1, 2)) -> np.ndarray:
     mask = np.asarray(mask, dtype=bool)
     if mask.ndim != 3:
         raise ValueError("mask must be a 3D array")
@@ -75,12 +75,10 @@ def remove_border_connected_components(mask: np.ndarray, connectivity: int = 3)
     if count == 0:
         return np.zeros_like(mask, dtype=bool)
 
-    border_labels = set(np.unique(labels[0, :, :]))
-    border_labels.update(np.unique(labels[-1, :, :]))
-    border_labels.update(np.unique(labels[:, 0, :]))
-    border_labels.update(np.unique(labels[:, -1, :]))
-    border_labels.update(np.unique(labels[:, :, 0]))
-    border_labels.update(np.unique(labels[:, :, -1]))
+    border_labels = set()
+    for axis in axes:
+        border_labels.update(np.unique(np.take(labels, 0, axis=axis)))
+        border_labels.update(np.unique(np.take(labels, -1, axis=axis)))
     border_labels.discard(0)
     remove = np.zeros(count + 1, dtype=bool)
     if border_labels:

{voidspace-0.1.0 → voidspace-0.1.4}/src/voidspace/segment.py

@@ -25,6 +25,17 @@ def _validate_same_shape(*arrays: np.ndarray) -> None:
         raise ValueError(f"all masks must have the same shape, got {sorted(shapes)}")
 
 
+def _continue_scan_ends(mask, footprint, operation):
+    """Continue the endpoint slices, without continuing lateral exterior background."""
+    radius = footprint.shape[0] // 2
+    if radius == 0:
+        return operation(mask, structure=footprint, border_value=0)
+    # Closing contains a dilation and an erosion; retain both operations' support.
+    padding = 2 * radius
+    padded = np.pad(mask, ((padding, padding), (0, 0), (0, 0)), mode="edge")
+    return operation(padded, structure=footprint, border_value=0)[padding:-padding]
+
+
 def segment_voidspace(
     segmentation: np.ndarray,
     spacing_mm: tuple[float, float, float],
@@ -35,7 +46,7 @@ def segment_voidspace(
     bone = _validate_3d("segmentation", segmentation)
     if mask is None:
         domain = np.ones_like(bone, dtype=bool)
-        domain_source = "segmentation_border_background"
+        domain_source = "segmentation_lateral_background"
     else:
         domain = _validate_3d("mask", mask)
         _validate_same_shape(bone, domain)
@@ -47,11 +58,12 @@ def segment_voidspace(
         connectivity=params.connectivity,
     )
     closing_fp = ellipsoid_footprint(params.closing_radius_mm, spacing_mm)
-    filled_bone = ndi.binary_closing(bone_in_domain, structure=closing_fp) & domain
+    filled_bone = _continue_scan_ends(bone_in_domain, closing_fp, ndi.binary_closing) & domain
     if mask is None:
         interior_background = remove_border_connected_components(
             ~filled_bone,
             connectivity=params.connectivity,
+            axes=(1, 2),
         )
         domain = filled_bone | interior_background
         filled_bone = filled_bone & domain
@@ -59,7 +71,7 @@ def segment_voidspace(
 
     if params.boundary_erosion_radius_mm > 0:
         erosion_fp = ellipsoid_footprint(params.boundary_erosion_radius_mm, spacing_mm)
-        candidate_void = ndi.binary_erosion(candidate_void, structure=erosion_fp, border_value=0)
+        candidate_void = _continue_scan_ends(candidate_void, erosion_fp, ndi.binary_erosion)
     candidate_void = candidate_void & domain
 
     all_void = remove_small_components(
@@ -81,5 +93,6 @@ def segment_voidspace(
             "min_large_void_volume_mm3": params.min_large_void_volume_mm3,
             "structuring_element": "spacing_aware_ellipsoid",
             "domain_source": domain_source,
+            "scan_end_policy": "edge_continuation",
         },
     )

voidspace-0.1.4/src/voidspace/workflows.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import SimpleITK as sitk
+
+from voidspace.change import classify_voidspace_change, measure_voidspace_change
+from voidspace.io import AimReference, read_mask, write_mask_like, write_metrics_csv
+from voidspace.metrics import measure_voidspace
+from voidspace.models import VoidspaceCompareResult, VoidspaceParameters, VoidspaceRunResult
+from voidspace.segment import segment_voidspace
+
+
+def _metric_row(metrics, **context):
+    return {
+        **context,
+        "VS.TV": metrics.vstv_percent,
+        "VS.V": metrics.volume_mm3,
+        "Tt.V": metrics.total_volume_mm3,
+        "VS.N": metrics.component_count,
+        "VS.Ar": metrics.projected_area_mm2,
+    }
+
+
+def _mask_extension(reference) -> str:
+    return ".AIM" if isinstance(reference, AimReference) else ".nii.gz"
+
+
+def _reference_image(reference) -> sitk.Image:
+    return reference.image if isinstance(reference, AimReference) else reference
+
+
+def _array_on_reference_grid(array, source_reference, target_reference) -> np.ndarray:
+    source_image = _reference_image(source_reference)
+    target_image = _reference_image(target_reference)
+    if source_image.GetSize() == target_image.GetSize() and all(
+        np.allclose(getattr(source_image, getter)(), getattr(target_image, getter)(), rtol=0, atol=1e-6)
+        for getter in ("GetOrigin", "GetSpacing", "GetDirection")
+    ):
+        return np.asarray(array, dtype=bool)
+    image = sitk.GetImageFromArray(np.asarray(array, dtype=np.uint8))
+    image.CopyInformation(source_image)
+    resampled = sitk.Resample(
+        image,
+        target_image,
+        sitk.Transform(),
+        sitk.sitkNearestNeighbor,
+        0,
+        sitk.sitkUInt8,
+    )
+    return sitk.GetArrayFromImage(resampled).astype(bool)
+
+
+def intersect_masks(
+    mask_paths: list[Path | str] | tuple[Path | str, ...],
+    *,
+    output_path: Path | str,
+    force: bool = False,
+) -> Path:
+    """Write the voxelwise intersection of masks that share one image space."""
+    paths = [Path(path) for path in mask_paths]
+    if len(paths) < 2:
+        raise ValueError("at least two masks are required")
+    output_path = Path(output_path)
+    if output_path.exists() and not force:
+        raise FileExistsError(f"output already exists: {output_path}")
+
+    intersection, spacing, reference = read_mask(paths[0])
+    for path in paths[1:]:
+        mask, mask_spacing, mask_reference = read_mask(path)
+        if mask_spacing != spacing:
+            raise ValueError("all masks must have the same spacing")
+        mask = _array_on_reference_grid(mask, mask_reference, reference)
+        if mask.shape != intersection.shape:
+            raise ValueError("all masks must overlap the reference image space")
+        intersection = intersection & mask
+
+    write_mask_like(intersection, reference, output_path)
+    return output_path
+
+
+def run_case(
+    *,
+    segmentation_path: Path | str,
+    output_dir: Path | str,
+    mask_path: Path | str | None = None,
+    parameters: VoidspaceParameters | None = None,
+    force: bool = False,
+) -> VoidspaceRunResult:
+    """Run cross-sectional voidspace segmentation and measurement for one scan."""
+    output_dir = Path(output_dir)
+    segmentation, spacing, reference = read_mask(segmentation_path)
+    mask_extension = _mask_extension(reference)
+    large_path = output_dir / f"voidspace_large_mask{mask_extension}"
+    all_path = output_dir / f"voidspace_all_mask{mask_extension}"
+    measurements_path = output_dir / "voidspace_measurements.csv"
+
+    existing_outputs = [path for path in (large_path, all_path, measurements_path) if path.exists()]
+    if existing_outputs and not force:
+        raise FileExistsError(f"output already exists: {existing_outputs[0]}")
+
+    if mask_path is not None:
+        domain_mask, _mask_spacing, mask_reference = read_mask(mask_path)
+        domain_mask = _array_on_reference_grid(domain_mask, mask_reference, reference)
+    else:
+        domain_mask = None
+
+    params = parameters or VoidspaceParameters.xtremectii_defaults()
+    masks = segment_voidspace(segmentation, spacing, mask=domain_mask, parameters=params)
+    write_mask_like(masks.large_void, reference, large_path)
+    write_mask_like(masks.all_void, reference, all_path)
+
+    total_mask = domain_mask if domain_mask is not None else (masks.filled_bone | masks.all_void)
+    metrics = measure_voidspace(masks.large_void, total_mask, spacing, connectivity=params.connectivity)
+    write_metrics_csv(measurements_path, [_metric_row(metrics)])
+
+    return VoidspaceRunResult(large_path, all_path, measurements_path, metrics)
+
+
+def analyze_maps(
+    *,
+    large_void_path: Path | str,
+    all_void_path: Path | str,
+    mask_path: Path | str,
+    output_dir: Path | str,
+    force: bool = False,
+    connectivity: int = 3,
+) -> VoidspaceRunResult:
+    """Measure existing voidspace maps within an analysis mask without recomputing maps."""
+    output_dir = Path(output_dir)
+    large_void, spacing, reference = read_mask(large_void_path)
+    mask_extension = _mask_extension(reference)
+    large_path = output_dir / f"voidspace_large_mask{mask_extension}"
+    all_path = output_dir / f"voidspace_all_mask{mask_extension}"
+    measurements_path = output_dir / "voidspace_measurements.csv"
+
+    existing_outputs = [path for path in (large_path, all_path, measurements_path) if path.exists()]
+    if existing_outputs and not force:
+        raise FileExistsError(f"output already exists: {existing_outputs[0]}")
+
+    all_void, _all_spacing, all_reference = read_mask(all_void_path)
+    all_void = _array_on_reference_grid(all_void, all_reference, reference)
+    domain_mask, _mask_spacing, mask_reference = read_mask(mask_path)
+    domain_mask = _array_on_reference_grid(domain_mask, mask_reference, reference)
+
+    masked_large_void = large_void & domain_mask
+    masked_all_void = all_void & domain_mask
+    write_mask_like(masked_large_void, reference, large_path)
+    write_mask_like(masked_all_void, reference, all_path)
+
+    metrics = measure_voidspace(masked_large_void, domain_mask, spacing, connectivity=connectivity)
+    write_metrics_csv(measurements_path, [_metric_row(metrics)])
+
+    return VoidspaceRunResult(large_path, all_path, measurements_path, metrics)
+
+
+def compare(
+    *,
+    baseline_void_path: Path | str,
+    followup_void_path: Path | str,
+    output_dir: Path | str,
+    mask_path: Path | str | None = None,
+    force: bool = False,
+) -> VoidspaceCompareResult:
+    """Compare already aligned baseline and follow-up voidspace masks."""
+    output_dir = Path(output_dir)
+    baseline, spacing, reference = read_mask(baseline_void_path)
+    mask_extension = _mask_extension(reference)
+    stable_path = output_dir / f"voidspace_quiescent_mask{mask_extension}"
+    expanded_path = output_dir / f"voidspace_expanded_mask{mask_extension}"
+    contracted_path = output_dir / f"voidspace_contracted_mask{mask_extension}"
+    measurements_path = output_dir / "voidspace_change_measurements.csv"
+    existing_outputs = [
+        path for path in (stable_path, expanded_path, contracted_path, measurements_path) if path.exists()
+    ]
+    if existing_outputs and not force:
+        raise FileExistsError(f"output already exists: {existing_outputs[0]}")
+
+    followup, _followup_spacing, followup_reference = read_mask(followup_void_path)
+    followup = _array_on_reference_grid(followup, followup_reference, reference)
+
+    domain_mask = None
+    if mask_path is not None:
+        domain_mask, _mask_spacing, mask_reference = read_mask(mask_path)
+        domain_mask = _array_on_reference_grid(domain_mask, mask_reference, reference)
+
+    change = classify_voidspace_change(baseline, followup, mask=domain_mask)
+    write_mask_like(change.stable, reference, stable_path)
+    write_mask_like(change.expanded, reference, expanded_path)
+    write_mask_like(change.contracted, reference, contracted_path)
+    metrics = measure_voidspace_change(change, spacing)
+    write_metrics_csv(
+        measurements_path,
+        [
+            {
+                "stable.VS.V": metrics.stable_volume_mm3,
+                "quiescent.VS.V": metrics.stable_volume_mm3,
+                "expanded.VS.V": metrics.expanded_volume_mm3,
+                "contracted.VS.V": metrics.contracted_volume_mm3,
+                "net.VS.V": metrics.net_change_volume_mm3,
+            }
+        ],
+    )
+    return VoidspaceCompareResult(
+        stable_path,
+        expanded_path,
+        contracted_path,
+        measurements_path,
+        metrics,
+    )
+
+
+run_voidspace_case = run_case
+run_voidspace_change_case = compare

{voidspace-0.1.0 → voidspace-0.1.4/src/voidspace.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidspace
-Version: 0.1.0
+Version: 0.1.4
 Summary: Spacing-aware voidspace analysis for HR-pQCT segmentations
 Author: Matthias Walle
 License-Expression: MIT
@@ -36,8 +36,10 @@ Dynamic: license-file
 Spacing-aware voidspace analysis for HR-pQCT segmentations.
 
 `voidspace` is a standalone logic package. It does not segment bone, register
-scans, create common regions, or resample images. It expects inputs that are
-already in the image space to analyze.
+scans or create common regions. It expects inputs already in the same physical
+space. File workflows place cropped masks on the reference grid with
+nearest-neighbor resampling using origin, spacing, and direction; this does not
+estimate registration between scans.
 
 The command line interface reads common SimpleITK image formats and Scanco AIM
 masks. AIM masks are read in native scaling, interpreted as foreground where
@@ -55,8 +57,19 @@ nonzero, and written back as native binary AIM masks using the input geometry.
 
 When no periosteal mask is supplied, the segmentation-only workflow estimates
 the analysis domain from the closed segmentation by excluding background
-connected to the image border. Supplying an explicit mask remains preferred
-when that contour is available.
+connected to lateral (in-plane) image borders, not the two scan ends. Supplying
+an explicit full bone mask remains preferred, especially for breached cortex.
+
+Closing and erosion use edge continuation along the scan axis before cropping
+back to the acquired volume. This assumes the endpoint cross-sections continue
+beyond the scan, rather than treating acquisition ends as empty biological space.
+Physical morphology radii and volume thresholds are unchanged. This boundary
+policy is not a validation of exact scanner/IPL equivalence.
+
+All voidspace includes large voidspace: the large map is a size-filtered subset.
+For common-region reporting, compute maps on the full bone domain with `run-case`,
+then use `analyze-maps` to clip and measure without recomputing morphology at the
+common-region boundaries. Force-rerun old outputs to apply these corrections.
 
 ## Algorithm
 
@@ -91,6 +104,14 @@ voidspace run-case \
   --output-dir voidspace-out
 ```
 
+```bash
+voidspace analyze-maps \
+  --large-void voidspace-out/voidspace_large_mask.AIM \
+  --all-void voidspace-out/voidspace_all_mask.AIM \
+  --mask common_region.AIM \
+  --output-dir voidspace-common-region
+```
+
 ```bash
 voidspace compare \
   --baseline-void baseline_voidspace_large_mask.AIM \
@@ -99,8 +120,8 @@ voidspace compare \
   --output-dir voidspace-change
 ```
 
-`--mask` is optional for both commands. Use `--force` to overwrite existing
-outputs.
+`--mask` is optional for `run-case` and `compare`, and required for
+`analyze-maps`. Use `--force` to overwrite existing outputs.
 
 ## Python
 
@@ -128,6 +149,18 @@ result = compare(
 print(result.metrics.net_change_volume_mm3)
 ```
 
+```python
+from voidspace import analyze_maps
+
+result = analyze_maps(
+    large_void_path="voidspace-out/voidspace_large_mask.AIM",
+    all_void_path="voidspace-out/voidspace_all_mask.AIM",
+    mask_path="common_region.AIM",
+    output_dir="voidspace-common-region",
+)
+print(result.metrics.vstv_percent)
+```
+
 ## Citation
 
 For cross-sectional voidspace analysis, cite:

{voidspace-0.1.0 → voidspace-0.1.4}/tests/test_aim_io.py

@@ -1,5 +1,6 @@
 import numpy as np
 import py_aimio
+import SimpleITK as sitk
 
 from voidspace.io import is_aim_path, read_mask, write_mask_like
 
@@ -56,3 +57,18 @@ def test_write_mask_like_round_trips_scanco_aim(tmp_path):
         0.0820000022649765,
     )
     assert np.array_equal(roundtrip, subset)
+
+
+def test_write_mask_like_can_write_nifti_from_scanco_aim_reference(tmp_path):
+    source = np.zeros((3, 4, 5), dtype=np.int8)
+    source[1, 2, 3] = 127
+    input_path = tmp_path / "seg.AIM"
+    _write_aim(input_path, source)
+    segmentation, _spacing, reference = read_mask(input_path)
+
+    output = write_mask_like(segmentation, reference, tmp_path / "analysis_mask.nii.gz")
+
+    image = sitk.ReadImage(str(output))
+    roundtrip = sitk.GetArrayFromImage(image).astype(bool)
+    assert image.GetSize() == (5, 4, 3)
+    assert np.array_equal(roundtrip, segmentation)

{voidspace-0.1.0 → voidspace-0.1.4}/tests/test_cli.py

@@ -83,10 +83,71 @@ def test_compare_cli_writes_expanded_and_contracted_masks(tmp_path):
     )
 
     assert rc == 0
+    assert (tmp_path / "change" / "voidspace_quiescent_mask.nii.gz").is_file()
     assert (tmp_path / "change" / "voidspace_expanded_mask.nii.gz").is_file()
     assert (tmp_path / "change" / "voidspace_contracted_mask.nii.gz").is_file()
 
 
+def test_intersect_masks_cli_writes_combined_mask(tmp_path):
+    full = np.ones((3, 3, 3), dtype=bool)
+    full[2, :, :] = False
+    common = np.zeros_like(full)
+    common[:, 1:, :] = True
+    _write_mask(tmp_path / "full.nii.gz", full)
+    _write_mask(tmp_path / "common.nii.gz", common)
+
+    rc = main(
+        [
+            "intersect-masks",
+            "--mask",
+            str(tmp_path / "full.nii.gz"),
+            "--mask",
+            str(tmp_path / "common.nii.gz"),
+            "--output",
+            str(tmp_path / "analysis_mask.nii.gz"),
+            "--force",
+        ]
+    )
+
+    assert rc == 0
+    result = sitk.GetArrayFromImage(sitk.ReadImage(str(tmp_path / "analysis_mask.nii.gz"))).astype(bool)
+    assert np.array_equal(result, full & common)
+
+
+def test_analyze_maps_cli_writes_masked_copies_and_measurements(tmp_path):
+    all_void = np.ones((3, 3, 3), dtype=bool)
+    large_void = np.zeros_like(all_void)
+    large_void[0, 0, 0] = True
+    large_void[2, 2, 2] = True
+    mask = np.zeros_like(all_void)
+    mask[0, 0, 0] = True
+    mask[0, 0, 1] = True
+    _write_mask(tmp_path / "all.nii.gz", all_void)
+    _write_mask(tmp_path / "large.nii.gz", large_void)
+    _write_mask(tmp_path / "mask.nii.gz", mask)
+
+    rc = main(
+        [
+            "analyze-maps",
+            "--large-void",
+            str(tmp_path / "large.nii.gz"),
+            "--all-void",
+            str(tmp_path / "all.nii.gz"),
+            "--mask",
+            str(tmp_path / "mask.nii.gz"),
+            "--output-dir",
+            str(tmp_path / "masked"),
+        ]
+    )
+
+    assert rc == 0
+    assert (tmp_path / "masked" / "voidspace_large_mask.nii.gz").is_file()
+    assert (tmp_path / "masked" / "voidspace_all_mask.nii.gz").is_file()
+    with (tmp_path / "masked" / "voidspace_measurements.csv").open(newline="", encoding="utf-8") as stream:
+        rows = list(csv.DictReader(stream))
+    assert rows[0]["VS.V"] == "1.0"
+
+
 def test_run_case_cli_writes_aim_masks_for_aim_input(tmp_path):
     segmentation = np.ones((9, 9, 9), dtype=bool)
     segmentation[4, 4, 4] = False
@@ -125,3 +186,15 @@ def test_run_case_help_uses_single_mask_argument_and_no_study_metadata(capsys):
     assert "--subject" not in help_text
     assert "--session" not in help_text
     assert "--site" not in help_text
+
+
+def test_analyze_maps_help_uses_existing_map_inputs(capsys):
+    with pytest.raises(SystemExit) as exc_info:
+        main(["analyze-maps", "--help"])
+
+    assert exc_info.value.code == 0
+    help_text = capsys.readouterr().out
+    assert "--large-void" in help_text
+    assert "--all-void" in help_text
+    assert "--mask" in help_text
+    assert "--segmentation" not in help_text

{voidspace-0.1.0 → voidspace-0.1.4}/tests/test_segment.py

@@ -3,6 +3,33 @@ import numpy as np
 from voidspace import VoidspaceParameters, segment_voidspace
 
 
+def _open_tube():
+    yy, xx = np.indices((65, 65))
+    radius = np.sqrt((xx - 32) ** 2 + (yy - 32) ** 2)
+    full = np.broadcast_to(radius < 25, (31, 65, 65)).copy()
+    cavity = np.broadcast_to(radius < 15, full.shape)
+    params = VoidspaceParameters(closing_radius_mm=1, boundary_erosion_radius_mm=1,
+                                min_large_void_volume_mm3=10,
+                                bone_speckle_min_voxels=1, void_speckle_min_voxels=1)
+    return full & ~cavity, full, params
+
+
+def test_open_end_void_survives_without_explicit_domain():
+    bone, full, params = _open_tube()
+    result = segment_voidspace(bone, (1, 1, 1), parameters=params)
+    assert result.large_void[:, 32, 32].all()
+    assert not result.all_void[~full].any()
+    assert not np.any(result.large_void & ~result.all_void)
+
+
+def test_end_slices_match_interior_for_uniform_tube():
+    bone, full, params = _open_tube()
+    result = segment_voidspace(bone, (1, 1, 1), mask=full, parameters=params)
+    assert np.array_equal(result.filled_bone[0], result.filled_bone[15])
+    assert np.array_equal(result.all_void[0], result.all_void[15])
+    assert np.array_equal(result.all_void[-1], result.all_void[15])
+
+
 def _solid_cube_with_cavity(size=31, cavity_radius=4):
     bone = np.zeros((size, size, size), dtype=bool)
     bone[4:-4, 4:-4, 4:-4] = True
@@ -65,6 +92,6 @@ def test_segment_voidspace_derives_internal_domain_without_periosteal_mask():
 
     result = segment_voidspace(bone, (0.061, 0.061, 0.061), parameters=params)
 
-    assert result.metadata["domain_source"] == "segmentation_border_background"
+    assert result.metadata["domain_source"] == "segmentation_lateral_background"
     assert result.large_void[cavity].any()
     assert not result.all_void[~peri].any()

voidspace-0.1.4/tests/test_workflows.py

@@ -0,0 +1,163 @@
+import numpy as np
+import SimpleITK as sitk
+
+from voidspace import VoidspaceParameters, analyze_maps, compare, intersect_masks, run_case
+import pytest
+
+
+@pytest.mark.parametrize("size, origin", [(3, (1, 1, 1)), (5, (1, 0, 0))])
+def test_run_case_places_analysis_mask_on_segmentation_grid(tmp_path, size, origin):
+    segmentation = np.zeros((5, 5, 5), dtype=np.uint8)
+    _write_mask(tmp_path / "seg.nii.gz", segmentation)
+    mask_image = sitk.GetImageFromArray(np.ones((size,) * 3, dtype=np.uint8))
+    mask_image.SetOrigin(origin)
+    sitk.WriteImage(mask_image, str(tmp_path / "domain.nii.gz"))
+    result = run_case(segmentation_path=tmp_path / "seg.nii.gz",
+                      mask_path=tmp_path / "domain.nii.gz", output_dir=tmp_path / "out",
+                      parameters=VoidspaceParameters(closing_radius_mm=0, boundary_erosion_radius_mm=0,
+                          min_large_void_volume_mm3=0, bone_speckle_min_voxels=1, void_speckle_min_voxels=1))
+    assert result.metrics.total_volume_mm3 == (27 if size == 3 else 100)
+    output = sitk.GetArrayFromImage(sitk.ReadImage(str(result.all_mask_path)))
+    assert not output[:, :, 0].any()
+
+
+def _write_mask(path, array):
+    image = sitk.GetImageFromArray(array.astype("uint8"))
+    image.SetSpacing((1.0, 1.0, 1.0))
+    sitk.WriteImage(image, str(path))
+
+
+def test_run_case_returns_metrics_and_output_paths(tmp_path):
+    segmentation = np.ones((9, 9, 9), dtype=bool)
+    segmentation[4, 4, 4] = False
+    _write_mask(tmp_path / "seg.nii.gz", segmentation)
+
+    result = run_case(
+        segmentation_path=tmp_path / "seg.nii.gz",
+        output_dir=tmp_path / "out",
+        parameters=VoidspaceParameters(
+            closing_radius_mm=0.0,
+            boundary_erosion_radius_mm=0.0,
+            min_large_void_volume_mm3=0.0,
+            bone_speckle_min_voxels=1,
+            void_speckle_min_voxels=1,
+        ),
+    )
+
+    assert result.large_mask_path.is_file()
+    assert result.all_mask_path.is_file()
+    assert result.measurements_path.is_file()
+    assert result.metrics.component_count == 1
+
+
+def test_compare_returns_change_metrics_and_output_paths(tmp_path):
+    baseline = np.zeros((2, 2, 2), dtype=bool)
+    followup = np.zeros_like(baseline)
+    baseline[0, 0, 0] = True
+    followup[1, 1, 1] = True
+    _write_mask(tmp_path / "baseline.nii.gz", baseline)
+    _write_mask(tmp_path / "followup.nii.gz", followup)
+
+    result = compare(
+        baseline_void_path=tmp_path / "baseline.nii.gz",
+        followup_void_path=tmp_path / "followup.nii.gz",
+        output_dir=tmp_path / "out",
+    )
+
+    assert result.expanded_mask_path.is_file()
+    assert result.contracted_mask_path.is_file()
+    assert result.measurements_path.is_file()
+    assert result.metrics.expanded_volume_mm3 == 1.0
+    assert result.metrics.contracted_volume_mm3 == 1.0
+
+
+def test_analyze_maps_reuses_existing_void_masks_and_measures_inside_mask(tmp_path):
+    all_void = np.ones((3, 3, 3), dtype=bool)
+    large_void = np.zeros_like(all_void)
+    large_void[0, 0, 0] = True
+    large_void[2, 2, 2] = True
+    mask = np.zeros_like(all_void)
+    mask[0, 0, 0] = True
+    mask[0, 0, 1] = True
+    _write_mask(tmp_path / "all.nii.gz", all_void)
+    _write_mask(tmp_path / "large.nii.gz", large_void)
+    _write_mask(tmp_path / "mask.nii.gz", mask)
+
+    result = analyze_maps(
+        large_void_path=tmp_path / "large.nii.gz",
+        all_void_path=tmp_path / "all.nii.gz",
+        mask_path=tmp_path / "mask.nii.gz",
+        output_dir=tmp_path / "masked",
+    )
+
+    assert result.large_mask_path.is_file()
+    assert result.all_mask_path.is_file()
+    assert result.measurements_path.is_file()
+    assert result.metrics.volume_mm3 == 1.0
+    assert result.metrics.total_volume_mm3 == 2.0
+
+
+def test_intersect_masks_writes_boolean_intersection(tmp_path):
+    full = np.ones((3, 3, 3), dtype=bool)
+    full[2, :, :] = False
+    common = np.zeros_like(full)
+    common[:, 1:, :] = True
+    _write_mask(tmp_path / "full.nii.gz", full)
+    _write_mask(tmp_path / "common.nii.gz", common)
+
+    output_path = intersect_masks(
+        [tmp_path / "full.nii.gz", tmp_path / "common.nii.gz"],
+        output_path=tmp_path / "analysis_mask.nii.gz",
+    )
+
+    image = sitk.ReadImage(str(output_path))
+    result = sitk.GetArrayFromImage(image).astype(bool)
+    assert result.sum() == 12
+    assert np.array_equal(result, full & common)
+
+
+def test_intersect_masks_resamples_cropped_mask_to_reference_grid(tmp_path):
+    full = np.ones((5, 5, 5), dtype=bool)
+    common = np.ones((3, 3, 3), dtype=bool)
+    _write_mask(tmp_path / "full.nii.gz", full)
+    common_image = sitk.GetImageFromArray(common.astype("uint8"))
+    common_image.SetSpacing((1.0, 1.0, 1.0))
+    common_image.SetOrigin((1.0, 1.0, 1.0))
+    sitk.WriteImage(common_image, str(tmp_path / "common.nii.gz"))
+
+    output_path = intersect_masks(
+        [tmp_path / "full.nii.gz", tmp_path / "common.nii.gz"],
+        output_path=tmp_path / "analysis_mask.nii.gz",
+    )
+
+    image = sitk.ReadImage(str(output_path))
+    result = sitk.GetArrayFromImage(image).astype(bool)
+    expected = np.zeros_like(full)
+    expected[1:4, 1:4, 1:4] = True
+    assert image.GetSize() == (5, 5, 5)
+    assert np.array_equal(result, expected)
+
+
+def test_analyze_maps_honors_direction_with_matching_sizes_and_origins(tmp_path):
+    full = np.ones((5, 5, 5), dtype=bool)
+    _write_mask(tmp_path / "all.nii.gz", full)
+    _write_mask(tmp_path / "large.nii.gz", full)
+    mask = sitk.GetImageFromArray(full.astype(np.uint8))
+    mask.SetDirection((-1, 0, 0, 0, 1, 0, 0, 0, 1))
+    sitk.WriteImage(mask, str(tmp_path / "domain.nii.gz"))
+    result = analyze_maps(large_void_path=tmp_path / "large.nii.gz", all_void_path=tmp_path / "all.nii.gz",
+                          mask_path=tmp_path / "domain.nii.gz", output_dir=tmp_path / "out")
+    assert result.metrics.total_volume_mm3 == 25
+
+
+def test_compare_places_cropped_maps_in_same_physical_space(tmp_path):
+    baseline = np.zeros((5, 5, 5), dtype=bool)
+    baseline[2, 2, 2] = True
+    _write_mask(tmp_path / "baseline.nii.gz", baseline)
+    cropped = sitk.GetImageFromArray(np.ones((1, 1, 1), dtype=np.uint8))
+    cropped.SetOrigin((2, 2, 2))
+    sitk.WriteImage(cropped, str(tmp_path / "followup.nii.gz"))
+    result = compare(baseline_void_path=tmp_path / "baseline.nii.gz",
+                     followup_void_path=tmp_path / "followup.nii.gz", output_dir=tmp_path / "out")
+    assert result.metrics.stable_volume_mm3 == 1
+    assert result.metrics.expanded_volume_mm3 == result.metrics.contracted_volume_mm3 == 0

voidspace-0.1.0/src/voidspace/workflows.py

@@ -1,124 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from voidspace.change import classify_voidspace_change, measure_voidspace_change
-from voidspace.io import AimReference, read_mask, write_mask_like, write_metrics_csv
-from voidspace.metrics import measure_voidspace
-from voidspace.models import VoidspaceCompareResult, VoidspaceParameters, VoidspaceRunResult
-from voidspace.segment import segment_voidspace
-
-
-def _metric_row(metrics, **context):
-    return {
-        **context,
-        "VS.TV": metrics.vstv_percent,
-        "VS.V": metrics.volume_mm3,
-        "Tt.V": metrics.total_volume_mm3,
-        "VS.N": metrics.component_count,
-        "VS.Ar": metrics.projected_area_mm2,
-    }
-
-
-def _mask_extension(reference) -> str:
-    return ".AIM" if isinstance(reference, AimReference) else ".nii.gz"
-
-
-def run_case(
-    *,
-    segmentation_path: Path | str,
-    output_dir: Path | str,
-    mask_path: Path | str | None = None,
-    parameters: VoidspaceParameters | None = None,
-    force: bool = False,
-) -> VoidspaceRunResult:
-    """Run cross-sectional voidspace segmentation and measurement for one scan."""
-    output_dir = Path(output_dir)
-    segmentation, spacing, reference = read_mask(segmentation_path)
-    mask_extension = _mask_extension(reference)
-    large_path = output_dir / f"voidspace_large_mask{mask_extension}"
-    all_path = output_dir / f"voidspace_all_mask{mask_extension}"
-    measurements_path = output_dir / "voidspace_measurements.csv"
-
-    existing_outputs = [path for path in (large_path, all_path, measurements_path) if path.exists()]
-    if existing_outputs and not force:
-        raise FileExistsError(f"output already exists: {existing_outputs[0]}")
-
-    if mask_path is not None:
-        domain_mask, mask_spacing, _mask_reference = read_mask(mask_path)
-        if mask_spacing != spacing or domain_mask.shape != segmentation.shape:
-            raise ValueError("mask must be in the same space as segmentation")
-    else:
-        domain_mask = None
-
-    params = parameters or VoidspaceParameters.xtremectii_defaults()
-    masks = segment_voidspace(segmentation, spacing, mask=domain_mask, parameters=params)
-    write_mask_like(masks.large_void, reference, large_path)
-    write_mask_like(masks.all_void, reference, all_path)
-
-    total_mask = domain_mask if domain_mask is not None else (masks.filled_bone | masks.all_void)
-    metrics = measure_voidspace(masks.large_void, total_mask, spacing, connectivity=params.connectivity)
-    write_metrics_csv(measurements_path, [_metric_row(metrics)])
-
-    return VoidspaceRunResult(large_path, all_path, measurements_path, metrics)
-
-
-def compare(
-    *,
-    baseline_void_path: Path | str,
-    followup_void_path: Path | str,
-    output_dir: Path | str,
-    mask_path: Path | str | None = None,
-    force: bool = False,
-) -> VoidspaceCompareResult:
-    """Compare already aligned baseline and follow-up voidspace masks."""
-    output_dir = Path(output_dir)
-    baseline, spacing, reference = read_mask(baseline_void_path)
-    mask_extension = _mask_extension(reference)
-    stable_path = output_dir / f"voidspace_stable_mask{mask_extension}"
-    expanded_path = output_dir / f"voidspace_expanded_mask{mask_extension}"
-    contracted_path = output_dir / f"voidspace_contracted_mask{mask_extension}"
-    measurements_path = output_dir / "voidspace_change_measurements.csv"
-    existing_outputs = [
-        path for path in (stable_path, expanded_path, contracted_path, measurements_path) if path.exists()
-    ]
-    if existing_outputs and not force:
-        raise FileExistsError(f"output already exists: {existing_outputs[0]}")
-
-    followup, followup_spacing, _followup_reference = read_mask(followup_void_path)
-    if followup_spacing != spacing or followup.shape != baseline.shape:
-        raise ValueError("baseline and followup void masks must already be aligned")
-
-    domain_mask = None
-    if mask_path is not None:
-        domain_mask, mask_spacing, _mask_reference = read_mask(mask_path)
-        if mask_spacing != spacing or domain_mask.shape != baseline.shape:
-            raise ValueError("mask must be aligned with the void masks")
-
-    change = classify_voidspace_change(baseline, followup, mask=domain_mask)
-    write_mask_like(change.stable, reference, stable_path)
-    write_mask_like(change.expanded, reference, expanded_path)
-    write_mask_like(change.contracted, reference, contracted_path)
-    metrics = measure_voidspace_change(change, spacing)
-    write_metrics_csv(
-        measurements_path,
-        [
-            {
-                "stable.VS.V": metrics.stable_volume_mm3,
-                "expanded.VS.V": metrics.expanded_volume_mm3,
-                "contracted.VS.V": metrics.contracted_volume_mm3,
-                "net.VS.V": metrics.net_change_volume_mm3,
-            }
-        ],
-    )
-    return VoidspaceCompareResult(
-        stable_path,
-        expanded_path,
-        contracted_path,
-        measurements_path,
-        metrics,
-    )
-
-
-run_voidspace_case = run_case
-run_voidspace_change_case = compare

voidspace-0.1.0/tests/test_workflows.py

@@ -1,54 +0,0 @@
-import numpy as np
-import SimpleITK as sitk
-
-from voidspace import VoidspaceParameters, compare, run_case
-
-
-def _write_mask(path, array):
-    image = sitk.GetImageFromArray(array.astype("uint8"))
-    image.SetSpacing((1.0, 1.0, 1.0))
-    sitk.WriteImage(image, str(path))
-
-
-def test_run_case_returns_metrics_and_output_paths(tmp_path):
-    segmentation = np.ones((9, 9, 9), dtype=bool)
-    segmentation[4, 4, 4] = False
-    _write_mask(tmp_path / "seg.nii.gz", segmentation)
-
-    result = run_case(
-        segmentation_path=tmp_path / "seg.nii.gz",
-        output_dir=tmp_path / "out",
-        parameters=VoidspaceParameters(
-            closing_radius_mm=0.0,
-            boundary_erosion_radius_mm=0.0,
-            min_large_void_volume_mm3=0.0,
-            bone_speckle_min_voxels=1,
-            void_speckle_min_voxels=1,
-        ),
-    )
-
-    assert result.large_mask_path.is_file()
-    assert result.all_mask_path.is_file()
-    assert result.measurements_path.is_file()
-    assert result.metrics.component_count == 1
-
-
-def test_compare_returns_change_metrics_and_output_paths(tmp_path):
-    baseline = np.zeros((2, 2, 2), dtype=bool)
-    followup = np.zeros_like(baseline)
-    baseline[0, 0, 0] = True
-    followup[1, 1, 1] = True
-    _write_mask(tmp_path / "baseline.nii.gz", baseline)
-    _write_mask(tmp_path / "followup.nii.gz", followup)
-
-    result = compare(
-        baseline_void_path=tmp_path / "baseline.nii.gz",
-        followup_void_path=tmp_path / "followup.nii.gz",
-        output_dir=tmp_path / "out",
-    )
-
-    assert result.expanded_mask_path.is_file()
-    assert result.contracted_mask_path.is_file()
-    assert result.measurements_path.is_file()
-    assert result.metrics.expanded_volume_mm3 == 1.0
-    assert result.metrics.contracted_volume_mm3 == 1.0