| |
| """Build model-facing manifests and lightweight processed assets for liver data.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import re |
| import shutil |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
|
|
|
|
| PHASES = { |
| 0: "native", |
| 1: "arterial", |
| 2: "portal", |
| 3: "delayed", |
| } |
|
|
| CLINICAL_KEEP = [ |
| "age", |
| "gender_woman", |
| "etiology_mixed", |
| "etiology_HCV", |
| "etiology_HBV", |
| "etiology_alcoholic", |
| "etiology_NASH", |
| "etiology_cryptogenic", |
| "lesions_number", |
| "lesion1_diameter", |
| "lesion1_LIRADS", |
| "lesion2_diameter", |
| "lesion2_LIRADS", |
| "lesion3_diameter", |
| "lesion3_LIRADS", |
| "biopsy", |
| "lab_albumin", |
| "lab_creatinine", |
| "lab_bilirubin", |
| "lab_afp", |
| "lab_inr", |
| "lab_alt", |
| "tace_number", |
| "initial_LR_TR", |
| "cps", |
| "bclc", |
| "hap_score", |
| "mhap_2", |
| "albi_tae", |
| "6_12", |
| "6_12_score", |
| "nonv", |
| ] |
|
|
|
|
| def rel(path: Path, root: Path) -> str: |
| if not path: |
| return "" |
| path = path if path.is_absolute() else path.absolute() |
| root = root if root.is_absolute() else root.absolute() |
| try: |
| return str(path.relative_to(root)) |
| except ValueError: |
| return str(path) |
|
|
|
|
| def ensure_dir(path: Path) -> None: |
| path.mkdir(parents=True, exist_ok=True) |
|
|
|
|
| def link_file(src: Path, dst: Path, *, overwrite: bool = False) -> Path: |
| ensure_dir(dst.parent) |
| if dst.exists() or dst.is_symlink(): |
| if not overwrite: |
| return dst |
| dst.unlink() |
| os.symlink(src.resolve(), dst) |
| return dst |
|
|
|
|
| def write_csv(df: pd.DataFrame, path: Path) -> None: |
| ensure_dir(path.parent) |
| df.to_csv(path, index=False) |
| print(f"Wrote {path} ({len(df)} rows, {len(df.columns)} columns)") |
|
|
|
|
| def preprocess_msd(project_root: Path, overwrite: bool) -> pd.DataFrame: |
| src_root = project_root / "data" / "extracted" / "msd_liver" / "Task03_Liver" |
| out_root = project_root / "data" / "processed" / "msd_liver" |
| if not src_root.exists(): |
| print(f"Skip MSD: missing {src_root}") |
| return pd.DataFrame() |
|
|
| rows = [] |
| dataset_json = json.loads((src_root / "dataset.json").read_text()) |
| for item in dataset_json["training"]: |
| image_src = (src_root / item["image"]).resolve() |
| label_src = (src_root / item["label"]).resolve() |
| if image_src.name.startswith("._") or not image_src.exists() or not label_src.exists(): |
| continue |
| case_id = image_src.name.replace(".nii.gz", "") |
| image_dst = link_file(image_src, out_root / "images" / image_src.name, overwrite=overwrite) |
| label_dst = link_file(label_src, out_root / "labels" / label_src.name, overwrite=overwrite) |
| rows.append( |
| { |
| "dataset": "msd_liver", |
| "patient_id": case_id, |
| "case_id": case_id, |
| "ct_path": rel(image_dst, project_root), |
| "label_path": rel(label_dst, project_root), |
| "liver_mask_label": 1, |
| "tumor_mask_label": 2, |
| "source": rel(src_root, project_root), |
| } |
| ) |
|
|
| df = pd.DataFrame(rows).sort_values("case_id") |
| write_csv(df, out_root / "manifest.csv") |
| write_csv(df, project_root / "manifests" / "msd_liver_manifest.csv") |
| return df |
|
|
|
|
| def _load_nibabel(): |
| import nibabel as nib |
|
|
| return nib |
|
|
|
|
| def _load_sitk(): |
| import SimpleITK as sitk |
|
|
| return sitk |
|
|
|
|
| def derive_liver_mask(totalseg_path: Path, out_path: Path, overwrite: bool) -> Path: |
| if out_path.exists() and not overwrite: |
| return out_path |
| nib = _load_nibabel() |
| ensure_dir(out_path.parent) |
| img = nib.load(str(totalseg_path)) |
| data = np.asanyarray(img.dataobj) |
| liver = (data == 5).astype(np.uint8) |
| nib.save(nib.Nifti1Image(liver, img.affine, img.header), str(out_path)) |
| return out_path |
|
|
|
|
| def combine_tumor_nrrds(nrrd_paths: list[Path], out_path: Path, overwrite: bool) -> Path | None: |
| if not nrrd_paths: |
| return None |
| if out_path.exists() and not overwrite: |
| return out_path |
| sitk = _load_sitk() |
| ensure_dir(out_path.parent) |
| base = sitk.ReadImage(str(nrrd_paths[0])) |
| arr = sitk.GetArrayFromImage(base) > 0 |
| skipped = [] |
| for path in nrrd_paths[1:]: |
| img = sitk.ReadImage(str(path)) |
| if img.GetSize() != base.GetSize(): |
| skipped.append(path.name) |
| continue |
| arr |= sitk.GetArrayFromImage(img) > 0 |
| out = sitk.GetImageFromArray(arr.astype(np.uint8)) |
| out.CopyInformation(base) |
| sitk.WriteImage(out, str(out_path)) |
| if skipped: |
| print(f"Warning: skipped mismatched tumor masks for {out_path.name}: {', '.join(skipped)}") |
| return out_path |
|
|
|
|
| def choose_first(paths: list[Path | None]) -> Path | None: |
| for path in paths: |
| if path: |
| return path |
| return None |
|
|
|
|
| def preprocess_waw(project_root: Path, overwrite: bool, derive_liver: bool) -> pd.DataFrame: |
| raw_root = project_root / "data" / "raw" / "waw_tace" |
| src_root = project_root / "data" / "extracted" / "waw_tace" |
| out_root = project_root / "data" / "processed" / "waw_tace" |
| metadata_path = raw_root / "ct_hcc_metadata_v2.csv" |
| clinical_path = raw_root / "clinical_data_wawtace_v2_15_07_2024.xlsx" |
| if not metadata_path.exists() or not src_root.exists(): |
| print(f"Skip WAW-TACE: missing metadata or extracted data under {src_root}") |
| return pd.DataFrame() |
|
|
| metadata = pd.read_csv(metadata_path) |
| clinical = pd.read_excel(clinical_path) |
| clinical = clinical.rename(columns={"PATPRI": "patient_id"}) |
| clinical["patient_id"] = clinical["patient_id"].astype(str) |
| clinical_by_patient = clinical.set_index("patient_id", drop=False) |
|
|
| tumor_root = src_root / "tumor_masks_wawtace_v1_08_05_2024" |
| rows = [] |
| for patient_id, group in metadata.groupby(metadata["patient_id"].astype(str)): |
| row: dict[str, object] = { |
| "dataset": "waw_tace", |
| "patient_id": patient_id, |
| "case_id": patient_id, |
| } |
| phase_liver_paths: list[Path | None] = [] |
| phase_tumor_paths: list[Path | None] = [] |
|
|
| for phase_num, phase_name in PHASES.items(): |
| phase_group = group[group["ct_phase"] == phase_num] |
| scan_src = src_root / patient_id / f"{patient_id}_{phase_num}_scan.nii.gz" |
| scan_dst = out_root / "images" / patient_id / scan_src.name |
| scan_exists = scan_src.exists() |
| if scan_exists: |
| link_file(scan_src, scan_dst, overwrite=overwrite) |
| row[f"ct_{phase_name}_path"] = rel(scan_dst, project_root) if scan_exists else "" |
| row[f"phase_available_{phase_name}"] = int(scan_exists) |
|
|
| row[f"slice_thickness_{phase_name}"] = ( |
| float(phase_group["slice_thickness"].iloc[0]) if not phase_group.empty else np.nan |
| ) |
| row[f"tumor_count_{phase_name}"] = int(phase_group["tumor_count"].iloc[0]) if not phase_group.empty else np.nan |
|
|
| organ_candidates = sorted( |
| list((src_root / patient_id).glob(f"{patient_id}_{phase_num}_total_segmentator*.nii.gz")) |
| + list((src_root / patient_id).glob(f"{patient_id}_{phase_num}_total_segmentator*.nii.nii.gz")) |
| ) |
| organ_src = organ_candidates[0] if organ_candidates else src_root / patient_id / f"{patient_id}_{phase_num}_total_segmentator.nii.nii.gz" |
| organ_dst = out_root / "organ_masks" / patient_id / f"{patient_id}_{phase_num}_totalsegmentator.nii.gz" |
| liver_path = None |
| if organ_src.exists(): |
| link_file(organ_src, organ_dst, overwrite=overwrite) |
| row[f"organ_mask_{phase_name}_path"] = rel(organ_dst, project_root) |
| if derive_liver: |
| liver_dst = out_root / "masks_liver" / patient_id / f"{patient_id}_{phase_num}_liver.nii.gz" |
| liver_path = derive_liver_mask(organ_src, liver_dst, overwrite) |
| row[f"liver_mask_{phase_name}_path"] = rel(liver_path, project_root) |
| else: |
| row[f"liver_mask_{phase_name}_path"] = "" |
| else: |
| row[f"organ_mask_{phase_name}_path"] = "" |
| row[f"liver_mask_{phase_name}_path"] = "" |
| phase_liver_paths.append(liver_path) |
|
|
| nrrd_paths = sorted(tumor_root.glob(f"{patient_id}/{patient_id}_{phase_num}_*_tumor_seg.nrrd")) |
| tumor_path = combine_tumor_nrrds( |
| nrrd_paths, |
| out_root / "masks_tumor" / patient_id / f"{patient_id}_{phase_num}_tumor.nii.gz", |
| overwrite, |
| ) |
| row[f"tumor_mask_{phase_name}_path"] = rel(tumor_path, project_root) if tumor_path else "" |
| row[f"tumor_lesion_mask_count_{phase_name}"] = len(nrrd_paths) |
| phase_tumor_paths.append(tumor_path) |
|
|
| row["liver_mask_path"] = rel(choose_first(phase_liver_paths), project_root) |
| row["tumor_mask_path"] = rel(choose_first(phase_tumor_paths), project_root) |
|
|
| if patient_id in clinical_by_patient.index: |
| c = clinical_by_patient.loc[patient_id] |
| row["label_response"] = c.get("initial_tace_answer", np.nan) |
| row["label_progression"] = c.get("progression", np.nan) |
| row["time_pfs"] = c.get("progression_time", np.nan) |
| row["event_pfs"] = c.get("progression", np.nan) |
| row["time_os"] = c.get("survival_time", np.nan) |
| row["event_os"] = c.get("death", np.nan) |
| row["time_ttp"] = c.get("progression_time", np.nan) |
| row["event_ttp"] = c.get("progression", np.nan) |
| for col in CLINICAL_KEEP: |
| if col in c.index: |
| row[col] = c[col] |
| row[f"{col}_missing"] = int(pd.isna(c[col])) |
| rows.append(row) |
|
|
| df = pd.DataFrame(rows).sort_values("patient_id") |
| clinical_out = out_root / "clinical.csv" |
| write_csv(clinical, clinical_out) |
| write_csv(df, out_root / "manifest.csv") |
| write_csv(df, project_root / "manifests" / "waw_tace_manifest.csv") |
| return df |
|
|
|
|
| def infer_hcc_phase(series_description: object, study_description: object) -> str: |
| text = f"{series_description or ''} {study_description or ''}".lower() |
| if "segmentation" in text: |
| return "seg" |
| if "pre" in text or "non" in text or "wo" in text: |
| return "native" |
| if "arter" in text or "art" in text: |
| return "arterial" |
| if "portal" in text or "venous" in text or "pv" in text: |
| return "portal" |
| if "delay" in text: |
| return "delayed" |
| if "3 phase" in text or "liver" in text: |
| return "multiphase_or_liver_protocol" |
| return "unknown" |
|
|
|
|
| def preprocess_hcc(project_root: Path) -> pd.DataFrame: |
| candidates = sorted((project_root / "data" / "raw" / "hcc_tace_seg").glob("manifest-*")) |
| if not candidates: |
| print("Skip HCC-TACE-Seg: no manifest-* directory found") |
| return pd.DataFrame() |
| manifest_root = candidates[-1] |
| metadata_path = manifest_root / "metadata.csv" |
| if not metadata_path.exists(): |
| print(f"Skip HCC-TACE-Seg: missing {metadata_path}") |
| return pd.DataFrame() |
|
|
| metadata = pd.read_csv(metadata_path) |
| rows = [] |
| for _, rec in metadata.iterrows(): |
| series_dir = manifest_root / str(rec["File Location"]).strip("./") |
| phase = infer_hcc_phase(rec.get("Series Description"), rec.get("Study Description")) |
| rows.append( |
| { |
| "dataset": "hcc_tace_seg", |
| "patient_id": rec.get("Subject ID", ""), |
| "case_id": rec.get("Study UID", ""), |
| "series_uid": rec.get("Series UID", ""), |
| "study_date": rec.get("Study Date", ""), |
| "study_description": rec.get("Study Description", ""), |
| "series_description": rec.get("Series Description", ""), |
| "modality": rec.get("Modality", ""), |
| "sop_class_name": rec.get("SOP Class Name", ""), |
| "number_of_images": rec.get("Number of Images", ""), |
| "phase_guess": phase, |
| "dicom_series_dir": rel(series_dir, project_root) if series_dir.exists() else "", |
| "series_available": int(series_dir.exists()), |
| } |
| ) |
| df = pd.DataFrame(rows).sort_values(["patient_id", "study_date", "series_description"]) |
| out_root = project_root / "data" / "processed" / "hcc_tace_seg" |
| write_csv(metadata, out_root / "metadata.csv") |
| write_csv(df, out_root / "series_manifest.csv") |
| write_csv(df, project_root / "manifests" / "hcc_tace_seg_series_manifest.csv") |
| return df |
|
|
|
|
| def write_summary(project_root: Path, msd: pd.DataFrame, waw: pd.DataFrame, hcc: pd.DataFrame) -> None: |
| rows = [ |
| { |
| "dataset": "msd_liver", |
| "processed_rows": len(msd), |
| "notes": "MSD training image/label symlinks and manifest", |
| }, |
| { |
| "dataset": "waw_tace", |
| "processed_rows": len(waw), |
| "notes": "Patient-level multiphase CT manifest with clinical/outcome columns", |
| }, |
| { |
| "dataset": "hcc_tace_seg", |
| "processed_rows": len(hcc), |
| "notes": "DICOM series-level manifest; phase is inferred from descriptions", |
| }, |
| ] |
| write_csv(pd.DataFrame(rows), project_root / "manifests" / "preprocessing_summary.csv") |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--project-root", type=Path, default=Path(__file__).resolve().parents[1]) |
| parser.add_argument("--overwrite", action="store_true") |
| parser.add_argument("--skip-liver-derive", action="store_true", help="Do not derive binary liver masks from TotalSegmentator label 5.") |
| args = parser.parse_args() |
|
|
| project_root = args.project_root.resolve() |
| msd = preprocess_msd(project_root, args.overwrite) |
| waw = preprocess_waw(project_root, args.overwrite, derive_liver=not args.skip_liver_derive) |
| hcc = preprocess_hcc(project_root) |
| write_summary(project_root, msd, waw, hcc) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
