Datasets:

MEDHEB
/

MedHEB-Bench

#!/usr/bin/env python3

import argparse
import logging
import sys
import time
from multiprocessing import Pool
from pathlib import Path

import cv2
import nibabel as nib
import numpy as np
from PIL import Image

BASE_DIR = Path("./CT_DATA/data_volumes/dataset")
OUTPUT_BASE = Path("./CT_DATA")

SPLIT_CONFIG = {
    "train": {
        "input_dir": BASE_DIR / "train_fixed",
        "output_dir": OUTPUT_BASE / "train_fixed_drr",
    },
    "valid": {
        "input_dir": BASE_DIR / "valid_fixed",
        "output_dir": OUTPUT_BASE / "valid_fixed_drr",
    },
}

DONE_MARKER = "_DONE"

HU_MIN = -1000
HU_MAX = 1200
MU_WATER = 0.0025

BODY_THRESHOLD_HU = -700
BODY_KERNEL_SIZE = 5

RAW_PERCENTILES = (0.5, 99.5)
INVERT = True

AUTO_CROP = True
CROP_PAD = 8
CROP_THRESHOLD_PERCENTILE = 3


def hu_to_attenuation(data, hu_min=HU_MIN, hu_max=HU_MAX, mu_water=MU_WATER):
    data_clipped = np.clip(data, hu_min, hu_max)
    mu = mu_water * (data_clipped / 1000.0 + 1.0)
    return np.clip(mu, 0, None).astype(np.float32)


def create_body_mask(data, threshold_hu=BODY_THRESHOLD_HU, kernel_size=BODY_KERNEL_SIZE):
    mask = (data > threshold_hu).astype(np.uint8)
    kernel = np.ones((kernel_size, kernel_size), np.uint8)

    for z in range(mask.shape[2]):
        sl = mask[:, :, z]
        sl = cv2.morphologyEx(sl, cv2.MORPH_CLOSE, kernel)
        sl = cv2.morphologyEx(sl, cv2.MORPH_OPEN, kernel)
        mask[:, :, z] = sl

    return mask.astype(np.float32)


def generate_drr(mu, axis, voxel_spacing, percentiles=RAW_PERCENTILES, invert=INVERT):
    spacing = float(voxel_spacing[axis])
    line_integral = np.sum(mu, axis=axis) * spacing
    projection = np.exp(-line_integral)

    p_low, p_high = np.percentile(projection, percentiles)
    projection = np.clip(projection, p_low, p_high)
    projection = (projection - p_low) / (p_high - p_low + 1e-8)

    if invert:
        projection = 1.0 - projection

    return np.clip(projection, 0, 1).astype(np.float32)


def auto_crop(img, pad=CROP_PAD, threshold_percentile=CROP_THRESHOLD_PERCENTILE):
    mask = img > np.percentile(img, threshold_percentile)
    coords = np.argwhere(mask)

    if len(coords) == 0:
        return img

    y0, x0 = coords.min(axis=0)
    y1, x1 = coords.max(axis=0)

    y0 = max(0, y0 - pad)
    x0 = max(0, x0 - pad)
    y1 = min(img.shape[0], y1 + pad)
    x1 = min(img.shape[1], x1 + pad)

    return img[y0:y1, x0:x1]


def process_volume(args):
    nifti_path, out_subdir = args
    sub_name = out_subdir.name

    try:
        img = nib.load(nifti_path)
        data = np.asarray(img.dataobj).astype(np.float32)
        voxel_spacing = img.header.get_zooms()[:3]

        mu = hu_to_attenuation(data)

        body_mask = create_body_mask(data)
        mu = mu * body_mask
        del body_mask

        drr_ap = generate_drr(mu, axis=1, voxel_spacing=voxel_spacing)
        del mu, data

        drr_ap = np.flipud(drr_ap.T)

        sp_row, sp_col = float(voxel_spacing[2]), float(voxel_spacing[0])
        if abs(sp_row - sp_col) > 0.01:
            min_sp = min(sp_row, sp_col)
            scale_h = sp_row / min_sp
            scale_w = sp_col / min_sp
            new_h = int(round(drr_ap.shape[0] * scale_h))
            new_w = int(round(drr_ap.shape[1] * scale_w))
            drr_ap = cv2.resize(drr_ap, (new_w, new_h), interpolation=cv2.INTER_LINEAR)

        if AUTO_CROP:
            drr_ap = auto_crop(drr_ap)

        out_subdir.mkdir(parents=True, exist_ok=True)
        img_uint8 = (drr_ap * 255).astype(np.uint8)
        Image.fromarray(img_uint8, mode="L").save(out_subdir / "drr_ap.png")

        (out_subdir / DONE_MARKER).touch()
        return (sub_name, True, "OK")

    except Exception as e:
        return (sub_name, False, str(e))


