Remove the CBCT_CT_TS preset

CBCT_CT_TS/Evaluation_with_fid.yml

@@ -1,22 +0,0 @@
-Evaluator:
-  metrics:
-    FixedFid:
-      targets_criterions:
-        MovingFid:
-          criterions_loader:
-            TRE: {}
-  Dataset:
-    groups_src:
-      Volume_0:
-        groups_dest:
-          FixedFid:
-            transforms: None
-      Reference_0:
-        groups_dest:
-          MovingFid:
-            transforms: None
-    subset: None
-    dataset_filenames:
-    - ./Dataset:mha
-    validation: None
-  train_name: ImpactReg

CBCT_CT_TS/Evaluation_with_images.yml

@@ -1,35 +0,0 @@
-Evaluator:
-  metrics:
-    FixedImage:
-      targets_criterions:
-        MovingImage;Mask:
-          criterions_loader:
-            MAESaveMap:
-              reduction: mean
-              dataset: ./Evaluations/ImpactReg/Output:mha
-              group: MAE_map
-  Dataset:
-    groups_src:
-      Volume_0:
-        groups_dest:
-          FixedImage:
-            transforms: 
-              TensorCast:
-                dtype: float32
-      Reference_0:
-        groups_dest:
-          MovingImage:
-            transforms: 
-              TensorCast:
-                dtype: float32
-      Mask_0:
-        groups_dest:
-          Mask:
-            transforms:
-              TensorCast:
-                dtype: uint8
-    subset: None
-    dataset_filenames:
-    - ./Dataset:mha
-    validation: None
-  train_name: ImpactReg

CBCT_CT_TS/Evaluation_with_seg.yml

@@ -1,29 +0,0 @@
-Evaluator:
-  metrics:
-    FixedSeg:
-      targets_criterions:
-        MovingSeg:
-          criterions_loader:
-            DiceSaveMap:
-              labels: None
-              dataset: ./Evaluations/ImpactReg/Output:mha
-              group: Seg_MAE_map
-  Dataset:
-    groups_src:
-      Volume_0:
-        groups_dest:
-          FixedSeg:
-            transforms: 
-              TensorCast:
-                dtype: uint8
-      Reference_0:
-        groups_dest:
-          MovingSeg:
-            transforms: 
-              TensorCast:
-                dtype: uint8
-    subset: None
-    dataset_filenames:
-    - ./Dataset:mha
-    validation: None
-  train_name: ImpactReg

CBCT_CT_TS/Model.py

