caideface 0.1.3__py3-none-any.whl

caideface/__init__.py

@@ -0,0 +1,24 @@
+"""caideface - MRI defacing pipeline from cai4cai.
+
+A three-step pipeline for anonymising head MRI scans:
+1. Reorientation to MNI152 atlas reference (nibabel)
+2. Skull-stripping with HD-BET and dynamic dilation
+3. Affine registration and defacing (BRAINSFit)
+"""
+
+__version__ = "0.1.3"
+
+from .pipeline import DefacePipeline
+from .reorient import reorient_batch, reorient_single
+from .skull_strip import skull_strip_batch, skull_strip_single
+from .register import deface_batch, deface_single
+
+__all__ = [
+    "DefacePipeline",
+    "reorient_batch",
+    "reorient_single",
+    "skull_strip_batch",
+    "skull_strip_single",
+    "deface_batch",
+    "deface_single",
+]

caideface/cli.py

@@ -0,0 +1,127 @@
+"""Command-line interface for caideface."""
+
+import argparse
+import logging
+import sys
+
+from .pipeline import DefacePipeline
+from .reorient import reorient_batch
+from .skull_strip import skull_strip_batch, get_default_device
+from .register import deface_batch
+
+
+def _setup_logging(verbose: bool):
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+
+def main():
+    # Shared parent so -v works on any subcommand
+    parent = argparse.ArgumentParser(add_help=False)
+    parent.add_argument("-v", "--verbose", action="store_true", help="Enable debug logging")
+
+    parser = argparse.ArgumentParser(
+        prog="caideface",
+        description="MRI defacing pipeline from cai4cai: reorientation, skull-stripping, and affine-based defacing.",
+        parents=[parent],
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # --- run: full pipeline ---
+    run_parser = subparsers.add_parser("run", help="Run the full defacing pipeline", parents=[parent])
+    run_parser.add_argument("input_dir", help="Directory containing raw NIfTI files")
+    run_parser.add_argument("output_dir", help="Root output directory")
+    run_parser.add_argument("--brainsfit", required=True, help="Path to BRAINSFit executable")
+    run_parser.add_argument("--brainsresample", required=True, help="Path to BRAINSResample executable")
+    run_parser.add_argument("--device", default=None, choices=["cpu", "cuda"], help="Device for HD-BET (auto-detected if omitted)")
+    run_parser.add_argument("--no-tta", action="store_true", default=True, help="Disable HD-BET test-time augmentation (default: disabled)")
+    run_parser.add_argument("--dilation-mm", type=float, default=14.0, help="Brain mask dilation in mm (default: 14)")
+    run_parser.add_argument("--background", type=float, default=0, help="Background value for defaced voxels (default: 0 for MRI, use -1024 for CT)")
+    run_parser.add_argument("--template", default=None, help="Custom MNI152 skull-stripped template (uses bundled if omitted)")
+    run_parser.add_argument("--face-mask", default=None, help="Custom face mask in MNI152 space (uses bundled if omitted)")
+    run_parser.add_argument("--steps", default="all", help="Steps to run: all, or comma-separated: reorient,skull_strip,deface")
+
+    # --- reorient ---
+    reorient_parser = subparsers.add_parser("reorient", help="Step 1: Reorient NIfTI scans to MNI152", parents=[parent])
+    reorient_parser.add_argument("input_dir", help="Directory with NIfTI files")
+    reorient_parser.add_argument("output_dir", help="Output directory for reoriented files")
+
+    # --- skull-strip ---
+    ss_parser = subparsers.add_parser("skull-strip", help="Step 2: Skull-strip with HD-BET", parents=[parent])
+    ss_parser.add_argument("input_dir", help="Directory with reoriented NIfTI files")
+    ss_parser.add_argument("output_dir", help="Output directory for HD-BET results")
+    ss_parser.add_argument("--device", default=None, choices=["cpu", "cuda"], help="Device for HD-BET")
+    ss_parser.add_argument("--no-tta", action="store_true", default=True, help="Disable test-time augmentation")
+    ss_parser.add_argument("--dilation-mm", type=float, default=14.0, help="Dilation in mm")
+
+    # --- deface ---
+    deface_parser = subparsers.add_parser("deface", help="Step 3: Register and deface", parents=[parent])
+    deface_parser.add_argument("reoriented_dir", help="Directory with reoriented scans (Step 1 output)")
+    deface_parser.add_argument("hdbet_dir", help="Directory with HD-BET results (Step 2 output)")
+    deface_parser.add_argument("output_dir", help="Output directory for defaced scans")
+    deface_parser.add_argument("--brainsfit", required=True, help="Path to BRAINSFit executable")
+    deface_parser.add_argument("--brainsresample", required=True, help="Path to BRAINSResample executable")
+    deface_parser.add_argument("--template", default=None, help="Custom MNI152 skull-stripped template")
+    deface_parser.add_argument("--face-mask", default=None, help="Custom face mask in MNI152 space")
+    deface_parser.add_argument("--background", type=float, default=0, help="Background value (default: 0 for MRI, use -1024 for CT)")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    _setup_logging(args.verbose)
+
+    if args.command == "run":
+        pipeline = DefacePipeline(
+            brainsfit_path=args.brainsfit,
+            brainsresample_path=args.brainsresample,
+            device=args.device,
+            disable_tta=args.no_tta,
+            desired_dilation_mm=args.dilation_mm,
+            background_value=args.background,
+            target_path=args.template,
+            face_mask_path=args.face_mask,
+        )
+        results = pipeline.run(args.input_dir, args.output_dir, steps=args.steps)
+        failed = results.get("failed_defacing", [])
+        if failed:
+            print(f"\n{len(failed)} scan(s) failed to deface. See output log for details.")
+            sys.exit(1)
+
+    elif args.command == "reorient":
+        reorient_batch(args.input_dir, args.output_dir)
+
+    elif args.command == "skull-strip":
+        skull_strip_batch(
+            args.input_dir,
+            args.output_dir,
+            device=args.device,
+            disable_tta=args.no_tta,
+            desired_dilation_mm=args.dilation_mm,
+        )
+
+    elif args.command == "deface":
+        failed = deface_batch(
+            reoriented_dir=args.reoriented_dir,
+            hdbet_dir=args.hdbet_dir,
+            output_dir=args.output_dir,
+            brainsfit_path=args.brainsfit,
+            brainsresample_path=args.brainsresample,
+            target_path=args.template,
+            face_mask_path=args.face_mask,
+            background_value=args.background,
+        )
+        if failed:
+            print(f"\n{len(failed)} scan(s) failed. See output log.")
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

caideface/pipeline.py

@@ -0,0 +1,139 @@
+"""Full defacing pipeline orchestrator: reorient -> skull-strip -> register & deface."""
+
+import logging
+import os
+
+import pandas as pd
+
+from .reorient import reorient_batch
+from .skull_strip import skull_strip_batch
+from .register import deface_batch
+
+logger = logging.getLogger(__name__)
+
+
+class DefacePipeline:
+    """Orchestrates the three-step MRI defacing pipeline.
+
+    Parameters
+    ----------
+    brainsfit_path : str
+        Path to the BRAINSFit executable (from 3D Slicer).
+    brainsresample_path : str
+        Path to the BRAINSResample executable (from 3D Slicer).
+    device : str or None
+        'cpu' or 'cuda' for HD-BET. Auto-detected if None.
+    disable_tta : bool
+        Disable HD-BET test-time augmentation for faster processing.
+    desired_dilation_mm : float
+        Physical dilation in mm for brain mask expansion.
+    background_value : float
+        Value for defaced voxels (default 0 for MRI; use -1024 for CT).
+    target_path : str or None
+        Custom MNI152 skull-stripped template. Uses bundled if None.
+    face_mask_path : str or None
+        Custom face mask in MNI152 space. Uses bundled if None.
+    """
+
+    def __init__(
+        self,
+        brainsfit_path: str,
+        brainsresample_path: str,
+        device: str | None = None,
+        disable_tta: bool = True,
+        desired_dilation_mm: float = 14.0,
+        background_value: float = 0,
+        target_path: str | None = None,
+        face_mask_path: str | None = None,
+    ):
+        self.brainsfit_path = brainsfit_path
+        self.brainsresample_path = brainsresample_path
+        self.device = device
+        self.disable_tta = disable_tta
+        self.desired_dilation_mm = desired_dilation_mm
+        self.background_value = background_value
+        self.target_path = target_path
+        self.face_mask_path = face_mask_path
+
+    def run(
+        self,
+        input_dir: str,
+        output_dir: str,
+        steps: str = "all",
+    ) -> dict:
+        """Run the defacing pipeline.
+
+        Parameters
+        ----------
+        input_dir : str
+            Directory containing raw NIfTI (.nii.gz) files.
+        output_dir : str
+            Root output directory. Subdirectories will be created:
+            ``reoriented/``, ``hdbet/``, ``defaced/``.
+        steps : str
+            Which steps to run: 'all', 'reorient', 'skull_strip', 'deface',
+            or comma-separated combination like 'reorient,skull_strip'.
+
+        Returns
+        -------
+        dict
+            Summary with keys: reorient_log, skull_strip_log, failed_defacing.
+        """
+        input_dir = os.path.abspath(input_dir)
+        output_dir = os.path.abspath(output_dir)
+
+        reoriented_dir = os.path.join(output_dir, "reoriented")
+        hdbet_dir = os.path.join(output_dir, "hdbet")
+        defaced_dir = os.path.join(output_dir, "defaced")
+
+        run_steps = set(s.strip() for s in steps.split(",")) if steps != "all" else {"reorient", "skull_strip", "deface"}
+
+        results = {}
+
+        # Step 1: Reorientation
+        if "reorient" in run_steps:
+            logger.info("=" * 60)
+            logger.info("STEP 1: Reorientation to MNI152")
+            logger.info("=" * 60)
+            reorient_log = reorient_batch(input_dir, reoriented_dir)
+            results["reorient_log"] = reorient_log
+        else:
+            logger.info("Skipping Step 1 (reorientation)")
+
+        # Step 2: Skull-stripping
+        if "skull_strip" in run_steps:
+            logger.info("=" * 60)
+            logger.info("STEP 2: Skull-stripping with HD-BET")
+            logger.info("=" * 60)
+            skull_strip_log = skull_strip_batch(
+                input_dir=reoriented_dir,
+                output_dir=hdbet_dir,
+                device=self.device,
+                disable_tta=self.disable_tta,
+                desired_dilation_mm=self.desired_dilation_mm,
+            )
+            results["skull_strip_log"] = skull_strip_log
+        else:
+            logger.info("Skipping Step 2 (skull-stripping)")
+
+        # Step 3: Registration & Defacing
+        if "deface" in run_steps:
+            logger.info("=" * 60)
+            logger.info("STEP 3: Registration & Defacing")
+            logger.info("=" * 60)
+            failed = deface_batch(
+                reoriented_dir=reoriented_dir,
+                hdbet_dir=hdbet_dir,
+                output_dir=defaced_dir,
+                brainsfit_path=self.brainsfit_path,
+                brainsresample_path=self.brainsresample_path,
+                target_path=self.target_path,
+                face_mask_path=self.face_mask_path,
+                background_value=self.background_value,
+            )
+            results["failed_defacing"] = failed
+        else:
+            logger.info("Skipping Step 3 (registration & defacing)")
+
+        logger.info("Pipeline finished.")
+        return results

caideface/register.py

@@ -0,0 +1,395 @@
+"""Step 3: Affine registration with BRAINSFit, face mask warping, and defacing."""
+
+import os
+import csv
+import logging
+from glob import glob
+from pathlib import Path
+
+import nibabel as nib
+import numpy as np
+from numpy.linalg import inv
+from natsort import natsorted
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Bundled data helpers
+# ---------------------------------------------------------------------------
+
+def _data_dir() -> str:
+    """Return the path to the bundled data directory."""
+    return os.path.join(os.path.dirname(__file__), "data")
+
+
+def default_template_path() -> str:
+    return os.path.join(_data_dir(), "mni_icbm152_t1_tal_nlin_sym_55_ext_brain_only.nii.gz")
+
+
+def default_face_mask_path() -> str:
+    return os.path.join(_data_dir(), "t1_mask.nii.gz")
+
+
+# ---------------------------------------------------------------------------
+# Transform I/O (supports both plain 4x4 text and ITK/Slicer formats)
+# ---------------------------------------------------------------------------
+
+def read_slicer_transform_as_forward_in_RAS(txtfile_path: str) -> np.ndarray:
+    """Read an ITK/3D-Slicer affine transform file and return it as a
+    forward-direction 4x4 matrix in RAS coordinates."""
+    import SimpleITK as sitk
+
+    sitk_tfm = sitk.AffineTransform(sitk.ReadTransform(txtfile_path))
+
+    A = np.array(sitk_tfm.GetMatrix()).reshape(3, 3)
+    t = np.array(sitk_tfm.GetTranslation())
+    c = np.array(sitk_tfm.GetCenter())
+
+    # T(x) = A(x-c) + t + c  =>  translation = -A@c + t + c
+    t_aff = -A @ c + t + c
+
+    mat = np.eye(4)
+    mat[:3, :3] = A
+    mat[:3, 3] = t_aff
+
+    # LPS -> RAS conversion
+    RAS_to_LPS = np.diag([-1, -1, 1, 1])
+    mat_RAS = RAS_to_LPS @ mat @ RAS_to_LPS
+
+    # Return forward (inverse of resampling direction)
+    return inv(mat_RAS)
+
+
+def load_transform(path: str) -> np.ndarray:
+    """Load a transform from a text file, auto-detecting ITK vs plain format."""
+    with open(path, "r") as f:
+        first_line = f.readline()
+
+    if "#Insight Transform File" in first_line:
+        return read_slicer_transform_as_forward_in_RAS(path)
+    return np.loadtxt(path)
+
+
+# ---------------------------------------------------------------------------
+# Apply affine: warp floating image sform using a registration transform
+# ---------------------------------------------------------------------------
+
+def apply_affine_to_sform(
+    floating_path: str,
+    reference_path: str,
+    transform_path: str,
+    output_dir: str,
+) -> str:
+    """Apply a registration transform to the sform of a floating image.
+
+    Saves a warped NIfTI whose data is unchanged but whose affine encodes
+    the registration to the reference.
+
+    Returns the path to the warped image.
+    """
+    flo_nii = nib.load(floating_path)
+    reg_transform = load_transform(transform_path)
+
+    warped_affine = inv(reg_transform) @ flo_nii.affine
+
+    flo_name = os.path.basename(floating_path).replace(".nii.gz", "")
+    warped_path = os.path.join(output_dir, flo_name + "_warped.nii.gz")
+
+    warped_nii = nib.Nifti1Image(flo_nii.get_fdata(), warped_affine)
+    warped_nii.header["qform_code"] = 0
+    nib.save(warped_nii, warped_path)
+
+    return warped_path
+
+
+# ---------------------------------------------------------------------------
+# BRAINSFit registration
+# ---------------------------------------------------------------------------
+
+def run_brainsfit(
+    fixed_path: str,
+    moving_path: str,
+    output_volume_path: str,
+    output_transform_path: str,
+    brainsfit_path: str,
+) -> int:
+    """Run BRAINSFit affine registration and return the exit code."""
+    cmd = (
+        f'"{brainsfit_path}" '
+        f'--fixedVolume "{fixed_path}" '
+        f'--movingVolume "{moving_path}" '
+        f'--outputVolume "{output_volume_path}" '
+        f'--outputTransform "{output_transform_path}" '
+        f'--samplingPercentage 0.1 '
+        f'--splineGridSize 14,10,12 '
+        f'--initializeTransformMode useMomentsAlign '
+        f'--useRigid --useAffine '
+        f'--maskProcessingMode NOMASK '
+        f'--medianFilterSize 0,0,0 '
+        f'--removeIntensityOutliers 0 '
+        f'--outputVolumePixelType float '
+        f'--backgroundFillValue 0 '
+        f'--interpolationMode Linear '
+        f'--numberOfIterations 1500 '
+        f'--maximumStepLength 0.05 '
+        f'--minimumStepLength 0.001 '
+        f'--relaxationFactor 0.5 '
+        f'--translationScale 1000 '
+        f'--reproportionScale 1 '
+        f'--skewScale 1 '
+        f'--maxBSplineDisplacement 0 '
+        f'--fixedVolumeTimeIndex 0 '
+        f'--movingVolumeTimeIndex 0 '
+        f'--numberOfHistogramBins 50 '
+        f'--numberOfMatchPoints 10 '
+        f'--costMetric MMI '
+        f'--maskInferiorCutOffFromCenter 1000 '
+        f'--ROIAutoDilateSize 0 '
+        f'--ROIAutoClosingSize 9 '
+        f'--numberOfSamples 0 '
+        f'--failureExitCode -1 '
+        f'--numberOfThreads -1 '
+        f'--debugLevel 0 '
+        f'--costFunctionConvergenceFactor 2e+13 '
+        f'--projectedGradientTolerance 1e-05 '
+        f'--maximumNumberOfEvaluations 900 '
+        f'--maximumNumberOfCorrections 25 '
+        f'--metricSamplingStrategy Random '
+        f'>> /dev/null'
+    )
+    return os.system(cmd)
+
+
+def run_brainsresample(
+    input_volume: str,
+    reference_volume: str,
+    output_volume: str,
+    transform_path: str,
+    brainsresample_path: str,
+    inverse: bool = True,
+) -> int:
+    """Run BRAINSResample and return the exit code."""
+    cmd = (
+        f'"{brainsresample_path}" '
+        f'--inputVolume "{input_volume}" '
+        f'--referenceVolume "{reference_volume}" '
+        f'--outputVolume "{output_volume}" '
+        f'--warpTransform "{transform_path}" '
+        f'{"--inverseTransform " if inverse else ""}'
+        f'--interpolationMode NearestNeighbor'
+    )
+    return os.system(cmd)
+
+
+# ---------------------------------------------------------------------------
+# Defacing logic
+# ---------------------------------------------------------------------------
+
+def _build_scan_mapping(
+    floating_imgs: list[str],
+    reoriented_dir: str,
+    hdbet_dir: str,
+) -> dict:
+    """Map dilated skull-stripped scans to their reoriented originals and brain masks.
+
+    Returns a dict: {floating_path: (reoriented_path, brain_mask_path)}
+    """
+    reoriented_files = natsorted(glob(os.path.join(reoriented_dir, "**", "*.nii.gz"), recursive=True))
+    brain_masks = natsorted(glob(os.path.join(hdbet_dir, "**", "*_mask.nii.gz"), recursive=True))
+
+    mapping = {}
+    for fimg in floating_imgs:
+        stem = os.path.basename(fimg).replace("_dilated.nii.gz", "")
+        reoriented = next((r for r in reoriented_files if os.path.basename(r) == f"{stem}.nii.gz"), None)
+        mask = next((m for m in brain_masks if os.path.basename(m) == f"{stem}_mask.nii.gz"), None)
+        if reoriented and mask:
+            mapping[fimg] = (reoriented, mask)
+        else:
+            logger.warning("No match for %s (reoriented=%s, mask=%s)", fimg, reoriented, mask)
+    return mapping
+
+
+def deface_single(
+    floating_path: str,
+    reoriented_path: str,
+    brain_mask_path: str,
+    results_dir: str,
+    target_path: str,
+    face_mask_path: str,
+    brainsfit_path: str,
+    brainsresample_path: str,
+    existing_transform: str | None = None,
+    background_value: float = 0,
+) -> bool:
+    """Register, warp face mask, and deface a single scan.
+
+    Returns True on success, False on failure.
+    """
+    os.makedirs(results_dir, exist_ok=True)
+
+    base = os.path.basename(floating_path)
+    masked_path = os.path.join(results_dir, base.replace(".nii.gz", "_masked.nii.gz"))
+
+    # Skip if already defaced
+    if os.path.isfile(masked_path):
+        logger.info("Already defaced, skipping: %s", masked_path)
+        return True
+
+    out_affine = os.path.join(results_dir, base.replace(".nii.gz", ".txt"))
+    out_resampled = os.path.join(results_dir, base.replace(".nii.gz", "_resampled.nii.gz"))
+
+    # --- Registration ---
+    if existing_transform and os.path.isfile(existing_transform):
+        logger.info("Using existing transform: %s", existing_transform)
+        out_affine = existing_transform
+    else:
+        logger.info("Running BRAINSFit registration...")
+        exit_code = run_brainsfit(
+            target_path, floating_path, out_resampled, out_affine, brainsfit_path
+        )
+        if exit_code != 0:
+            logger.error("BRAINSFit failed (exit %d) for %s", exit_code, floating_path)
+            return False
+        logger.info("BRAINSFit completed successfully")
+
+    # --- Apply affine to warp face mask into scan space ---
+    apply_affine_to_sform(face_mask_path, floating_path, out_affine, results_dir)
+
+    # --- Resample face mask ---
+    face_mask_resampled = os.path.join(
+        results_dir,
+        os.path.basename(face_mask_path).replace(".nii.gz", "_resampled.nii.gz"),
+    )
+    run_brainsresample(
+        face_mask_path, floating_path, face_mask_resampled,
+        out_affine, brainsresample_path, inverse=True,
+    )
+
+    # --- Combine masks and deface ---
+    floating_nii = nib.load(reoriented_path)
+    floating_data = floating_nii.get_fdata()
+
+    face_data = nib.load(face_mask_resampled).get_fdata()
+    brain_data = nib.load(brain_mask_path).get_fdata()
+
+    mask_data = np.clip(face_data + brain_data, 0, 1)
+
+    if floating_data.ndim == 4:
+        defaced = np.where(mask_data[..., np.newaxis] > 0, floating_data, background_value)
+    else:
+        defaced = np.where(mask_data > 0, floating_data, background_value)
+
+    nib.save(nib.Nifti1Image(defaced, floating_nii.affine), masked_path)
+    logger.info("Saved defaced scan: %s", masked_path)
+    return True
+
+
+def deface_batch(
+    reoriented_dir: str,
+    hdbet_dir: str,
+    output_dir: str,
+    brainsfit_path: str,
+    brainsresample_path: str,
+    target_path: str | None = None,
+    face_mask_path: str | None = None,
+    background_value: float = 0,
+) -> list[str]:
+    """Run the full defacing pipeline (Step 3) on all dilated scans.
+
+    Parameters
+    ----------
+    reoriented_dir : str
+        Directory with reoriented scans from Step 1.
+    hdbet_dir : str
+        Directory with HD-BET outputs from Step 2.
+    output_dir : str
+        Where defaced scans will be saved.
+    brainsfit_path : str
+        Path to the BRAINSFit executable.
+    brainsresample_path : str
+        Path to the BRAINSResample executable.
+    target_path : str or None
+        Path to skull-stripped MNI152 template. Uses bundled if None.
+    face_mask_path : str or None
+        Path to face mask in MNI152 space. Uses bundled if None.
+    background_value : float
+        Value to fill defaced regions (default 0 for MRI; use -1024 for CT).
+
+    Returns
+    -------
+    list[str]
+        Paths of scans that failed to deface.
+    """
+    if target_path is None:
+        target_path = default_template_path()
+    if face_mask_path is None:
+        face_mask_path = default_face_mask_path()
+
+    hdbet_dir = os.path.abspath(hdbet_dir)
+    reoriented_dir = os.path.abspath(reoriented_dir)
+    output_dir = os.path.abspath(output_dir)
+
+    floating_imgs = natsorted(
+        glob(os.path.join(hdbet_dir, "**", "*_dilated.nii.gz"), recursive=True)
+    )
+
+    if not floating_imgs:
+        logger.warning("No dilated skull-stripped scans found in %s", hdbet_dir)
+        return []
+
+    logger.info("Found %d scans to deface", len(floating_imgs))
+
+    # Build mapping: floating -> (reoriented, brain_mask)
+    mapping = _build_scan_mapping(floating_imgs, reoriented_dir, hdbet_dir)
+
+    # Check for pre-existing transforms
+    existing_transforms = {}
+    for fimg in floating_imgs:
+        tfm_path = os.path.join(os.path.dirname(fimg), "Transform_to_template.txt")
+        if os.path.isfile(tfm_path):
+            existing_transforms[fimg] = tfm_path
+
+    failed = []
+    for fimg in floating_imgs:
+        if fimg not in mapping:
+            logger.warning("Skipping %s: no matching reoriented scan / mask", fimg)
+            failed.append(fimg)
+            continue
+
+        reoriented_path, brain_mask_path = mapping[fimg]
+        rel = os.path.relpath(os.path.dirname(fimg), hdbet_dir)
+        results_dir = os.path.join(output_dir, rel)
+
+        try:
+            ok = deface_single(
+                floating_path=fimg,
+                reoriented_path=reoriented_path,
+                brain_mask_path=brain_mask_path,
+                results_dir=results_dir,
+                target_path=target_path,
+                face_mask_path=face_mask_path,
+                brainsfit_path=brainsfit_path,
+                brainsresample_path=brainsresample_path,
+                existing_transform=existing_transforms.get(fimg),
+                background_value=background_value,
+            )
+            if not ok:
+                failed.append(fimg)
+        except Exception:
+            logger.exception("Error defacing %s", fimg)
+            failed.append(fimg)
+
+    # Write failure log
+    if failed:
+        csv_path = os.path.join(output_dir, "not_defaced_scans.csv")
+        with open(csv_path, "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(["scan_path"])
+            for p in failed:
+                writer.writerow([p])
+        logger.warning("%d scans failed. See %s", len(failed), csv_path)
+    else:
+        logger.info("All scans successfully defaced.")
+
+    return failed

caideface/reorient.py

@@ -0,0 +1,98 @@
+"""Step 1: Reorientation of NIfTI scans to LAS (MNI152 standard) using nibabel."""
+
+import os
+import logging
+
+import nibabel as nib
+from nibabel.orientations import axcodes2ornt, ornt_transform, io_orientation
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+# Target orientation matching fslreorient2std / MNI152 standard
+TARGET_ORIENTATION = ("L", "A", "S")
+
+
+def reorient_single(input_file: str, output_file: str) -> bool:
+    """Reorient a single NIfTI file to LAS orientation (MNI152 standard).
+
+    This is equivalent to FSL's ``fslreorient2std`` but implemented purely
+    in Python using nibabel, removing the FSL dependency.
+
+    Parameters
+    ----------
+    input_file : str
+        Path to the input NIfTI (.nii.gz) file.
+    output_file : str
+        Path where the reoriented file will be saved.
+
+    Returns
+    -------
+    bool
+        True if reorientation succeeded, False otherwise.
+    """
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    try:
+        img = nib.load(input_file)
+        orig_ornt = io_orientation(img.affine)
+        target_ornt = axcodes2ornt(TARGET_ORIENTATION)
+        transform = ornt_transform(orig_ornt, target_ornt)
+        reoriented = img.as_reoriented(transform)
+        nib.save(reoriented, output_file)
+    except Exception as e:
+        logger.error("Failed to reorient %s: %s", input_file, e)
+        return False
+
+    return os.path.exists(output_file)
+
+
+def reorient_batch(input_dir: str, output_dir: str) -> pd.DataFrame:
+    """Reorient all NIfTI files found recursively under *input_dir*.
+
+    The directory structure is mirrored under *output_dir*.
+
+    Parameters
+    ----------
+    input_dir : str
+        Root directory containing NIfTI files.
+    output_dir : str
+        Root directory where reoriented files will be saved,
+        preserving the subdirectory structure.
+
+    Returns
+    -------
+    pd.DataFrame
+        Log with columns ``input``, ``output``, ``success``.
+    """
+    input_dir = os.path.abspath(input_dir)
+    output_dir = os.path.abspath(output_dir)
+
+    log_rows = []
+    for root, _dirs, files in os.walk(input_dir):
+        for fname in files:
+            if not fname.endswith(".nii.gz"):
+                continue
+
+            input_path = os.path.join(root, fname)
+            rel = os.path.relpath(root, input_dir)
+            out_path = os.path.join(output_dir, rel, fname)
+
+            logger.info("Reorienting %s", input_path)
+            success = reorient_single(input_path, out_path)
+            log_rows.append({"input": input_path, "output": out_path, "success": success})
+
+            if success:
+                logger.info("OK: %s", fname)
+            else:
+                logger.warning("FAILED: %s", fname)
+
+    df = pd.DataFrame(log_rows)
+
+    # Save log
+    log_path = os.path.join(output_dir, "reorientation_log.csv")
+    os.makedirs(output_dir, exist_ok=True)
+    df.to_csv(log_path, index=False)
+    logger.info("Reorientation log saved at %s", log_path)
+
+    return df

caideface/skull_strip.py

@@ -0,0 +1,248 @@
+"""Step 2: Skull-stripping with HD-BET and dynamic mask dilation."""
+
+import os
+import subprocess
+import sys
+import logging
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+from scipy.ndimage import binary_dilation
+
+logger = logging.getLogger(__name__)
+
+
+def get_default_device() -> str:
+    """Return 'cuda' if a GPU is available, else 'cpu'."""
+    try:
+        import torch
+        return "cuda" if torch.cuda.is_available() else "cpu"
+    except ImportError:
+        return "cuda" if os.system("nvidia-smi > /dev/null 2>&1") == 0 else "cpu"
+
+
+def _hd_bet_executable() -> str:
+    """Return the path to hd-bet that belongs to the current Python env."""
+    env_bin = os.path.dirname(sys.executable)
+    env_hdbet = os.path.join(env_bin, "hd-bet")
+    if os.path.isfile(env_hdbet):
+        return env_hdbet
+    # Fall back to PATH
+    result = subprocess.run(["which", "hd-bet"], capture_output=True, text=True)
+    if result.returncode == 0:
+        return result.stdout.strip()
+    raise EnvironmentError(
+        "hd-bet not found. Install it with: pip install hd-bet\n"
+        "See: https://github.com/MIC-DKFZ/HD-BET"
+    )
+
+
+def get_safe_structuring_element(
+    voxel_sizes: tuple,
+    desired_dilation_mm: float = 14.0,
+    max_kernel_shape: tuple = (30, 30, 30),
+) -> np.ndarray:
+    """Compute a 3D structuring element adapted to voxel sizes.
+
+    This ensures a consistent physical dilation distance in mm regardless
+    of voxel resolution.
+
+    Parameters
+    ----------
+    voxel_sizes : tuple of float
+        Voxel spacing (mm) along each axis.
+    desired_dilation_mm : float
+        Desired physical dilation size in mm.
+    max_kernel_shape : tuple of int
+        Maximum allowed structuring element size per axis.
+
+    Returns
+    -------
+    np.ndarray
+        Binary structuring element.
+    """
+    shape = tuple(
+        min(mk, max(1, int(round(desired_dilation_mm / vs))))
+        for vs, mk in zip(voxel_sizes, max_kernel_shape)
+    )
+    logger.debug("Structuring element shape: %s", shape)
+    return np.ones(shape, dtype=np.uint8)
+
+
+def is_valid_3d_volume(filepath: str) -> bool:
+    """Return True if the NIfTI file is a 3D volume (not 2D or 4D)."""
+    if not filepath.endswith(".nii.gz"):
+        return False
+    try:
+        img = nib.load(filepath)
+        shape = img.shape
+        return len(shape) == 3 and all(d > 1 for d in shape)
+    except Exception:
+        return False
+
+
+def skull_strip_single(
+    input_file: str,
+    input_root: str,
+    output_dir: str,
+    device: str = "cpu",
+    disable_tta: bool = True,
+    desired_dilation_mm: float = 14.0,
+) -> dict:
+    """Run HD-BET on a single NIfTI file and produce dilated brain mask.
+
+    Parameters
+    ----------
+    input_file : str
+        Path to a reoriented NIfTI file.
+    input_root : str
+        Root input directory (used to compute relative paths).
+    output_dir : str
+        Root output directory.
+    device : str
+        'cpu' or 'cuda'.
+    disable_tta : bool
+        Disable test-time augmentation for faster processing.
+    desired_dilation_mm : float
+        Physical dilation size in mm for mask expansion.
+
+    Returns
+    -------
+    dict
+        Status dict with keys: input, output, hd_bet, mask, dilated.
+    """
+    filename = os.path.basename(input_file)
+    stem = filename.replace(".nii.gz", "")
+    subfolder = os.path.relpath(os.path.dirname(input_file), start=input_root)
+
+    hd_bet_file = os.path.join(output_dir, subfolder, f"{stem}_brain.nii.gz")
+    mask_file = os.path.join(output_dir, subfolder, f"{stem}_mask.nii.gz")
+    dilated_file = os.path.join(output_dir, subfolder, f"{stem}_dilated.nii.gz")
+
+    os.makedirs(os.path.dirname(hd_bet_file), exist_ok=True)
+
+    status = {
+        "hd_bet": "skipped" if os.path.exists(hd_bet_file) else "pending",
+        "mask": "skipped" if os.path.exists(mask_file) else "pending",
+        "dilated": "skipped" if os.path.exists(dilated_file) else "pending",
+    }
+
+    try:
+        # --- HD-BET ---
+        if not os.path.exists(hd_bet_file):
+            hdbet_bin = _hd_bet_executable()
+            cmd = [hdbet_bin, "-i", input_file, "-o", hd_bet_file, "-device", device]
+            if disable_tta:
+                cmd.append("--disable_tta")
+            try:
+                subprocess.run(cmd, check=True, capture_output=True, text=True)
+                status["hd_bet"] = "success"
+            except subprocess.CalledProcessError as e:
+                logger.error("hd-bet failed for %s: %s", input_file, e.stderr)
+                status["hd_bet"] = "failed"
+                return {"input": input_file, "output": hd_bet_file, **status, "error": e.stderr}
+
+        # --- Binary mask + dilation ---
+        if not os.path.exists(mask_file):
+            img = nib.load(hd_bet_file)
+            data = img.get_fdata()
+            voxel_sizes = img.header.get_zooms()[:3]
+
+            struct_elem = get_safe_structuring_element(voxel_sizes, desired_dilation_mm)
+
+            binary_volume = (data > 0).astype(np.uint8)
+            dilated_data = binary_dilation(binary_volume, structure=struct_elem)
+
+            nib.save(nib.Nifti1Image(dilated_data, img.affine, img.header), mask_file)
+            status["mask"] = "success" if os.path.exists(mask_file) else "failed"
+
+        # --- Apply dilated mask to original scan ---
+        if not os.path.exists(dilated_file):
+            mask_img = nib.load(mask_file)
+            mask_data = (mask_img.get_fdata() > 0).astype(np.uint8)
+
+            original_img = nib.load(input_file)
+            original_data = original_img.get_fdata()
+
+            dilated_volume = original_data * mask_data
+            nib.save(
+                nib.Nifti1Image(dilated_volume, original_img.affine, original_img.header),
+                dilated_file,
+            )
+            status["dilated"] = "success" if os.path.exists(dilated_file) else "failed"
+
+    except Exception as e:
+        logger.exception("Error processing %s", input_file)
+        for k in status:
+            if status[k] == "pending":
+                status[k] = "failed"
+
+    return {"input": input_file, "output": hd_bet_file, **status}
+
+
+def skull_strip_batch(
+    input_dir: str,
+    output_dir: str,
+    device: str | None = None,
+    disable_tta: bool = True,
+    desired_dilation_mm: float = 14.0,
+) -> pd.DataFrame:
+    """Run HD-BET skull-stripping on all 3D NIfTI volumes under *input_dir*.
+
+    Scans that are not 3D volumes (2D slices or 4D time series) are skipped.
+
+    Parameters
+    ----------
+    input_dir : str
+        Root directory with reoriented NIfTI files.
+    output_dir : str
+        Root output directory for HD-BET results.
+    device : str or None
+        'cpu' or 'cuda'. Auto-detected if None.
+    disable_tta : bool
+        Disable test-time augmentation.
+    desired_dilation_mm : float
+        Physical dilation in mm.
+
+    Returns
+    -------
+    pd.DataFrame
+        Processing log.
+    """
+    # Validate hd-bet is available (will raise if not found)
+    _hd_bet_executable()
+
+    if device is None:
+        device = get_default_device()
+
+    input_dir = os.path.abspath(input_dir)
+    output_dir = os.path.abspath(output_dir)
+    os.makedirs(output_dir, exist_ok=True)
+
+    log_data = []
+
+    for root, _dirs, files in os.walk(input_dir):
+        for fname in files:
+            input_file = os.path.join(root, fname)
+
+            if not is_valid_3d_volume(input_file):
+                continue
+
+            logger.info("Processing: %s", input_file)
+            result = skull_strip_single(
+                input_file, input_dir, output_dir, device, disable_tta, desired_dilation_mm
+            )
+            log_data.append(result)
+
+    df = pd.DataFrame(log_data)
+    log_path = os.path.join(output_dir, "hd_bet_log.csv")
+
+    if os.path.exists(log_path):
+        existing = pd.read_csv(log_path)
+        df = pd.concat([existing, df], ignore_index=True)
+
+    df.to_csv(log_path, index=False)
+    logger.info("HD-BET log saved at %s", log_path)
+
+    return df

caideface-0.1.3.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: caideface
+Version: 0.1.3
+Summary: MRI defacing pipeline with skull-stripping and affine registration from cai4cai
+Author-email: Lorena Garcia-Foncillas <lorenagarfon00@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/LorenaGarcia-Foncillas/caideface
+Project-URL: Repository, https://github.com/LorenaGarcia-Foncillas/caideface
+Keywords: MRI,defacing,anonymisation,skull-stripping,neuroimaging
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: nibabel>=4.0
+Requires-Dist: numpy<2,>=1.22
+Requires-Dist: scipy>=1.9
+Requires-Dist: SimpleITK>=2.2
+Requires-Dist: pandas>=1.5
+Requires-Dist: natsort>=8.0
+Requires-Dist: tqdm>=4.60
+Requires-Dist: hd-bet
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# caideface
+
+**MRI defacing pipeline with skull-stripping and affine registration** from the [cai4cai](https://cai4cai.ml/) research group (Contextual Artificial Intelligence for Computer Assisted Interventions).
+
+This pipeline anonymises head MRI scans by removing facial features while preserving brain structures, as described in the paper *"A Generalisable Head MRI Defacing Pipeline: Evaluation on 2,566 Meningioma Scans"* ([arXiv:2505.12999](https://arxiv.org/abs/2505.12999)).
+
+## Pipeline overview
+
+The pipeline consists of three steps:
+
+1. **Reorientation** -- Aligns NIfTI scans to LAS canonical orientation (MNI152 standard) using nibabel.
+2. **Skull-stripping** -- Extracts brain masks using [HD-BET](https://github.com/MIC-DKFZ/HD-BET), then applies dynamic dilation to preserve peripheral brain structures.
+3. **Registration & Defacing** -- Registers each scan to the MNI152 template using BRAINSFit (affine), warps a face mask into the scan's space, and applies it to remove facial features.
+
+The MNI152 skull-stripped template and face mask are **bundled with the package**, so no additional downloads are needed.
+
+## Requirements
+
+### Python
+
+- Python >= 3.9
+
+### External tools (not pip-installable)
+
+| Tool | Used in | Install |
+|------|---------|---------|
+| **BRAINSFit** & **BRAINSResample** | Step 3 | Bundled with [3D Slicer](https://www.slicer.org/) |
+
+> **Note:** Step 1 (reorientation) no longer requires FSL -- it uses nibabel's orientation tools to reorient scans to LAS (equivalent to `fslreorient2std`).
+
+#### Finding BRAINSFit and BRAINSResample
+
+These executables are included with 3D Slicer. Common locations:
+
+- **macOS**: `/Applications/Slicer.app/Contents/lib/Slicer-5.8/cli-modules/BRAINSFit`
+- **Linux**: `/path/to/Slicer/lib/Slicer-5.8/cli-modules/BRAINSFit`
+
+Replace `5.8` with your installed Slicer version if different. To verify the executables are found and working:
+
+```bash
+# Check they exist
+ls /Applications/Slicer.app/Contents/lib/Slicer-5.8/cli-modules/BRAINSFit
+ls /Applications/Slicer.app/Contents/lib/Slicer-5.8/cli-modules/BRAINSResample
+
+# Check they run (should print usage/help info)
+/Applications/Slicer.app/Contents/lib/Slicer-5.8/cli-modules/BRAINSFit --help
+/Applications/Slicer.app/Contents/lib/Slicer-5.8/cli-modules/BRAINSResample --help
+```
+
+You can also build them from source via [BRAINSTools](https://github.com/BRAINSia/BRAINSTools).
+
+## Installation
+
+We recommend using a conda environment:
+
+```bash
+conda create -n caideface python=3.10 -y
+conda activate caideface
+pip install caideface
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/cai4cai/caideface.git
+cd caideface
+pip install -e .
+```
+
+> **Note:** caideface requires `numpy<2` (enforced automatically). Some dependencies (HD-BET / nnU-Net) are not yet compatible with NumPy 2.x.
+
+## Usage
+
+### CLI -- Full pipeline
+
+Run all three steps in one command:
+
+```bash
+caideface run ./input_nifti ./output \
+  --brainsfit /path/to/BRAINSFit \
+  --brainsresample /path/to/BRAINSResample
+```
+
+This creates three subdirectories under `./output`:
+- `reoriented/` -- Step 1 outputs
+- `hdbet/` -- Step 2 outputs (skull-stripped, masks, dilated)
+- `defaced/` -- Step 3 outputs (final defaced scans)
+
+#### Options
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--device` | auto-detected | `cpu` or `cuda` for HD-BET |
+| `--no-tta` | on | Disable HD-BET test-time augmentation (faster but less accurate) |
+| `--dilation-mm` | `14.0` | Brain mask dilation in mm |
+| `--background` | `0` | Fill value for defaced regions (0 for MRI, -1024 for CT) |
+| `--template` | bundled | Custom MNI152 skull-stripped template |
+| `--face-mask` | bundled | Custom face mask in MNI152 space |
+| `--steps` | `all` | Run specific steps: `reorient`, `skull_strip`, `deface` (comma-separated) |
+| `-v` | off | Verbose/debug logging |
+
+### CLI -- Individual steps
+
+Run each step separately for more control:
+
+```bash
+# Step 1: Reorientation
+caideface reorient ./raw_nifti ./reoriented
+
+# Step 2: Skull-stripping
+caideface skull-strip ./reoriented ./hdbet --device cpu
+
+# Step 3: Registration & Defacing
+caideface deface ./reoriented ./hdbet ./defaced \
+  --brainsfit /path/to/BRAINSFit \
+  --brainsresample /path/to/BRAINSResample
+```
+
+## Output structure
+
+```
+output/
+├── reoriented/
+│   ├── reorientation_log.csv
+│   └── <subject>/<scan>.nii.gz
+├── hdbet/
+│   ├── hd_bet_log.csv
+│   └── <subject>/
+│       ├── hd_bet_<scan>.nii.gz           # Skull-stripped
+│       ├── hd_bet_mask_<scan>.nii.gz      # Dilated brain mask
+│       └── hd_bet_dilated_<scan>.nii.gz   # Dilated skull-stripped
+└── defaced/
+    ├── not_defaced_scans.csv              # Only if failures occurred
+    └── <subject>/
+        └── hd_bet_dilated_<scan>_masked.nii.gz  # Final defaced scan
+```
+
+## Existing transforms
+
+If you have pre-computed registration transforms (e.g. from 3D Slicer), place a file named `Transform_to_template.txt` in the same directory as the dilated skull-stripped scan. The pipeline will use it instead of running BRAINSFit. Both plain 4x4 text matrices and ITK/Slicer transform formats are supported.
+
+## Citation
+
+If you use this tool, please cite:
+
+```bibtex
+@article{caideface2025,
+  title={A Generalisable Head MRI Defacing Pipeline: Evaluation on 2,566 Meningioma Scans},
+  year={2025},
+  url={https://arxiv.org/abs/2505.12999}
+}
+```
+
+If you use HD-BET (skull-stripping, Step 2), please also cite:
+
+```bibtex
+@article{Isensee2019,
+  author={Isensee, F. and Schell, M. and Tursunova, I. and Brugnara, G. and Bonekamp, D. and Neuberger, U. and Wick, A. and Schlemmer, H. P. and Heiland, S. and Wick, W. and Bendszus, M. and Maier-Hein, K. H. and Kickingereder, P.},
+  title={Automated brain extraction of multi-sequence MRI using artificial neural networks},
+  journal={Human Brain Mapping},
+  year={2019},
+  pages={1--13},
+  doi={10.1002/hbm.24750}
+}
+```
+
+## License
+
+This project is licensed under the MIT License -- see the [LICENSE](LICENSE.md) file for details.

caideface-0.1.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+caideface/__init__.py,sha256=msDPaEjxupVzd6NlyPE10Nv35BflTJJLgWbfX9pSH4Q,665
+caideface/cli.py,sha256=Ze8ZAzbYPAIAGz54YdQPD4CfXXnQlqP4O2keskhhwws,6085
+caideface/pipeline.py,sha256=7GRKY7MUaj5YfE6gG2lBBmen67JDXiBzf1_ze9K9QK0,4849
+caideface/register.py,sha256=fF0SWI9pEpV70SN2GUOJxR2PfN1yyP-h-whRCIDQ5yg,13438
+caideface/reorient.py,sha256=YbRSE9XmNy-MbVVfukED6I3lbNCcPkF527h1nQRBaj8,3004
+caideface/skull_strip.py,sha256=iGBkpM1q-cV87qOmDDI3DXktAapzH_vq5VE3JhLou9k,8003
+caideface/data/mni_icbm152_t1_tal_nlin_sym_55_ext_brain_only.nii.gz,sha256=z_8nUQneAGj-CF-rSDtStwGXRbpopT3I_Gu1bDCSoTo,7398318
+caideface/data/t1_mask.nii.gz,sha256=fsePOut8Cv1ywZzNn9NRQbYKlrUdEHh7En99wIyB8oo,512923
+caideface-0.1.3.dist-info/licenses/LICENSE.md,sha256=OKBUz68LPq02070_4Swh-7AOVr4U0HemWq2gZTKcpnM,1074
+caideface-0.1.3.dist-info/METADATA,sha256=ytzsxwjzBSUJ_0o9Ly0Ef5AWlExEZLlvNfE3J-RMVEw,7178
+caideface-0.1.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+caideface-0.1.3.dist-info/entry_points.txt,sha256=NUUL-AAOAC7oTaL9AAQKnkHCxdS7od1pzUFe6FtKCeQ,49
+caideface-0.1.3.dist-info/top_level.txt,sha256=dXA98OltCVkbV76cm3x9ZCqSHgtYQO_CVUmHDpBHTq8,10
+caideface-0.1.3.dist-info/RECORD,,

caideface-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

caideface-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+caideface = caideface.cli:main

caideface-0.1.3.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2025-present cai4cai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

caideface-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+caideface