id-uptake-values 0.1.0__tar.gz

id_uptake_values-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.3
+Name: id-uptake-values
+Version: 0.1.0
+Summary: Add your description here
+Author: Christian Hinge
+Author-email: Christian Hinge <christian.hinge@regionh.dk>
+Requires-Dist: argparse>=1.4.0
+Requires-Dist: matplotlib>=3.11.2
+Requires-Dist: nibabel>=5.4.2
+Requires-Dist: scipy>=1.18.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# ID-uptake-values
+
+Estimate SUV (body-mass normalised) and SUL (lean-body-mass normalised) PET images **without** DICOM metadata such as injected dose or patient weight. Total activity and body mass / lean body mass are inferred from the images themselves, using TotalSegmentator masks and a k-nearest-neighbour model over axial distribution functions.
+
+## Installation
+
+```
+pip install .        # or: uv sync
+```
+
+The model weights are bundled with the package.
+
+## Usage
+
+Inputs are NIfTI files: PET, CT, and TotalSegmentator segmentations (`total`, `body`, and for SUL also `tissue`).
+
+```
+# SUV
+python -m id_uptake_values.suv --pet pet.nii.gz --ct ct.nii.gz \
+    --totalseg total.nii.gz --bodyseg body.nii.gz \
+    --output-image suv.nii.gz --output-json suv.json
+
+# SUL (optionally with a debug plot of the alignment and nearest-neighbour fit)
+python -m id_uptake_values.sul --pet pet.nii.gz --ct ct.nii.gz \
+    --totalseg total.nii.gz --tissueseg tissue.nii.gz --bodyseg body.nii.gz \
+    --output-image sul.nii.gz --output-json sul.json --debug-image debug.png
+```
+
+The JSON contains the estimated activity (MBq), the estimated body mass or lean body mass (kg), and the denominator the PET image was divided by.
+
+The scan must cover the region from C1 to the sacrum; otherwise a `ValueError` is raised.
+
+## Development
+
+```
+uv sync
+uv run pytest
+```
+
+The tests download subject `sub-000` from the [DEPICT-RH/Multimodal-HC](https://huggingface.co/datasets/DEPICT-RH/Multimodal-HC) dataset into the Hugging Face cache.

id_uptake_values-0.1.0/README.md

@@ -0,0 +1,40 @@
+# ID-uptake-values
+
+Estimate SUV (body-mass normalised) and SUL (lean-body-mass normalised) PET images **without** DICOM metadata such as injected dose or patient weight. Total activity and body mass / lean body mass are inferred from the images themselves, using TotalSegmentator masks and a k-nearest-neighbour model over axial distribution functions.
+
+## Installation
+
+```
+pip install .        # or: uv sync
+```
+
+The model weights are bundled with the package.
+
+## Usage
+
+Inputs are NIfTI files: PET, CT, and TotalSegmentator segmentations (`total`, `body`, and for SUL also `tissue`).
+
+```
+# SUV
+python -m id_uptake_values.suv --pet pet.nii.gz --ct ct.nii.gz \
+    --totalseg total.nii.gz --bodyseg body.nii.gz \
+    --output-image suv.nii.gz --output-json suv.json
+
+# SUL (optionally with a debug plot of the alignment and nearest-neighbour fit)
+python -m id_uptake_values.sul --pet pet.nii.gz --ct ct.nii.gz \
+    --totalseg total.nii.gz --tissueseg tissue.nii.gz --bodyseg body.nii.gz \
+    --output-image sul.nii.gz --output-json sul.json --debug-image debug.png
+```
+
+The JSON contains the estimated activity (MBq), the estimated body mass or lean body mass (kg), and the denominator the PET image was divided by.
+
+The scan must cover the region from C1 to the sacrum; otherwise a `ValueError` is raised.
+
+## Development
+
+```
+uv sync
+uv run pytest
+```
+
+The tests download subject `sub-000` from the [DEPICT-RH/Multimodal-HC](https://huggingface.co/datasets/DEPICT-RH/Multimodal-HC) dataset into the Hugging Face cache.

id_uptake_values-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "ID-uptake-values"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "Christian Hinge", email = "christian.hinge@regionh.dk" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "argparse>=1.4.0",
+    "matplotlib>=3.11.2",
+    "nibabel>=5.4.2",
+    "scipy>=1.18.1",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.16,<0.9.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = ["pytest>=8", "huggingface-hub>=0.25"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

id_uptake_values-0.1.0/src/id_uptake_values/adf.py

@@ -0,0 +1,69 @@
+#%%
+import numpy as np 
+import nibabel as nib
+from pathlib import Path
+import os 
+from scipy.ndimage import binary_fill_holes
+from nibabel.processing import resample_from_to
+
+def axial_distribution(img):
+    img = nib.funcs.as_closest_canonical(img)
+    img_y = img.get_fdata().sum(axis=(0,1)) * np.prod(img.header.get_zooms()[:2]) / 1000
+    nz = img.shape[-1]
+    img_x = img.affine @ np.array([np.zeros(nz),np.zeros(nz),np.arange(nz),np.ones(nz)])
+    img_x = img_x[-2,:]
+    return img_x, img_y
+
+def axial_distribution_mask(img, num_classes=13):
+    dataobj = np.asanyarray(img.dataobj)
+    nz = img.shape[-1]
+    img_y = np.zeros((nz,num_classes))
+    for ix in range(1,num_classes+1):
+        img_y[:,ix-1] = (dataobj==ix).sum(axis=(0,1))
+    img_x = img.affine @ np.array([np.zeros(nz),np.zeros(nz),np.arange(nz),np.ones(nz)])
+    img_x = img_x[-2,:]
+    img_y*= np.prod(img.header.get_zooms()[:2]) / 1000
+    return img_x, img_y
+
+def get_ct_cylindrical_mask(ct_image):
+    mask = ct_image.get_fdata() > -1023.5
+    mask = mask.any(axis=2,keepdims=True)
+    mask = binary_fill_holes(mask)
+    mask = np.repeat(mask,ct_image.shape[2],axis=2)
+    return nib.Nifti1Image(mask.astype("uint8"),affine=ct_image.affine)
+
+def crop_pet_activity_to_ct_axial_fov(pet_img,ct_image):
+    mask = get_ct_cylindrical_mask(ct_image)
+    mask = resample_from_to(mask,pet_img,order=0)
+    pet_arr = pet_img.get_fdata().copy()
+    pet_arr[mask.get_fdata()==0] = 0
+    return nib.Nifti1Image(pet_arr,pet_img.affine)
+    
+def make_distribution_functions(pet_img, ts_total_img, ts_body_img, ts_tissue_img,ct_img, out_directory=None):
+    if out_directory is not None:
+        os.makedirs(out_directory,exist_ok=True)
+    if not isinstance(out_directory,Path) and out_directory is not None:
+        out_directory = Path(out_directory)
+    data = {}
+
+    x,y = axial_distribution_mask(ts_total_img,num_classes=117)
+    data["ts_total_x"] = x
+    data["ts_total_y"] = y
+
+    pet_img = crop_pet_activity_to_ct_axial_fov(pet_img,ct_img)
+    x,y = axial_distribution(pet_img)
+    data["pet_x"] = x
+    data["pet_y"] = y
+
+    x,y = axial_distribution_mask(ts_body_img,num_classes=2)
+    data["ts_body_x"] = x
+    data["ts_body_y"] = y
+
+    if ts_tissue_img is not None:
+        x,y = axial_distribution_mask(ts_tissue_img,num_classes=3)
+        data["ts_tissues_x"] = x
+        data["ts_tissues_y"] = y
+
+    
+    return data 
+

id_uptake_values-0.1.0/src/id_uptake_values/debug_plots.py

@@ -0,0 +1,121 @@
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import nibabel as nib
+import numpy as np
+from nibabel.processing import resample_from_to
+
+from .adf import make_distribution_functions, get_ct_cylindrical_mask
+from .resampling import C1toSacrumResampler
+from .models import KNNLeanBodyMass, KNNActivity
+
+
+def _z_normalized(img, head, hip):
+    k = np.arange(img.shape[2])
+    z_mm = (img.affine @ np.stack([np.zeros_like(k), np.zeros_like(k), k, np.ones_like(k)]))[2]
+    return (z_mm - head) / (head - hip)
+
+
+def _overlay(mask, color=(1, 0, 0, 0.45)):
+    out = np.zeros(mask.shape + (4,))
+    out[mask] = color
+    return out
+
+
+def _band(img_canon, mip, head, hip, cmap, vmin, vmax, label):
+    zoom = img_canon.header.get_zooms()[:3]
+    return {
+        "mip": mip,
+        "zn": _z_normalized(img_canon, head, hip),
+        "span": abs(_z_normalized(img_canon, head, hip)[-1] - _z_normalized(img_canon, head, hip)[0]),
+        "t_over_z": (img_canon.shape[0] * zoom[0]) / (img_canon.shape[2] * zoom[2]),
+        "cmap": cmap,
+        "vmin": vmin,
+        "vmax": vmax,
+        "label": label,
+    }
+
+
+def _draw_adf(ax, model, adfs, band, name, prefix, greek, scale, unit):
+    x, yr, resmask = model._resample(adfs)
+    distance = model._distance(yr, resmask)
+    ixs = np.argsort(distance)[:model.n_neighbors]
+    nn_mean = model._nn_estimate(distance)
+    fov_fraction = nn_mean[resmask].sum()
+    fov_sum = model.fov_sum(adfs)
+    total = fov_sum / fov_fraction
+    scaled_patient = yr / yr.sum() * fov_fraction
+    neighbors = model.X[ixs]
+    ymax = max(neighbors.max(), scaled_patient.max())
+
+    for neighbor in neighbors:
+        ax.plot(x, neighbor, color="0.5", linewidth=0.6, alpha=0.5)
+    ax.plot([], [], color="0.5", linewidth=0.6, label=f"K={model.n_neighbors} nearest neighbors")
+    ax.plot(x, nn_mean, color="k", linewidth=2, label="Nearest neighbors mean")
+    ax.plot(x, scaled_patient, color="r", linewidth=2, label="Patient scaled to nn-mean")
+    ax.fill_between(x, 0, scaled_patient, where=resmask, color="r", alpha=0.2)
+    for pos, color, label in ((0, "tab:blue", "C1 (z = 0)"), (-1, "tab:green", "Sacrum (z = -1)")):
+        ix = np.argmin(np.abs(x - pos))
+        ax.axvline(pos, color=color, linewidth=0.8, zorder=4)
+        ax.scatter([x[ix]], [scaled_patient[ix]], color=color, edgecolor="k", s=70, zorder=5, label=label)
+    ax.axvline(x[resmask].min(), color="k", linestyle="--", alpha=0.5)
+    ax.axvline(x[resmask].max(), color="k", linestyle="--", alpha=0.5)
+
+    window = ax.get_window_extent()
+    xrange_ = 0.75 - (-3)
+    frac = band["span"] / xrange_ * (window.width / window.height) * band["t_over_z"]
+    ytop = ymax / (1 - frac - 0.02)
+    height = frac * ytop
+    bottom = ytop - height
+    ax.imshow(band["mip"], origin="lower", cmap=band["cmap"], vmin=band["vmin"], vmax=band["vmax"],
+              aspect="auto", extent=[band["zn"][0], band["zn"][-1], bottom, bottom + height], zorder=3)
+    if band["label"]:
+        ax.text(max(band["zn"][0], -3), bottom + height + 0.01 * ytop, band["label"], fontsize=9, va="bottom")
+
+    ax.set_xlim(-3, 0.75)
+    ax.set_ylim(0, ytop)
+    ax.set_title(f"{name}\n{prefix}_total = {total / scale:.1f} {unit}, FOV fraction {greek} = {fov_fraction * 100:.1f}%")
+    ax.set_xlabel("Normalized axial position (z)")
+    ax.set_ylabel("Volume distribution density")
+    ax.legend(loc="lower left", bbox_to_anchor=(0.01, 0.3), fontsize=8)
+    return total, fov_sum, fov_fraction
+
+
+def create_debug_image(pet_img, ct_img, ts_total_img, ts_tissue_img, ts_body_img, out_path, model_dir):
+    adfs = make_distribution_functions(pet_img, ts_total_img, ts_body_img, ts_tissue_img, ct_img)
+    model_dose = KNNActivity(n_neighbors=40)
+    model_dose.load_weights(Path(model_dir) / "activity")
+    model_volume = KNNLeanBodyMass(n_neighbors=40)
+    model_volume.load_weights(Path(model_dir) / "lbm")
+    sul_denominator = model_dose.predict(adfs) / model_volume.predict(adfs)
+
+    resampler = C1toSacrumResampler(adfs["ts_total_x"], adfs["ts_total_y"])
+    head, hip = resampler.head_offset, resampler.hip_offset
+
+    sul_canon = nib.funcs.as_closest_canonical(nib.Nifti1Image(pet_img.get_fdata() / sul_denominator, affine=pet_img.affine))
+    ct_canon = nib.funcs.as_closest_canonical(ct_img)
+    crop_mask = resample_from_to(get_ct_cylindrical_mask(ct_img), pet_img, order=0)
+    crop_arr = nib.funcs.as_closest_canonical(crop_mask).get_fdata()
+    sul_arr = sul_canon.get_fdata()
+
+    pet_band = _band(sul_canon, sul_arr.max(axis=1), head, hip, "gray_r", 0, 5, "")
+    ct_mip = np.clip(ct_canon.get_fdata(), -200, 250).mean(axis=1)
+    ct_band = _band(ct_canon, ct_mip, head, hip, "gray_r", ct_mip.min(), np.percentile(ct_mip, 99.9), "")
+
+    fig, (ax_td, ax_dose, ax_lbm) = plt.subplots(1, 3, figsize=(21, 7.5))
+
+    ax_td.imshow(sul_arr.max(axis=2).T, origin="lower", cmap="gray_r", vmin=0, vmax=5, aspect="equal")
+    ax_td.imshow(_overlay((crop_arr.max(axis=2) == 0).T, color=(1, 0, 0, 0.2)), origin="lower", aspect="equal")
+    ax_td.set_title("Top-down projection (SUL MIP) with cropping mask\nred = cropped by CT cylindrical mask")
+    ax_td.set_xlabel("Transaxial voxel (x)")
+    ax_td.set_ylabel("Transaxial voxel (y, posterior to anterior)")
+
+    _draw_adf(ax_dose, model_dose, adfs, pet_band, "Dose ADF (PET)",
+              prefix="A", greek="\u03b1", scale=1e6, unit="MBq")
+    _draw_adf(ax_lbm, model_volume, adfs, ct_band, "Lean body mass ADF (CT)",
+              prefix="LBM", greek="\u03b2", scale=1e3, unit="kg")
+
+    out_path = Path(out_path)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(out_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)

id_uptake_values-0.1.0/src/id_uptake_values/estimation.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+
+import nibabel as nib
+
+from .adf import make_distribution_functions
+from .models import KNNActivity
+
+knn_model = Path(__file__).parent / "weights/knn-melanoma-fdg"
+
+
+def estimate_dose_and_volume(pet_img, ct_img, ts_total_img, ts_tissue_img, ts_body_img, volume_model, volume_dir):
+    adfs = make_distribution_functions(pet_img, ts_total_img, ts_body_img, ts_tissue_img, ct_img)
+    model_dose = KNNActivity(n_neighbors=40)
+    model_dose.load_weights(knn_model / "activity")
+    model_volume = volume_model(n_neighbors=40)
+    model_volume.load_weights(volume_dir)
+    return model_dose.predict(adfs), model_volume.predict(adfs)
+
+
+def build_outputs(pet_img, total_dose, total_volume, quantity, volume_key):
+    denominator = total_dose / total_volume
+    constants = {
+        f"estimated_{quantity}_denominator": float(denominator),
+        "estimated_activity_MBq": float(total_dose) / 1e6,
+        volume_key: float(total_volume) / 1e3,
+    }
+    img = nib.Nifti1Image(pet_img.get_fdata() / denominator, affine=pet_img.affine)
+    return img, constants

id_uptake_values-0.1.0/src/id_uptake_values/models.py

@@ -0,0 +1,72 @@
+from pathlib import Path
+
+import numpy as np
+
+from .resampling import C1toSacrumResampler
+
+
+class KNNModel:
+    def __init__(self, n_neighbors, distance_function="MAE"):
+        self.n_neighbors = n_neighbors
+        self.distance_function = distance_function
+
+    def load_batch(self, data):
+        raise NotImplementedError("load_batch not implemented")
+
+    def fov_sum(self, data):
+        x, y = self.load_batch(data)
+        return abs(x[0] - x[1]) * (y.sum())
+
+    def load_weights(self, directory):
+        self.X = np.load(Path(directory) / "X.npy")
+
+    def _distance(self, yr, resmask):
+        X = self.X[:, resmask]
+        X /= X.sum(axis=-1, keepdims=True)
+        yr = yr[resmask].reshape(1, -1)
+        yr = yr / yr.sum()
+        if self.distance_function == "MAE":
+            distance = np.abs(yr - X).mean(axis=-1)
+        elif self.distance_function == "MSE":
+            distance = np.square(yr - X).mean(axis=-1)
+        else:
+            raise Exception("Unknown distance function")
+        return distance
+
+    def _resample(self, data):
+        x, y = data["ts_total_x"], data["ts_total_y"]
+        xmetric, ymetric = self.load_batch(data)
+        resampler = C1toSacrumResampler(x, y)
+        _, yr, resmask = resampler(xmetric, ymetric)
+        return _, yr, resmask
+
+    def _nn_estimate(self, distance):
+        ixs = np.argsort(distance)[:self.n_neighbors]
+        Xmu = self.X[ixs, :].mean(axis=0)
+        Xmu = Xmu / Xmu.sum()
+        return Xmu
+
+    def predict(self, data):
+        fov_sum = self.fov_sum(data)
+        _, yr, resmask = self._resample(data)
+        distance = self._distance(yr, resmask)
+        nn_mean = self._nn_estimate(distance)
+        fov_fraction = nn_mean[resmask].sum()
+        return fov_sum * 1 / fov_fraction
+
+
+class KNNActivity(KNNModel):
+    def load_batch(self, data):
+        return data["pet_x"], data["pet_y"]
+
+
+class KNNLeanBodyMass(KNNModel):
+    def load_batch(self, data):
+        lbm = data["ts_body_y"].sum(axis=1) - 0.76 * (data["ts_tissues_y"][:, 0] + data["ts_tissues_y"][:, 1])
+        lbm[lbm < 0] = 0
+        return data["ts_body_x"], lbm
+
+
+class KNNBodyVolume(KNNModel):
+    def load_batch(self, data):
+        return data["ts_body_x"], data["ts_body_y"].sum(axis=1)

id_uptake_values-0.1.0/src/id_uptake_values/resampling.py

@@ -0,0 +1,50 @@
+import numpy as np
+
+
+def in_fov_volume_ml(x, y):
+    dz = np.abs(np.diff(x[:2]))
+    return (y.sum() * dz).item()
+
+
+class C1toSacrumResampler:
+    def __init__(self, xts, yts, range=[0.75, -3], sample_points=1024):
+        sacrum_adf = yts[:, 25 - 1]
+        c1_adf = yts[:, 50 - 1]
+
+        if (c1_vol := in_fov_volume_ml(xts, c1_adf)) < 0.5:
+            raise ValueError(f"C1 volume too small {c1_vol:.2f}ml")
+
+        if (c1_vol := in_fov_volume_ml(xts, sacrum_adf)) < 2:
+            raise ValueError(f"Sacrum volume too small {c1_vol:.2f}ml")
+
+        self.head_offset = xts[np.argmax(c1_adf)]
+        self.hip_offset = xts[np.argmax(sacrum_adf)]
+
+        self.range = range
+        self.x_interp = np.linspace(self.range[0], self.range[1], sample_points)
+
+    def _interp(self, x, y):
+        return np.interp(self.x_interp, (x - self.head_offset) / (self.head_offset - self.hip_offset), y, right=0, left=0)
+
+    def _check_fix_data_mask(self, data_mask):
+        if not data_mask.any():
+            raise ValueError("data_mask is empty")
+
+        indices = np.nonzero(data_mask)
+        first = indices[0][0]
+        last = indices[0][-1]
+        x_probe = (self.x_interp >= -1) & (self.x_interp <= 0)
+        data_mask[first:last + 1] = True
+
+        if not data_mask[x_probe].all():
+            raise ValueError("data fov does not cover C1 to sacrum")
+
+        return data_mask
+
+    def __call__(self, x, y):
+        data_mask = y > 0
+        y_interp = self._interp(x, y)
+        data_mask = self._interp(x, data_mask)
+        data_mask = data_mask == 1
+        self._check_fix_data_mask(data_mask)
+        return self.x_interp, y_interp, data_mask

id_uptake_values-0.1.0/src/id_uptake_values/sul.py

@@ -0,0 +1,64 @@
+import argparse
+import json
+from pathlib import Path
+
+import nibabel as nib
+
+from .debug_plots import create_debug_image
+from .estimation import build_outputs, estimate_dose_and_volume, knn_model
+from .models import KNNLeanBodyMass
+
+
+def sul_id(pet_img, ct_img, ts_total_img, ts_tissue_img, ts_body_img):
+    total_dose, total_volume = estimate_dose_and_volume(pet_img, ct_img, ts_total_img, ts_tissue_img, ts_body_img,
+                                                        KNNLeanBodyMass, knn_model / "lbm")
+    return build_outputs(pet_img, total_dose, total_volume, "sul", "estimated_lbm_kg")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Estimate SUL (lean-body-mass-corrected SUV) from PET/CT and TotalSegmentator masks.")
+    parser.add_argument("--pet", required=True, type=Path, help="Path to PET image (NIfTI).")
+    parser.add_argument("--ct", required=True, type=Path, help="Path to CT image (NIfTI).")
+    parser.add_argument("--totalseg", required=True, type=Path, help="Path to TotalSegmentator 'total' segmentation (NIfTI).")
+    parser.add_argument("--tissueseg", required=True, type=Path, help="Path to TotalSegmentator tissue segmentation (NIfTI).")
+    parser.add_argument("--bodyseg", required=True, type=Path, help="Path to TotalSegmentator body segmentation (NIfTI).")
+    parser.add_argument("--output-image", type=Path, default=None, help="Path to save the SUL image (NIfTI).")
+    parser.add_argument("--output-json", type=Path, default=None, help="Path to save the SUL constants (JSON).")
+    parser.add_argument("--debug-image", type=Path, default=None, help="Path to save a debug PNG of the axial cropping and ADF.")
+    args = parser.parse_args()
+
+    if args.output_image is None and args.output_json is None and args.debug_image is None:
+        parser.error("at least one of --output-image, --output-json or --debug-image must be given")
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    pet_img = nib.load(args.pet)
+    ct_img = nib.load(args.ct)
+    ts_total_img = nib.load(args.totalseg)
+    ts_tissue_img = nib.load(args.tissueseg)
+    ts_body_img = nib.load(args.bodyseg)
+
+    if args.debug_image is not None:
+        create_debug_image(pet_img, ct_img, ts_total_img, ts_tissue_img, ts_body_img, args.debug_image, knn_model)
+
+    if args.output_image is None and args.output_json is None:
+        return
+
+    sul_img, constants = sul_id(pet_img, ct_img, ts_total_img, ts_tissue_img, ts_body_img)
+
+    if args.output_image is not None:
+        args.output_image.parent.mkdir(parents=True, exist_ok=True)
+        nib.save(sul_img, args.output_image)
+
+    if args.output_json is not None:
+        args.output_json.parent.mkdir(parents=True, exist_ok=True)
+        with open(args.output_json, "w") as handle:
+            json.dump(constants, handle, sort_keys=True, indent=4)
+
+
+if __name__ == "__main__":
+    main()

id_uptake_values-0.1.0/src/id_uptake_values/suv.py

@@ -0,0 +1,54 @@
+import argparse
+import json
+from pathlib import Path
+
+import nibabel as nib
+
+from .estimation import build_outputs, estimate_dose_and_volume, knn_model
+from .models import KNNBodyVolume
+
+
+def suv_id(pet_img, ct_img, ts_total_img, ts_body_img):
+    total_dose, total_body_mass = estimate_dose_and_volume(pet_img, ct_img, ts_total_img, None, ts_body_img,
+                                                           KNNBodyVolume, knn_model / "weight")
+    return build_outputs(pet_img, total_dose, total_body_mass, "suv", "estimated_body_mass_kg")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Estimate SUV (body-mass-corrected) from PET/CT and TotalSegmentator masks.")
+    parser.add_argument("--pet", required=True, type=Path, help="Path to PET image (NIfTI).")
+    parser.add_argument("--ct", required=True, type=Path, help="Path to CT image (NIfTI).")
+    parser.add_argument("--totalseg", required=True, type=Path, help="Path to TotalSegmentator 'total' segmentation (NIfTI).")
+    parser.add_argument("--bodyseg", required=True, type=Path, help="Path to TotalSegmentator body segmentation (NIfTI).")
+    parser.add_argument("--output-image", type=Path, default=None, help="Path to save the SUV image (NIfTI).")
+    parser.add_argument("--output-json", type=Path, default=None, help="Path to save the SUV constants (JSON).")
+    args = parser.parse_args()
+
+    if args.output_image is None and args.output_json is None:
+        parser.error("at least one of --output-image or --output-json must be given")
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    pet_img = nib.load(args.pet)
+    ct_img = nib.load(args.ct)
+    ts_total_img = nib.load(args.totalseg)
+    ts_body_img = nib.load(args.bodyseg)
+
+    suv_img, constants = suv_id(pet_img, ct_img, ts_total_img, ts_body_img)
+
+    if args.output_image is not None:
+        args.output_image.parent.mkdir(parents=True, exist_ok=True)
+        nib.save(suv_img, args.output_image)
+
+    if args.output_json is not None:
+        args.output_json.parent.mkdir(parents=True, exist_ok=True)
+        with open(args.output_json, "w") as handle:
+            json.dump(constants, handle, sort_keys=True, indent=4)
+
+
+if __name__ == "__main__":
+    main()