def discover_files(input_dir, output_dir):
    tasks = []
    for case_dir in sorted(input_dir.iterdir()):
        if not case_dir.is_dir():
            continue
        for sub_dir in sorted(case_dir.iterdir()):
            if not sub_dir.is_dir():
                continue
            sub_name = sub_dir.name
            nifti_path = sub_dir / f"{sub_name}_1.nii.gz"
            if not nifti_path.exists():
                continue
            out_subdir = output_dir / sub_name
            if (out_subdir / DONE_MARKER).exists():
                continue
            tasks.append((nifti_path, out_subdir))
    return tasks


def run_split(split, workers):
    cfg = SPLIT_CONFIG[split]
    input_dir = cfg["input_dir"]
    output_dir = cfg["output_dir"]

    logging.info(f"=== Processing {split} split (DRR) ===")
    logging.info(f"Input:  {input_dir}")
    logging.info(f"Output: {output_dir}")

    output_dir.mkdir(parents=True, exist_ok=True)
    tasks = discover_files(input_dir, output_dir)
    total = len(tasks)
    logging.info(f"Found {total} volumes to process (skipped already done)")

    if total == 0:
        logging.info("Nothing to do.")
        return

    done = 0
    failed = 0
    failed_files = []
    t0 = time.time()

    with Pool(processes=workers) as pool:
        for sub_name, success, msg in pool.imap_unordered(process_volume, tasks):
            done += 1
            if success:
                if done % 20 == 0 or done == total:
                    elapsed = time.time() - t0
                    rate = done / elapsed
                    eta = (total - done) / rate if rate > 0 else 0
                    logging.info(
                        f"[{split}] {done}/{total} done "
                        f"({done / total * 100:.1f}%) | "
                        f"{rate:.1f} vol/s | ETA {eta / 3600:.1f}h"
                    )
            else:
                failed += 1
                failed_files.append((sub_name, msg))
                logging.error(f"[{split}] FAILED {sub_name}: {msg}")

    elapsed = time.time() - t0
    logging.info(
        f"=== {split} DRR done: {done - failed} succeeded, "
        f"{failed} failed, {elapsed / 3600:.2f}h ==="
    )

    if failed_files:
        fail_path = OUTPUT_BASE / f"{split}_drr_failed.txt"
        with open(fail_path, "w") as f:
            for name, msg in failed_files:
                f.write(f"{name}\t{msg}\n")
        logging.info(f"Failed files written to {fail_path}")


def setup_logging():
    log_path = OUTPUT_BASE / "generate_drr.log"
    fmt = "%(asctime)s [%(levelname)s] %(message)s"
    handler_file = logging.FileHandler(log_path, mode="a")
    handler_console = logging.StreamHandler(sys.stdout)
    logging.basicConfig(
        level=logging.INFO,
        format=fmt,
        handlers=[handler_file, handler_console],
    )
    sys.stdout.reconfigure(line_buffering=True)


def main():
    parser = argparse.ArgumentParser(description="Generate DRR X-ray from CT NIfTI volumes")
    parser.add_argument(
        "--split",
        choices=["train", "valid", "both"],
        default="both",
        help="Which split to process (default: both)",
    )
    parser.add_argument(
        "--workers",
        type=int,
        default=8,
        help="Number of parallel workers (default: 8)",
    )
    args = parser.parse_args()

    setup_logging()
    logging.info(f"Starting DRR generation: split={args.split}, workers={args.workers}")

    if args.split == "both":
        run_split("train", args.workers)
        run_split("valid", args.workers)
    else:
        run_split(args.split, args.workers)


if __name__ == "__main__":
    main()