@@ -1,301 +0,0 @@
-# Copyright (c) 2025 Valentin Boussot
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""Registration as a KonfAI model: the config -> elastix parameter-map mapping + the ``add_module`` graph.
-
-``RegistrationNet`` wires ``ElastixRegistration`` (fixed = branch 0, moving = branch 1, fixed/moving masks =
-2/3) and splits its output into ``MovedImage`` / ``DisplacementField`` on the fixed grid. This module owns
-the MAPPING — the per-resolution model matrix (``resolutions``) turned into IMPACT parameter-map lines, and
-the config schema (``ModelSpec`` / ``ResolutionSpec``). The elastix RUNTIME (binary install, model download,
-subprocess, progress) lives in ``elastix_engine.py`` and is imported only when the graph is built.
-
-A UI reads the tuning knobs straight from the TYPES below: ``Literal`` (a fixed set),
-``Annotated[.., Range]`` (numeric bounds), ``Annotated[str, Choices(...)]`` (a resolver the app owns).
-
-NOTE: do NOT add ``from __future__ import annotations`` — KonfAI's config engine reads runtime annotations
-(``get_origin``); PEP 563 stringized annotations break arg resolution.
-"""
-
-import json
-import os
-import re
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Annotated, Literal
-
-import torch
-from huggingface_hub import hf_hub_download
-from konfai.network import network
-from konfai.utils.config import Choices, Range
-
-# IMPACT field docs: https://github.com/vboussot/ImpactLoss/tree/main/ParameterMaps
-# A model's FIXED props (dimension / channels / FOV formula) come from the registry (models.json on
-# VBoussot/impact-torchscript-models); the config carries the FREE knobs (models per resolution, voxel size,
-# iterations, per-model weights/mask/subset/pca/distance) and the global ``mode``.
-_IMPACT_MODELS_REGISTRY = "VBoussot/impact-torchscript-models:models.json"
-
-# ``2^l+3`` plateaus: segmenter layers 7-8 share layer 6's receptive field. Deeper configs should run
-# Static anyway; in Jacobian we clamp ``l`` to this plateau.
-_FOV_RAMP_MAX_LAYER = 6
-
-
-def registry_choices() -> list[str]:
-    """The ``ref`` picker's values — model refs (``repo:path``) from the registry the engine already fetches
-    (offline-first). A user may still point ``ref`` at a local model."""
-    repo = _IMPACT_MODELS_REGISTRY.split(":", 1)[0]
-    return [f"{repo}:{key}" for key in load_models_registry()]
-
-
-def _num(x: object) -> str:
-    """Format a number the elastix way: no trailing '.0' (6.0 -> '6', 0.2 -> '0.2')."""
-    return "%g" % float(x)
-
-
-@dataclass
-class ModelSpec:
-    """One feature model at one resolution (several may share a resolution). ``ref`` picks the model; the
-    rest are its per-(resolution, model) knobs. Dimension / channels / FOV are intrinsic — from the registry
-    (``models.json``) keyed by ``ref`` — never tuned."""
-
-    ref: Annotated[str, Choices(registry_choices)]
-    voxel_size: list[float] = field(default_factory=list)
-    layers_weight: list[float] = field(default_factory=lambda: [1.0])
-    subset_features: Annotated[int, Range(0, 1000)] = 0
-    pca: Annotated[int, Range(0, 100)] = 0
-    distance: Literal["L1", "L2", "Dice", "Cosine", "NCC"] = "L1"
-    layers_mask: str = ""
-
-
-@dataclass
-class ResolutionSpec:
-    """One elastix resolution level: its iteration budget and the (self-configured) models compared there."""
-
-    max_iterations: Annotated[int, Range(1, 100000)]
-    models: dict[str, ModelSpec]
-
-
-def _sorted_specs(mapping: dict) -> list:
-    """dict keyed by string indices ('0','1',...) -> values in numeric order."""
-    return [mapping[k] for k in sorted(mapping, key=lambda key: int(key))]
-
-
-def load_models_registry(ref: str = _IMPACT_MODELS_REGISTRY) -> dict:
-    """Load models.json (the fixed params per model) from the model repo on Hugging Face.
-
-    The registry is NOT bundled with the preset. ``KONFAI_IMPACT_MODELS_REGISTRY`` (a local path) wins for
-    dev/offline; otherwise ``ref`` must be a ``repo:file`` Hugging Face reference.
-    """
-    local = os.environ.get("KONFAI_IMPACT_MODELS_REGISTRY", "")
-    if local:
-        path = Path(local)
-    elif ":" in ref:
-        repo, filename = ref.split(":", 1)
-        path = Path(hf_hub_download(repo_id=repo, filename=filename, repo_type="model"))  # nosec B615
-    else:
-        raise ValueError(
-            f"models_registry '{ref}' must be a 'repo:file' Hugging Face reference (the registry is fetched "
-            f"from HF, not bundled) — or set KONFAI_IMPACT_MODELS_REGISTRY to a local file for offline use."
-        )
-    return json.loads(path.read_text(encoding="utf-8"))
-
-
-def _model_key(ref: str) -> str:
-    """Registry key / staged relative path = the model file within the repo (strip a 'repo:' prefix)."""
-    return ref.split(":", 1)[1] if ":" in ref else ref
-
-
-def _deepest_active_layer(layers_mask: str) -> int:
-    """Deepest (largest-FOV) layer selected by ``layers_mask``, as a 0-based index.
-
-    A model returns its layers shallow->deep; ``layers_mask`` has one char per returned layer, position ``i``
-    == ``layer_i``, ``'1'`` = selected. In Jacobian the patch must cover the DEEPEST selected layer's
-    receptive field, so the FOV is governed by the rightmost ``'1'``.
-    """
-    mask = layers_mask.strip().strip('"')
-    active = [i for i, char in enumerate(mask) if char == "1"]
-    if not active:
-        raise ValueError(f"LayersMask '{layers_mask}' selects no layer; cannot derive the model FOV.")
-    return max(active)
-
-
-def _fov_value(fov: dict, layers_mask: str) -> int:
-    """Evaluate a model's field-of-view (in voxels) from its registry ``fov`` spec.
-
-    Formulas (model repo, https://huggingface.co/VBoussot/impact-torchscript-models):
-      ``2*r*d+1``  MIND, from radius ``r`` / dilation ``d`` (R1D2 -> 5);
-      ``2^l+3``    TotalSegmentator / MRSegmentator, ``l`` = deepest layer picked by ``layers_mask``, clamped
-                   to the receptive-field plateau ``_FOV_RAMP_MAX_LAYER`` (layers 7-8 -> layer 6);
-      a bare int   a fixed FOV (SAM2.1 -> 29, DINOv2 -> 14);
-      ``Global``   Anatomix — whole-image only (Static); no finite Jacobian patch -> error.
-    An explicit ``value`` in the spec is honoured as a precomputed shortcut.
-    """
-    formula = str(fov.get("formula", "")).strip()
-    key = re.sub(r"\s+", "", formula).lower()
-    if key.isdigit():
-        return int(key)
-    if key == "2*r*d+1":
-        return 2 * int(fov["r"]) * int(fov["d"]) + 1
-    if key == "2^l+3":
-        return 2 ** min(_deepest_active_layer(layers_mask), _FOV_RAMP_MAX_LAYER) + 3
-    if "global" in key:
-        raise ValueError(f"model FOV '{formula}' is whole-image only (Static); it has no Jacobian patch size.")
-    if fov.get("value") is not None:
-        return int(fov["value"])
-    raise ValueError(f"cannot evaluate model FOV formula '{formula}'.")
-
-
-def _patch_size(mode: str, entry: dict, layers_mask: str) -> str:
-    """PatchSize from the model FOV, one token per model axis (2D -> 2 tokens, 3D -> 3): Static -> whole
-    image (all zeros); Jacobian -> the evaluated FOV per axis. A 2D+3D mix at a resolution concatenates,
-    e.g. ``29 29 11 11 11`` (SAM 2D + TS 3D), matching IMPACT."""
-    dim = int(entry.get("dimension", 3))
-    if mode.strip().strip('"').lower() != "jacobian":
-        return " ".join(["0"] * dim)
-    fov = _fov_value(entry.get("fov", {}), layers_mask)
-    return " ".join([str(fov)] * dim)
-
-
-def generate_impact_parameter_map(template_text: str, resolutions: dict, registry: dict, mode: str = "Static") -> str:
-    """Rewrite the resolution-dependent lines of ``template_text`` from the model matrix ``resolutions``.
-
-    Regenerated: MaximumNumberOfIterations, NumberOfResolutions, Fixed/MovingImagePyramidRescaleSchedule,
-    ImpactMode, and the whole ImpactXxxK block; every other line is kept verbatim. N (number of resolutions)
-    is deduced from the config. ``mode`` drives PatchSize: Static -> ``0 0 0``; Jacobian -> the per-model FOV
-    from the registry formula and the cell's ``layers_mask``.
-    """
-    res = _sorted_specs(resolutions)
-    n = len(res)
-    mode_clean = mode.strip().strip('"') or "Static"
-
-    impact: list[str] = []
-    for k, r in enumerate(res):
-        models = _sorted_specs(r.models)
-        entries = [registry[_model_key(m.ref)] for m in models]
-
-        def row(stem: str, values: list[str]) -> None:
-            impact.append(f"(Impact{stem}{k} " + " ".join(values) + ")")
-
-        # From the registry ONLY the 3 truly model-fixed props (Dimension, NumberOfChannels, PatchSize = the
-        # model FOV); everything else is a per-model knob taken straight from the cell.
-        row("ModelsPath", [f'"{_model_key(m.ref)}"' for m in models])
-        row("Dimension", [e["dimension"] for e in entries])
-        row("NumberOfChannels", [e["numberofchannels"] for e in entries])
-        row("PatchSize", [_patch_size(mode_clean, e, m.layers_mask) for e, m in zip(entries, models)])
-        row("VoxelSize", [" ".join(_num(v) for v in m.voxel_size) for m in models])
-        row("LayersMask", [f'"{m.layers_mask}"' for m in models])
-        row("SubsetFeatures", [str(m.subset_features) for m in models])
-        row("PCA", [str(m.pca) for m in models])
-        row("Distance", [f'"{m.distance}"' for m in models])
-        row("LayersWeight", [" ".join(_num(w) for w in m.layers_weight) for m in models])
-        impact.append("")  # blank line between resolutions, mirroring the reference maps
-
-    # The per-resolution block is the contiguous span from the first to the last ``Impact<name><k>`` line
-    # (inner blanks fall inside it). Replace the whole span at its first line so reference blanks aren't kept.
-    lines = template_text.splitlines()
-    indexed = [(re.match(r"^\s*\((\S+?)\s+(.*?)\)\s*$", ln), ln) for ln in lines]
-    block_rows = [i for i, (m, _) in enumerate(indexed) if m and re.match(r"^Impact[A-Za-z]+\d+$", m.group(1))]
-    block_lo, block_hi = (block_rows[0], block_rows[-1]) if block_rows else (-1, -2)
-
-    out: list[str] = []
-    for i, (m, line) in enumerate(indexed):
-        key = m.group(1) if m else None
-        if block_lo <= i <= block_hi:
-            if i == block_lo:  # replace the whole span at its first line, drop the rest (incl. inner blanks)
-                out.extend(impact[:-1])
-        elif key == "MaximumNumberOfIterations":
-            out.append("(MaximumNumberOfIterations " + " ".join(_num(r.max_iterations) for r in res) + ")")
-        elif key == "NumberOfResolutions":
-            out.append(f"(NumberOfResolutions {n})")
-        elif key in ("FixedImagePyramidRescaleSchedule", "MovingImagePyramidRescaleSchedule"):
-            out.append(f"({key} " + " ".join(["1"] * 3 * n) + ")")
-        elif key == "ImpactMode":
-            out.append(f'(ImpactMode "{mode_clean}")')
-        else:
-            out.append(line)
-    return "\n".join(out)
-
-
-class ChannelSelect(torch.nn.Module):
-    """Select a channel slice ``[start:stop]`` (splits the registration output into moved / DVF)."""
-
-    def __init__(self, start: int, stop: int) -> None:
-        super().__init__()
-        self._start = start
-        self._stop = stop
-
-    def forward(self, tensor: torch.Tensor) -> torch.Tensor:
-        return tensor[:, self._start : self._stop]
-
-
-class RegistrationNet(network.Network):
-    """Pairwise registration as an ``add_module`` graph (fixed = branch 0, moving = branch 1, fixed mask = 2,
-    moving mask = 3; masks restrict the metric, whole-image = no restriction).
-
-    Outputs (both on the fixed grid): ``MovedImage`` (moving resampled onto fixed) and ``DisplacementField``
-    (the dim-component displacement field, mm). ``ElastixRegistration`` produces both channel-stacked; two
-    ``ChannelSelect`` modules split them. Output geometry is attached by the predictor via
-    ``same_as_group: Volume_0:Fixed``.
-    """
-
-    def __init__(
-        self,
-        optimizer: network.OptimizerLoader = network.OptimizerLoader(),
-        schedulers: dict[str, network.LRSchedulersLoader] = {
-            "default:ReduceLROnPlateau": network.LRSchedulersLoader(0)
-        },
-        outputs_criterions: dict[str, network.TargetCriterionsLoader] = {"default": network.TargetCriterionsLoader()},
-        engine: str = "elastix",
-        parameter_maps: list[str] = [],
-        max_iterations: Annotated[int, Range(0, 100000)] = 0,
-        final_grid_spacing: Annotated[float, Range(0.0, 100.0)] = 0.0,
-        subset_features: Annotated[int, Range(0, 1000)] = 0,
-        spatial_samples: Annotated[int, Range(0, 100000)] = 0,
-        parameter_overrides: list[str] = [],
-        resolutions: dict[str, ResolutionSpec] = {},
-        mode: Literal["Static", "Jacobian"] = "Static",
-    ) -> None:
-        # The registration is fully described by ``resolutions`` (config = source of truth): each resolution
-        # lists its self-configured models; the download list is derived from the cells. Global knobs override
-        # the generated map (final_grid_spacing -> FinalGridSpacingInPhysicalUnits mm, spatial_samples ->
-        # NumberOfSpatialSamples, parameter_overrides 'Key=value'). Empty ``resolutions`` = an intensity-only
-        # preset (fixed maps + overrides). The elastix runtime is imported here (heavy: torch/sitk/subprocess).
-        from elastix_engine import ElastixRegistration
-
-        super().__init__(
-            in_channels=1,
-            optimizer=optimizer,
-            schedulers=schedulers,
-            outputs_criterions=outputs_criterions,
-            dim=3,
-        )
-        self.add_module(
-            "Registration",
-            ElastixRegistration(
-                engine,
-                parameter_maps,
-                max_iterations,
-                final_grid_spacing,
-                subset_features,
-                spatial_samples,
-                parameter_overrides,
-                resolutions,
-                mode,
-            ),
-            in_branch=[0, 1, 2, 3],
-            out_branch=["registration"],
-        )
-        self.add_module("MovedImage", ChannelSelect(0, 1), in_branch=["registration"], out_branch=["moved"])
-        self.add_module("DisplacementField", ChannelSelect(1, 4), in_branch=["registration"], out_branch=["dvf"])

CBCT_CT_TS/ParameterMap_CBCT_generic_TS.txt

@@ -1,152 +0,0 @@
-(MaximumNumberOfIterations 300 300 250 200)
-(NumberOfSpatialSamples 2000)
-(Transform "RecursiveBSplineTransform")
-(NumberOfResolutions 4)
-(FinalGridSpacingInPhysicalUnits 14)
-(FixedImagePyramid "FixedGenericImagePyramid")
-(MovingImagePyramid "MovingGenericImagePyramid")
-(FixedImagePyramidRescaleSchedule 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
-(MovingImagePyramidRescaleSchedule 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
-// (GridSpacingSchedule 10.000000 5.000000 2.000000 1.000000)
-
-
-
-(ImpactModelsPath0 "TS/M852.pt")
-(ImpactDimension0 3)
-(ImpactNumberOfChannels0 1)
-(ImpactPatchSize0 0 0 0)
-(ImpactVoxelSize0 3 3 3)
-(ImpactLayersMask0 "0000001")
-(ImpactSubsetFeatures0 64)
-(ImpactPCA0 0)
-(ImpactDistance0 "Dice")
-(ImpactLayersWeight0 1)
-
-(ImpactModelsPath1 "TS/M850.pt")
-(ImpactDimension1 3)
-(ImpactNumberOfChannels1 1)
-(ImpactPatchSize1 0 0 0)  
-(ImpactVoxelSize1 3 3 3)
-(ImpactLayersMask1 "00000001")
-(ImpactSubsetFeatures1 64)
-(ImpactPCA1 0)
-(ImpactDistance1 "Dice")
-(ImpactLayersWeight1 1)
-
-(ImpactModelsPath2 "TS/M850.pt")
-(ImpactDimension2 3)
-(ImpactNumberOfChannels2 1)
-(ImpactPatchSize2 0 0 0)
-(ImpactVoxelSize2 2 2 3)
-(ImpactLayersMask2 "01000001")
-(ImpactSubsetFeatures2 64 64)
-(ImpactPCA2 0 0)
-(ImpactDistance2 "L1" "Dice")
-(ImpactLayersWeight2 0.3 0.7)
-
-(ImpactModelsPath3 "TS/M850.pt")
-(ImpactDimension3 3)
-(ImpactNumberOfChannels3 1)
-(ImpactPatchSize3 0 0 0)
-(ImpactVoxelSize3 2 2 3)
-(ImpactLayersMask3 "01000001")
-(ImpactSubsetFeatures3 64 64)
-(ImpactPCA3 0 0)
-(ImpactDistance3 "L1" "Dice")
-(ImpactLayersWeight3 0.5 0.5)
-
-(ImpactModelsPath4 "TS/M850.pt")
-(ImpactDimension4 3)
-(ImpactNumberOfChannels4 1)
-(ImpactPatchSize4 0 0 0)
-(ImpactVoxelSize4 2 2 3)
-(ImpactLayersMask4 "01000000")
-(ImpactSubsetFeatures4 64)
-(ImpactPCA4 0)
-(ImpactDistance4 "L1")
-(ImpactLayersWeight4 1)
-
-
-(ImpactUseMixedPrecision "true")
-(ImpactFeaturesMapUpdateInterval -1)
-(ImpactWriteFeatureMaps "false")
-(ImpactMode "Static")
-(ImpactGPU 0)
-
-
-(Metric "Impact" "AdvancedMattesMutualInformation" "TransformBendingEnergyPenalty")
-(Metric0Weight 1)
-(Metric1Weight 0.4)
-(Metric2Weight 10)
-
-// imageTypes
-(FixedInternalImagePixelType "float")
-(MovingInternalImagePixelType "float")
-(UseDirectionCosines "true")
-
-// components
-(Registration "MultiMetricMultiResolutionRegistration")
-(BSplineTransformSplineOrder 3)
-(UseCyclicTransform "false")
-
-// transform
-(AutomaticTransformInitialization "false")
-(AutomaticTransformInitializationMethod "GeometricalCenter")
-(AutomaticScalesEstimation "true")
-(HowToCombineTransforms "Compose")
-
-
-// optimizer
-(Optimizer "AdaptiveStochasticGradientDescent")
-(MaximumNumberOfSamplingAttempts 8)
-(UseAdaptiveStepSizes "true")
-(UseMultiThreadingForMetrics "true")
-(ASGDParameterEstimationMethod "DisplacementDistribution")
-//(MaximumStepLength 0.6602)
-(SigmoidInitialTime 0.0)
-(NoiseCompensation "true")
-(NumberOfSamplesForExactGradient 4096)
-
-// automatic
-(AutomaticParameterEstimation "true")
-//(SP_alpha 1)
-//(SP_A 20.0)
-//(SP a 400)
-//(SigmoidMax 1.0)
-//(SigmoidMin -0.8)
-//(SigmoidScale 0.00000001)
-//(NumberOfGradientMeasurements 10)
-//(NumberOfJacobianMeasurements 1000)
-
-(FixedKernelBSplineOrder 3)
-(MovingKernelBSplineOrder 3)
-(CheckNumberOfSamples "true")
-(UseRelativeWeights "false")
-
-
-// several
-(WriteTransformParametersEachIteration "false")
-(WriteTransformParametersEachResolution "false")
-(ShowExactMetricValue "false")
-(ErodeFixedMask "false")
-(ErodeMovingMask "false")
-(UseBinaryFormatForTransformationParameters "false")
-
-// imageSampler
-(Interpolator "BSplineInterpolator")
-(ImageSampler "RandomCoordinate")
-(NewSamplesEveryIteration "true")
-(UseRandomSampleRegion "false")
-
-// interpolator and resampler
-(ResampleInterpolator "FinalBSplineInterpolator")
-(FinalBSplineInterpolationOrder 3)
-(BSplineInterpolationOrder 3)
-(Resampler "DefaultResampler")
-(WriteIterationInfo "false")
-(WriteResultImage "false")
-(DefaultPixelValue -1024)
-(ResultImageFormat "mha")
-
-(ITKTransformOutputFileNameExtension "itk.txt")
-(WriteITKCompositeTransform "true")

CBCT_CT_TS/Prediction.yml

@@ -1,118 +0,0 @@
-Predictor:
-  Model:
-    classpath: Model:RegistrationNet
-    RegistrationNet:
-      engine: elastix
-      parameter_maps:
-      - ParameterMap_CBCT_generic_TS.txt
-      outputs_criterions: None
-      max_iterations: 0
-      final_grid_spacing: 14.0
-      subset_features: 0
-      spatial_samples: 2000
-      parameter_overrides: []
-  Dataset:
-    groups_src:
-      Volume_0:
-        groups_dest:
-          Fixed:
-            transforms:
-              TensorCast:
-                dtype: float32
-                inverse: false
-            patch_transforms: None
-            is_input: true
-      Volume_1:
-        groups_dest:
-          Moving:
-            transforms:
-              TensorCast:
-                dtype: float32
-                inverse: false
-            patch_transforms: None
-            is_input: true
-      Volume_2:
-        groups_dest:
-          FixedMask:
-            transforms:
-              TensorCast:
-                dtype: float32
-                inverse: false
-            patch_transforms: None
-            is_input: true
-      Volume_3:
-        groups_dest:
-          MovingMask:
-            transforms:
-              TensorCast:
-                dtype: float32
-                inverse: false
-            patch_transforms: None
-            is_input: true
-    augmentations:
-      DataAugmentation_0:
-        data_augmentations:
-          Flip:
-            f_prob:
-            - 0
-            - 0.5
-            - 0.5
-            vector_field: true
-            prob: 1
-        nb: 2
-    Patch:
-      patch_size: None
-      overlap: None
-      mask: None
-      pad_value: None
-      extend_slice: 0
-    subset: None
-    filter: None
-    dataset_filenames:
-    - ./Dataset/:mha
-    use_cache: false
-    batch_size: 1
-    num_workers: None
-    pin_memory: false
-    prefetch_factor: None
-    persistent_workers: None
-  outputs_dataset:
-    MovedImage:
-      OutputDataset:
-        name_class: OutSameAsGroupDataset
-        before_reduction_transforms: None
-        after_reduction_transforms: None
-        final_transforms:
-          TensorCast:
-            dtype: float32
-            inverse: false
-        dataset_filename: Moved:mha
-        group: Moved
-        same_as_group: Volume_0:Fixed
-        patch_combine: None
-        inverse_transform: false
-        reduction: Mean
-        Mean: {}
-    DisplacementField:
-      OutputDataset:
-        name_class: OutSameAsGroupDataset
-        before_reduction_transforms: None
-        after_reduction_transforms: None
-        final_transforms:
-          TensorCast:
-            dtype: float32
-            inverse: false
-        dataset_filename: DVF:mha
-        group: DVF
-        same_as_group: Volume_0:Fixed
-        patch_combine: None
-        inverse_transform: false
-        reduction: Mean
-        Mean: {}
-  train_name: ImpactReg-CBCT-CT-TS
-  manual_seed: 42
-  gpu_checkpoints: None
-  images_log: None
-  combine: Mean
-  autocast: false
-  data_log: None

CBCT_CT_TS/Uncertainty.yml

@@ -1,24 +0,0 @@
-Evaluator:
-  metrics:
-    Uncertainty:
-      targets_criterions:
-        None:
-          criterions_loader:
-            Mean:
-              name: Uncertainty
-  Dataset:
-    groups_src:
-      Volume_0:
-        groups_dest:
-          Uncertainty:
-            transforms:
-              Norm: {}
-              StandardDeviation: {}
-              Save:
-                dataset: ./Uncertainties/ImpactReg/Output:mha
-                group: None
-    subset: None
-    dataset_filenames:
-    - ./Dataset:mha
-    validation: None
-  train_name: ImpactReg

CBCT_CT_TS/app.json

@@ -1,96 +0,0 @@
-{
-    "display_name": "CBCT/CT preset with TotalSegmentator",
-    "short_description": "Generic CBCT/CT deformable registration using TotalSegmentator features",
-    "description": "A four-level recursive B-spline deformable registration optimized for generic CBCT/CT alignment, driven by the IMPACT metric using semantic features extracted from pretrained TotalSegmentator TorchScript models. The optimization follows a multi-resolution ASGD scheme with up to 300, 300, 250, and 200 iterations using 2000 random spatial samples per level. Features are extracted at progressively finer voxel scales (3 mm, 3 mm, 2\u00d72\u00d73 mm, 2\u00d72\u00d73 mm), starting with Dice-based overlap on segmentation outputs and progressively integrating feature-level alignment via L1 distances on selected internal layers (0.3/0.7 then 0.5/0.5 L1/Dice), ending with a final purely feature-based stage. A composite objective (IMPACT + mutual information + bending energy penalty) ensures robust cross-modality alignment while enforcing smooth, physically plausible deformations.",
-    "task": "registration",
-    "tta": 0,
-    "mc_dropout": 0,
-    "models": [
-        "model.pt"
-    ],
-    "inputs": {
-        "Fixed": {
-            "display_name": "Fixed image",
-            "volume_type": "VOLUME",
-            "required": true
-        },
-        "Moving": {
-            "display_name": "Moving image",
-            "volume_type": "VOLUME",
-            "required": true
-        },
-        "FixedMask": {
-            "display_name": "Fixed mask (optional)",
-            "volume_type": "SEGMENTATION",
-            "required": false,
-            "default": "ones"
-        },
-        "MovingMask": {
-            "display_name": "Moving mask (optional)",
-            "volume_type": "SEGMENTATION",
-            "required": false,
-            "default": "ones"
-        }
-    },
-    "outputs": {
-        "MovedImage": {
-            "display_name": "Moved image",
-            "volume_type": "VOLUME",
-            "required": true
-        },
-        "DisplacementField": {
-            "display_name": "Displacement field",
-            "volume_type": "VOLUME",
-            "required": false
-        }
-    },
-    "inputs_evaluations": {
-        "Image": {
-            "Evaluation_with_images.yml": {
-                "FixedImage": {
-                    "display_name": "Fixed image",
-                    "volume_type": "VOLUME",
-                    "required": true
-                },
-                "MovingImage": {
-                    "display_name": "Moving image",
-                    "volume_type": "VOLUME",
-                    "required": true
-                },
-                "Mask": {
-                    "display_name": "Evaluation mask",
-                    "volume_type": "SEGMENTATION",
-                    "required": false
-                }
-            }
-        },
-        "Segmentation": {
-            "Evaluation_with_seg.yml": {
-                "FixedSeg": {
-                    "display_name": "Fixed segmentation",
-                    "volume_type": "SEGMENTATION",
-                    "required": true
-                },
-                "MovingSeg": {
-                    "display_name": "Moving segmentation",
-                    "volume_type": "SEGMENTATION",
-                    "required": true
-                }
-            }
-        },
-        "Landmarks": {
-            "Evaluation_with_fid.yml": {
-                "FixedFid": {
-                    "display_name": "Fixed landmarks",
-                    "volume_type": "FIDUCIALS",
-                    "required": true
-                },
-                "MovingFid": {
-                    "display_name": "Moving landmarks",
-                    "volume_type": "FIDUCIALS",
-                    "required": true
-                }
-            }
-        }
-    }
-}

CBCT_CT_TS/elastix_engine.py

@@ -1,386 +0,0 @@
-# Copyright (c) 2025 Valentin Boussot
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""Elastix-IMPACT runtime for the registration bundle.
-
-``ElastixEngine`` installs the elastix-IMPACT binary, downloads the TorchScript feature models, stages the
-parameter maps (generated from the model matrix or copied + overridden), runs the subprocess, and resamples.
-``ElastixRegistration`` is the graph module ``RegistrationNet`` wires — it bridges KonfAI tensors <-> SITK
-images. The config -> parameter-map MAPPING lives in ``Model.py`` and is imported here.
-"""
-
-import os
-import re
-import shutil
-import subprocess  # nosec B404
-import tempfile
-from pathlib import Path
-
-import numpy as np
-import SimpleITK as sitk
-import torch
-import tqdm
-from huggingface_hub import hf_hub_download
-from install import get_elastix_bin, install_elastix_impact, try_elastix
-from konfai.utils.dataset import Attribute, data_to_image, image_to_data
-
-from Model import _sorted_specs, generate_impact_parameter_map, load_models_registry
-
-# Elastix + IMPACT binary is cached once here (heavy: binary + LibTorch) and reused across runs.
-# Set KONFAI_ELASTIX_DIR to point at an existing install and skip the download.
-ELASTIX_CACHE = Path.home() / ".cache" / "konfai" / "elastix-impact"
-
-
-def _is_partial_mask(mask: "sitk.Image | None") -> bool:
-    """True only for a mask that actually restricts the metric region — some voxels in, some out. An
-    absent optional mask arrives as a whole-image (all-ones) default from KonfAI, and an all-zero mask
-    is degenerate; both are treated as no mask, so elastix runs without ``-fMask`` / ``-mMask`` (i.e.
-    the whole image) instead of paying for a mask that restricts nothing."""
-    if mask is None:
-        return False
-    arr = sitk.GetArrayViewFromImage(mask)
-    return bool((arr > 0).any()) and bool((arr == 0).any())
-
-
-class ElastixEngine:
-    """Run the elastix-IMPACT binary on a fixed/moving pair; return (moved, dvf) on the fixed grid.
-
-    NOTE: the elastix-IMPACT metric lives only in the custom ``elastix-impact`` binary (SimpleElastix does
-    NOT ship it), so registration is a subprocess call, not ``sitk.ElastixImageFilter``.
-    """
-
-    def __init__(
-        self,
-        parameter_maps: list[str],
-        max_iterations: int = 0,
-        final_grid_spacing: float = 0.0,
-        subset_features: int = 0,
-        spatial_samples: int = 0,
-        parameter_overrides: list[str] = [],
-        resolutions: dict = {},
-        mode: str = "Static",
-    ) -> None:
-        self._bundle_dir = Path(__file__).resolve().parent
-        self._parameter_maps = [self._bundle_dir / Path(p).name for p in parameter_maps]
-        self._max_iterations = max_iterations
-        self._final_grid_spacing = final_grid_spacing
-        self._subset_features = subset_features
-        self._spatial_samples = spatial_samples
-        self._parameter_overrides = list(parameter_overrides)
-        # ImpactMode: Static computes features once per level (PatchSize 0 0 0 = whole image); Jacobian
-        # samples random FOV-sized patches each iteration. One mode per preset.
-        self._mode = mode
-        # Matrix mode: with ``resolutions`` the map is GENERATED from it. Empty ``resolutions`` = an
-        # intensity preset (no IMPACT models): the fixed maps are staged with only the global overrides.
-        self._resolutions = resolutions
-        self._registry = load_models_registry() if resolutions else {}
-        # Feature models are DERIVED — the unique refs across the matrix cells (no flat ``models`` param).
-        models: list[str] = []
-        for res in _sorted_specs(resolutions):
-            for model in _sorted_specs(res.models):
-                if model.ref not in models:
-                    models.append(model.ref)
-        self._models = models
-        # ``iterations`` (the progress-bar total) is DERIVED: the sum of per-resolution iteration budgets.
-        self._iterations = self._total_iterations()
-        self._elastix_bin = self._ensure_binary()
-        self._local_models = self._download_models()
-
-    def _total_iterations(self) -> int:
-        """Total iterations across resolutions — the progress-bar budget, from the config (or the maps)."""
-        if self._resolutions:
-            return sum(int(res.max_iterations) for res in _sorted_specs(self._resolutions))
-        total = 0
-        for src in self._parameter_maps:
-            match = re.search(r"\(MaximumNumberOfIterations\s+([^)]*)\)", src.read_text(encoding="utf-8"))
-            if match:
-                total += sum(int(token) for token in match.group(1).split())
-        return total
-
-    def _ensure_binary(self) -> Path:
-        # Optional override: point at an existing elastix-IMPACT install (skips the download).
-        override = os.environ.get("KONFAI_ELASTIX_DIR", "")
-        if override:
-            try_elastix(Path(override))
-            return get_elastix_bin(Path(override)).resolve()
-        ELASTIX_CACHE.mkdir(parents=True, exist_ok=True)
-        try:
-            try_elastix(ELASTIX_CACHE)
-        except Exception:
-            install_elastix_impact(ELASTIX_CACHE, force_cuda=False, force_cpu=False)
-            try_elastix(ELASTIX_CACHE)
-        return get_elastix_bin(ELASTIX_CACHE).resolve()
-
-    def _download_models(self) -> list[tuple[str, Path]]:
-        """Fetch the TorchScript feature models (``repo:filename``); keep (relative_name, local_path)."""
-        models = []
-        for ref in self._models:
-            repo, filename = ref.split(":", 1)
-            local = Path(hf_hub_download(repo_id=repo, filename=filename, repo_type="model"))  # nosec B615
-            models.append((filename, local))
-        return models
-
-    def _parameter_map_overrides(self, global_only: bool = False) -> tuple[dict[str, str], list[tuple[str, str]]]:
-        """The tuned knobs as parameter-map overrides: ``(per_token, exact)``.
-
-        ``per_token`` maps an elastix key (or the ``ImpactSubsetFeatures`` prefix) to a value replacing
-        **each** existing token, preserving per-resolution / per-model multiplicity. ``exact`` entries (from
-        ``parameter_overrides``, ``Key=value text``) replace the whole value verbatim and win over the named
-        knobs. Overrides only REPLACE keys already present — never inject. ``global_only`` (matrix mode) drops
-        ``max_iterations`` / ``subset_features`` (the matrix already sets those per cell).
-        """
-        per_token: dict[str, str] = {}
-        if not global_only and self._max_iterations > 0:
-            per_token["MaximumNumberOfIterations"] = str(int(self._max_iterations))
-        if self._final_grid_spacing > 0:
-            per_token["FinalGridSpacingInPhysicalUnits"] = str(float(self._final_grid_spacing))
-        if not global_only and self._subset_features > 0:
-            per_token["ImpactSubsetFeatures"] = str(int(self._subset_features))  # prefix: indexed per metric
-        if self._spatial_samples > 0:
-            per_token["NumberOfSpatialSamples"] = str(int(self._spatial_samples))
-        exact: list[tuple[str, str]] = []
-        for entry in self._parameter_overrides:
-            key, sep, value = entry.partition("=")
-            if not sep or not key.strip():
-                raise ValueError(f"Invalid parameter_overrides entry '{entry}': expected 'Key=value text'.")
-            exact.append((key.strip(), value.strip()))
-        return per_token, exact
-
-    @staticmethod
-    def _apply_map_overrides(
-        text: str, per_token: dict[str, str], exact: list[tuple[str, str]], device_index: int
-    ) -> str:
-        """Patch a parameter map: set ImpactGPU to the device, apply exact key overrides, replace each token
-        of a per-token knob (preserving multiplicity), and warn for a requested key absent from the map.
-        """
-        entry_pattern = re.compile(r"^(\s*)\((\S+)((?:\s+[^)]*)?)\)\s*$")
-        requested = set(per_token) | {key for key, _ in exact}
-        seen: set[str] = set()
-        lines = []
-        for line in text.splitlines():
-            match = entry_pattern.match(line)
-            if match:
-                indent, key, values = match.group(1), match.group(2), match.group(3)
-                if key == "ImpactGPU":
-                    line = f"{indent}(ImpactGPU {device_index})"
-                else:
-                    exact_value = next((value for k, value in exact if k == key), None)
-                    if exact_value is not None:
-                        seen.add(key)
-                        line = f"{indent}({key} {exact_value})"
-                    else:
-                        token_key = "ImpactSubsetFeatures" if key.startswith("ImpactSubsetFeatures") else key
-                        if token_key in per_token:
-                            seen.add(token_key)
-                            replaced = " ".join(per_token[token_key] for _ in values.split())
-                            line = f"{indent}({key} {replaced})"
-            lines.append(line)
-        # Overrides never inject keys, so a knob set for a key absent from every map silently does nothing —
-        # surface it (e.g. final_grid_spacing on a rigid-only preset).
-        for key in sorted(requested - seen):
-            print(f"[ImpactReg] note: override '{key}' matched no entry in the preset's parameter maps.")
-        return "\n".join(lines)
-
-    def _stage_parameter_maps(self, work: Path, device_index: int) -> list[Path]:
-        """Stage the parameter maps into ``work``.
-
-        Matrix mode GENERATES each map from ``resolutions`` + the registry, then applies only the map-wide
-        knobs (the matrix already sets iterations/features per cell). Legacy mode copies the preset's maps and
-        applies every per-token / exact override. Both set the ImpactGPU device.
-        """
-        staged = []
-        for src in self._parameter_maps:
-            if self._resolutions:
-                text = generate_impact_parameter_map(
-                    src.read_text(encoding="utf-8"), self._resolutions, self._registry, self._mode
-                )
-                per_token, exact = self._parameter_map_overrides(global_only=True)
-            else:
-                text = src.read_text(encoding="utf-8")
-                per_token, exact = self._parameter_map_overrides()
-            text = self._apply_map_overrides(text, per_token, exact, device_index)
-            dst = work / src.name
-            dst.write_text(text if text.endswith("\n") else text + "\n", encoding="utf-8")
-            staged.append(dst)
-        return staged
-
-    def register(
-        self,
-        fixed: sitk.Image,
-        moving: sitk.Image,
-        device_index: int,
-        fixed_mask: sitk.Image | None = None,
-        moving_mask: sitk.Image | None = None,
-    ) -> tuple[np.ndarray, np.ndarray]:
-        """Register ``moving`` onto ``fixed``; return (moved, dvf) as channel-first arrays on the fixed grid.
-
-        Optional ``fixed_mask`` / ``moving_mask`` restrict the similarity metric to a region (elastix
-        ``-fMask`` / ``-mMask``); a mask covering the whole image is equivalent to passing none.
-        """
-        work = Path(tempfile.mkdtemp(prefix="konfai_reg_"))
-        try:
-            fixed_path, moving_path = work / "Fixed.mha", work / "Moving.mha"
-            sitk.WriteImage(fixed, str(fixed_path))
-            sitk.WriteImage(moving, str(moving_path))
-
-            # Stage the feature models at the relative path the maps reference (e.g. ImpactModelsPath0
-            # "MIND/R1D2_3D.pt"), resolved from the elastix working directory.
-            for rel_name, model_path in self._local_models:
-                dst = work / rel_name
-                dst.parent.mkdir(parents=True, exist_ok=True)
-                if not dst.exists():
-                    dst.symlink_to(model_path)
-
-            args = [str(self._elastix_bin), "-f", str(fixed_path), "-m", str(moving_path)]
-            for flag, mask, name in (("-fMask", fixed_mask, "FixedMask.mha"), ("-mMask", moving_mask, "MovingMask.mha")):
-                if _is_partial_mask(mask):
-                    mask_path = work / name
-                    sitk.WriteImage(sitk.Cast(mask, sitk.sitkUInt8), str(mask_path))
-                    args += [flag, str(mask_path)]
-            args += ["-out", str(work)]
-            for pmap in self._stage_parameter_maps(work, device_index):
-                args += ["-p", str(pmap)]
-
-            # Make the elastix binary's bundled libs (libtorch under <install>/lib) and any extra
-            # libtorch/CUDA dirs (KONFAI_ELASTIX_EXTRA_LIB) findable so the IMPACT metric plugin loads.
-            env = os.environ.copy()
-            extra_libs = [str(self._elastix_bin.parent.parent / "lib"), os.environ.get("KONFAI_ELASTIX_EXTRA_LIB", "")]
-            env["LD_LIBRARY_PATH"] = os.pathsep.join(p for p in [*extra_libs, env.get("LD_LIBRARY_PATH", "")] if p)
-            proc = subprocess.Popen(  # nosec B603
-                args,
-                cwd=str(work),
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                text=True,
-                bufsize=1,
-                env=env,
-            )
-            # Drive a tqdm bar over elastix's iteration lines so SlicerKonfAI (which parses the "N% done"
-            # progress line) shows real progress. A tuned max_iterations makes the declared budget stale ->
-            # open-ended bar. The description mirrors KonfAI's bars: resolution level + the metric value.
-            captured: list[str] = []
-            iteration_line = re.compile(r"^\d+\s")
-            budget = None if self._max_iterations > 0 else (self._iterations or None)
-            progress = tqdm.tqdm(total=budget, desc="Registration", ncols=0, leave=True)
-            assert proc.stdout is not None
-            resolution = 0
-            for line in proc.stdout:
-                captured.append(line)
-                stripped = line.strip()
-                if stripped.startswith("Resolution:"):
-                    try:
-                        resolution = int(stripped.split(":", 1)[1])
-                    except ValueError:
-                        pass
-                elif iteration_line.match(line):
-                    progress.update(1)
-                    columns = line.split()  # column 2 is the metric (header "1:ItNr 2:Metric ...")
-                    if len(columns) > 1:
-                        try:
-                            progress.set_description(
-                                f"Registration : res {resolution} | metric {float(columns[1]):.4f}"
-                            )
-                        except ValueError:
-                            pass
-            progress.close()
-            returncode = proc.wait()
-            if returncode != 0:
-                raise RuntimeError(f"elastix failed (code {returncode}):\n{''.join(captured[-40:])}")
-
-            transforms = sorted(
-                work.glob("TransformParameters.*-Composite.itk.txt"),
-                key=lambda p: int(p.name.split(".")[1].split("-")[0]),
-            )
-            if not transforms:
-                raise FileNotFoundError("elastix produced no composite transform file.")
-            transform = sitk.ReadTransform(str(transforms[-1]))
-
-            moved = sitk.Resample(moving, fixed, transform, sitk.sitkLinear, 0.0, moving.GetPixelID())
-            dvf = sitk.TransformToDisplacementField(
-                transform,
-                sitk.sitkVectorFloat64,
-                fixed.GetSize(),
-                fixed.GetOrigin(),
-                fixed.GetSpacing(),
-                fixed.GetDirection(),
-            )
-            moved_np, _ = image_to_data(moved)
-            dvf_np, _ = image_to_data(dvf)
-            return moved_np, dvf_np
-        finally:
-            shutil.rmtree(work, ignore_errors=True)
-
-
-class ElastixRegistration(torch.nn.Module):
-    """Custom graph module: (fixed, moving) tensors + their geometry -> moved image on the fixed grid.
-
-    ``accepts_attributes = True`` opts this module into receiving, from the KonfAI graph, the per-branch
-    ``Attribute`` list alongside the tensors (same convention as ``CriterionWithAttribute``). elastix needs
-    the physical geometry (Origin/Spacing/Direction), which raw tensors do not carry.
-    """
-
-    accepts_attributes = True
-
-    def __init__(
-        self,
-        engine: str,
-        parameter_maps: list[str],
-        max_iterations: int = 0,
-        final_grid_spacing: float = 0.0,
-        subset_features: int = 0,
-        spatial_samples: int = 0,
-        parameter_overrides: list[str] = [],
-        resolutions: dict = {},
-        mode: str = "Static",
-    ) -> None:
-        super().__init__()
-        if engine != "elastix":
-            raise NotImplementedError(f"ElastixRegistration engine '{engine}' is not implemented yet.")
-        self._engine = ElastixEngine(
-            parameter_maps,
-            max_iterations,
-            final_grid_spacing,
-            subset_features,
-            spatial_samples,
-            parameter_overrides,
-            resolutions,
-            mode,
-        )
-
-    def forward(
-        self,
-        fixed: torch.Tensor,
-        moving: torch.Tensor,
-        fixed_mask: torch.Tensor,
-        moving_mask: torch.Tensor,
-        attributes: list[list[Attribute]],
-    ) -> torch.Tensor:
-        # attributes = [fixed, moving, fixed_mask, moving_mask] branch attrs; each a list[Attribute] over the
-        # batch. Returns, per sample, the moved image (1 channel) stacked with the DVF (dim channels), both on
-        # the fixed grid; downstream ChannelSelect splits them. A whole-image mask (the default) restricts nothing.
-        fixed_attrs, moving_attrs, fmask_attrs, mmask_attrs = attributes
-        device_index = fixed.device.index if fixed.device.type == "cuda" else -1
-        combined = []
-        for b in range(fixed.shape[0]):
-            fixed_img = data_to_image(fixed[b].detach().cpu().numpy(), fixed_attrs[b])
-            moving_img = data_to_image(moving[b].detach().cpu().numpy(), moving_attrs[b])
-            fixed_mask_img = data_to_image(fixed_mask[b].detach().cpu().numpy(), fmask_attrs[b])
-            moving_mask_img = data_to_image(moving_mask[b].detach().cpu().numpy(), mmask_attrs[b])
-            moved_np, dvf_np = self._engine.register(
-                fixed_img, moving_img, device_index, fixed_mask_img, moving_mask_img
-            )
-            combined.append(torch.from_numpy(np.concatenate([moved_np, dvf_np], axis=0)))
-        return torch.stack(combined, dim=0).to(fixed.device)

CBCT_CT_TS/install.py

@@ -1,325 +0,0 @@
-# Copyright (c) 2025 Valentin Boussot
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import argparse
-import platform
-import re
-import shutil
-import stat
-import subprocess  # nosec B404
-import zipfile
-from pathlib import Path
-
-import requests
-from tqdm import tqdm
-
-# -----------------------------------------------------------------------------
-# Elastix + IMPACT binary assets hosted on GitHub Releases.
-#
-# Key format: (OS, ARCH, FLAVOR)
-#   - OS     : platform.system() -> "Linux", "Windows", "Darwin"
-#   - ARCH   : normalized architecture -> "x86_64"
-#   - FLAVOR : "cpu" or "cu128"
-#
-# CPU assets are standalone (LibTorch CPU bundled).
-# CUDA assets do NOT bundle LibTorch (too large for GitHub limits).
-# -----------------------------------------------------------------------------
-ELX_ASSET_TEMPLATE = {
-    ("Linux", "x86_64", "cpu"): "elastix-impact-linux-x86_64-cpu.zip",
-    ("Linux", "x86_64", "cu128"): "elastix-impact-linux-x86_64-cu128.zip",
-    ("Windows", "x86_64", "cpu"): "elastix-impact-windows-x86_64-cpu.zip",
-    ("Windows", "x86_64", "cu128"): "elastix-impact-windows-x86_64-cu128.zip",
-    ("Darwin", "x86_64", "cpu"): "elastix-impact-macos-14-x86_64-cpu.zip",
-}
-
-# -----------------------------------------------------------------------------
-# Official LibTorch downloads (PyTorch).
-#
-# IMPORTANT:
-# - Version MUST match the one used at build time (ABI compatibility).
-# - Using "shared-with-deps" ensures CUDA runtime libraries are included
-#   (except the NVIDIA driver, which must be installed system-wide).
-# -----------------------------------------------------------------------------
-
-LIBTORCH_URL = {
-    (
-        "Linux",
-        "x86_64",
-        "cpu",
-    ): "https://download.pytorch.org/libtorch/cpu/libtorch-shared-with-deps-2.8.0%2Bcpu.zip",
-    (
-        "Windows",
-        "x86_64",
-        "cpu",
-    ): "https://download.pytorch.org/libtorch/cpu/libtorch-win-shared-with-deps-2.8.0%2Bcpu.zip",
-    (
-        "Darwin",
-        "arm64",
-        "cpu",
-    ): "https://download.pytorch.org/libtorch/cpu/libtorch-win-shared-with-deps-2.8.0%2Bcpu.zip",
-    (
-        "Linux",
-        "x86_64",
-        "cu128",
-    ): "https://download.pytorch.org/libtorch/cu128/libtorch-shared-with-deps-2.8.0%2Bcu128.zip",
-    (
-        "Windows",
-        "x86_64",
-        "cu128",
-    ): "https://download.pytorch.org/libtorch/cu128/libtorch-win-shared-with-deps-2.8.0%2Bcu128.zip",
-}
-
-# -----------------------------------------------------------------------------
-# Minimum NVIDIA driver versions required for CUDA 12.8.
-#
-# The CUDA Toolkit itself is NOT required.
-# Only a sufficiently recent NVIDIA driver must be installed.
-# -----------------------------------------------------------------------------
-CUDA128_MIN_DRIVER_LINUX = (570, 26)
-CUDA128_MIN_DRIVER_WINDOWS = (570, 65)
-
-GITHUB_OWNER = "vboussot"
-GITHUB_REPO = "ImpactElastix"
-GITHUB_TAG = "1.0.0"
-
-
-DEFAULT_PREFIX = Path.cwd() / "elastix-impact"
-
-
-def run_cmd(cmd: list[str]) -> str:
-    return subprocess.check_output(cmd, stderr=subprocess.STDOUT).decode("utf-8", errors="replace")  # nosec B603
-
-
-def detect_nvidia_driver() -> tuple[bool, tuple[int, int] | None]:
-    """
-    Detect presence of an NVIDIA GPU and extract the driver version.
-    Returns:
-        (True, (major, minor)) if detected
-        (False, None) if nvidia-smi is not available
-    """
-    try:
-        nvidia_smi = shutil.which("nvidia-smi")
-        if nvidia_smi is None:
-            raise RuntimeError("nvidia-smi not found in PATH")
-
-        out = (
-            subprocess.check_output(
-                [nvidia_smi, "--query-gpu=driver_version", "--format=csv,noheader"], stderr=subprocess.DEVNULL
-            )  # nosec B603
-            .decode("utf-8")
-            .strip()
-        )
-    except Exception:
-        return (False, None)
-
-    # Exemple: "575.64"
-    m = re.match(r"([0-9]+)\.([0-9]+)", out)
-    if not m:
-        return (True, None)
-
-    return (True, (int(m.group(1)), int(m.group(2))))
-
-
-def driver_ok_for_cuda(os_name: str, drv: tuple[int, int] | None) -> bool:
-    """
-    Check whether the detected NVIDIA driver satisfies the minimum
-    requirement for CUDA 12.8 on the given operating system.
-    """
-    if drv is None:
-        return False
-    if os_name == "Linux":
-        return drv >= CUDA128_MIN_DRIVER_LINUX
-    if os_name == "Windows":
-        return drv >= CUDA128_MIN_DRIVER_WINDOWS
-    return False
-
-
-def normalize_arch(machine: str) -> str:
-    """
-    Normalize platform.machine() output across operating systems.
-
-    Examples:
-        AMD64   -> x86_64
-        aarch64 -> arm64
-    """
-    m = machine.lower()
-    if m in ("x86_64", "amd64"):
-        return "x86_64"
-    if m in ("aarch64", "arm64"):
-        return "arm64"
-    return machine
-
-
-def download_file(url: str, dst: Path) -> None:
-    """
-    Download a file from the given URL with a progress indicator.
-    """
-    dst.parent.mkdir(parents=True, exist_ok=True)
-    print(f"Downloading: {url}", flush=True)
-    print(f"       to: {dst}", flush=True)
-
-    try:
-        with requests.get(url, stream=True, timeout=60) as r:
-            r.raise_for_status()
-            total = int(r.headers.get("content-length", 0))
-            with open(dst, "wb") as f:
-                with tqdm(
-                    total=total,
-                    unit="B",
-                    unit_scale=True,
-                    desc=f"Downloading {dst.name}",
-                ) as pbar:
-                    for chunk in r.iter_content(chunk_size=8192):
-                        f.write(chunk)
-                        pbar.update(len(chunk))
-    except Exception as e:
-        raise e
-
-
-def extract_archive(archive: Path, dst_dir: Path) -> None:
-    """
-    Extract a ZIP archive to the destination directory.
-    """
-    dst_dir.mkdir(parents=True, exist_ok=True)
-    print(f"Extracting: {archive} -> {dst_dir}", flush=True)
-    with zipfile.ZipFile(archive, "r") as z:
-        z.extractall(dst_dir)
-    archive.unlink()
-
-
-def install_elastix_impact(install_path: Path, force_cuda: bool, force_cpu: bool):
-    os_name = platform.system()
-    arch = normalize_arch(platform.machine())
-    has_nvidia, drv = detect_nvidia_driver()
-
-    if os_name not in ("Linux", "Windows", "Darwin"):
-        raise NameError(f"Unsupported OS: {os_name}")
-
-    if arch not in ("x86_64", "arm64"):
-        raise NameError(f"Unsupported arch: {arch} (expected x86_64, arm64)")
-
-    flavor = "cpu"
-    if force_cuda:
-        if not has_nvidia or not driver_ok_for_cuda(os_name, drv):
-            raise NameError(
-                "CUDA forced but NVIDIA driver/GPU not suitable. Detected: has_nvidia={has_nvidia}, driver={drv}"
-            )
-
-        flavor = "cu128"
-    elif not force_cpu:
-        if has_nvidia and driver_ok_for_cuda(os_name, drv):
-            flavor = "cu128"
-        else:
-            flavor = "cpu"
-
-    print(f"System: {os_name} {arch}", flush=True)
-    print(f"NVIDIA: {has_nvidia}, driver={drv}", flush=True)
-    print(f"Selected flavor: {flavor}", flush=True)
-
-    key = (os_name, arch, flavor)
-    if key not in ELX_ASSET_TEMPLATE:
-        raise NameError(f"No elastix asset configured for {key}")
-    if flavor != "cpu" and key not in LIBTORCH_URL:
-        raise NameError(f"No libtorch url configured for {key}")
-
-    install_path = install_path.resolve()
-    install_path.mkdir(parents=True, exist_ok=True)
-
-    elx_asset = ELX_ASSET_TEMPLATE[key]
-    elx_url = f"https://github.com/{GITHUB_OWNER}/{GITHUB_REPO}/releases/download/{GITHUB_TAG}/{elx_asset}"
-    elx_archive = install_path / elx_asset
-    download_file(elx_url, elx_archive)
-    extract_archive(elx_archive, install_path)
-
-    # -------------------------------------------------------------------------
-    # ZIP archives may drop executable permissions.
-    # Ensure elastix and transformix are executable on Unix platforms.
-    # -------------------------------------------------------------------------
-    if os_name in ("Linux", "Darwin"):
-        for exe in ("elastix", "transformix"):
-            p = install_path / "bin" / exe
-            if p.exists():
-                p.chmod(p.stat().st_mode | stat.S_IEXEC)
-
-    # ---------------------------------------------------------------------
-    # - Download matching LibTorch 12.8 with or without CUDA 12.8
-    # - Extract it
-    # - Move runtime libraries to a location visible to the dynamic loader
-    #
-    # Linux / macOS : prefix/lib
-    # Windows       : prefix (next to elastix.exe)
-    # ---------------------------------------------------------------------
-    lt_url = LIBTORCH_URL[key]
-    lt_archive = install_path / Path(lt_url).name
-    download_file(lt_url, lt_archive)
-    extract_archive(lt_archive, install_path)
-    for p in (install_path / "libtorch" / "lib").iterdir():
-        if ".so" in p.name or ".dll" in p.name or ".dylib" in p.name:
-            shutil.move(p, (install_path if os_name == "Windows" else install_path / "lib") / p.name)
-
-    shutil.rmtree(install_path / "libtorch")
-    if os_name == "Linux" and flavor == "cu128":
-        shutil.copy(install_path / "lib" / "libcudart-c3a75b33.so.12", install_path / "lib" / "libcudart.so.12")
-
-
-def get_elastix_bin(install_path: Path) -> Path:
-    return install_path / ("elastix.exe" if platform.system() == "Windows" else (Path("bin") / "elastix"))
-
-
-def try_elastix(install_path: Path) -> None:
-    try:
-        subprocess.run(
-            [str(get_elastix_bin(install_path)), "-h"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )  # nosec B603
-    except subprocess.CalledProcessError as e:
-        msg = "Elastix execution failed.\n\n"
-
-        msg += f"Command:\n{' '.join(e.cmd)}\n"
-        msg += f"Return code: {e.returncode}\n\n"
-
-        if e.stderr:
-            msg += "Error output:\n"
-            msg += e.stderr.strip()
-        raise NameError(msg)
-
-    except OSError as e:
-        msg = (
-            "Elastix could not be started.\n\n"
-            "This is usually caused by missing shared libraries "
-            "(e.g. LibTorch or CUDA runtime).\n\n"
-            f"System error:\n{str(e)}"
-        )
-
-        raise NameError(msg)
-
-
-def main() -> None:
-    ap = argparse.ArgumentParser()
-    ap.add_argument(
-        "--install-path", type=Path, default=DEFAULT_PREFIX, help="Install directory (default: ./elastix-impact)"
-    )
-    group = ap.add_mutually_exclusive_group()
-    group.add_argument("--force-cpu", action="store_true", help="Force CPU install even if NVIDIA present")
-    group.add_argument("--force-cuda", action="store_true", help="Force CUDA install (fails if no suitable driver)")
-    args = vars(ap.parse_args())
-    install_elastix_impact(**args)
-
-
-if __name__ == "__main__":
-    main()

CBCT_CT_TS/model.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:de99fbc36331ce674639acc774f52b4a2d0027f2f312d9d28669e831a0c4fd7e
-size 1249

README.md

@@ -35,7 +35,6 @@ resampled onto the fixed image (**`MovedImage`**) and the **`DisplacementField`*
 | `MR_CT_TS` | MR/CT | elastix + IMPACT | MR/CT with MIND + TotalSegmentator features |
 | `MR_CT_MRSeg` | MR/CT | elastix + IMPACT | MR/CT with MIND + MRSegmentator features |
 | `CBCT_CT_HeadNeck` | CBCT/CT | elastix + IMPACT | CBCT/CT head & neck preset |
-| `CBCT_CT_TS` | CBCT/CT | elastix + IMPACT | CBCT/CT with TotalSegmentator features |
 | `CBCT_CT_MRSeg` | CBCT/CT | elastix + IMPACT | CBCT/CT with MRSegmentator features |
 | `ConvexAdam_Coarse` | any | itk-impact (native) | Global coarse coupled-convex init (IMPACT/MIND) |
 | `ConvexAdam_Fine` | any | itk-impact (native) | Adam instance-optimisation (tileable; expects a pre-aligned start) |