Download Preprocess/3D_Task/CT-RATE/CT2Xray.py from MEDHEB/MedHEB-Bench: direct link, hf CLI and curl.
- Browser
- Download file 7.42 kB
-
https://huggingface.co/datasets/MEDHEB/MedHEB-Bench/resolve/main/Preprocess/3D_Task/CT-RATE/CT2Xray.py
- Command line
-
hf download hf://datasets/MEDHEB/MedHEB-Bench/Preprocess/3D_Task/CT-RATE/CT2Xray.py
-
curl -L -o CT2Xray.py https://huggingface.co/datasets/MEDHEB/MedHEB-Bench/resolve/main/Preprocess/3D_Task/CT-RATE/CT2Xray.py
7.42 kB
| #!/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() | |