voidspace 0.1.0__tar.gz → 0.1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidspace
-Version: 0.1.0
+Version: 0.1.3
 Summary: Spacing-aware voidspace analysis for HR-pQCT segmentations
 Author: Matthias Walle
 License-Expression: MIT
@@ -91,6 +91,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 +107,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 +136,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.3}/README.md

@@ -58,6 +58,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 +74,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 +103,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.3}/pyproject.toml

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

{voidspace-0.1.0 → voidspace-0.1.3}/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.3"
 
 __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.3}/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.3}/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.3}/src/voidspace/workflows.py

@@ -2,6 +2,9 @@ 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
@@ -24,6 +27,56 @@ 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 source_image.GetOrigin() == target_image.GetOrigin():
+        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,
@@ -63,6 +116,45 @@ def run_case(
     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)
+    if all_spacing != spacing or all_void.shape != large_void.shape:
+        raise ValueError("large and all void masks must be in the same space")
+    domain_mask, mask_spacing, _mask_reference = read_mask(mask_path)
+    if mask_spacing != spacing or domain_mask.shape != large_void.shape:
+        raise ValueError("mask must be aligned with the void masks")
+
+    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,
@@ -75,7 +167,7 @@ def compare(
     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}"
+    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"
@@ -105,6 +197,7 @@ def compare(
         [
             {
                 "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,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidspace
-Version: 0.1.0
+Version: 0.1.3
 Summary: Spacing-aware voidspace analysis for HR-pQCT segmentations
 Author: Matthias Walle
 License-Expression: MIT
@@ -91,6 +91,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 +107,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 +136,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.3}/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.3}/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.3/tests/test_workflows.py

@@ -0,0 +1,121 @@
+import numpy as np
+import SimpleITK as sitk
+
+from voidspace import VoidspaceParameters, analyze_maps, compare, intersect_masks, 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
+
+
+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)

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