#!/usr/bin/env python3 """ GAMMA adapter — multimodal glaucoma grading (fundus + 3D OCT volume + DC mask + fovea). Inputs: {input_root}/grading/Glaucoma_grading/{training,testing}/multi-modality_images/NNNN/ NNNN.jpg fundus image NNNN/{0..255}_image.jpg 256 OCT B-scan slices (3D macular volume) NNNN_Sequence.mhd/.raw raw 3D metadata (not used here) {input_root}/grading/Glaucoma_grading/training/glaucoma_grading_training_GT.xlsx columns: data, non, early, mid_advanced (one-hot) {input_root}/fovea_localization_training_GT.xlsx columns: data, Fovea_X, Fovea_Y {input_root}/mask_DC/train/NNNN.png disc/cup mask, train only (pixel 0/128/255) Outputs (under {output_root}): extracted/public_gamma_multimodal/{hash[:2]}/{hash}/ fundus_color.jpg disc_cup_mask.png (train only; 0/128/255) oct_bscan_volume/000.png...255.png (re-encoded grayscale PNG) meta.json manifest/public_gamma_multimodal_images.parquet manifest/public_gamma_multimodal_sidecar.parquet (fovea coords, train only) captions/public_gamma_multimodal_captions.parquet Manifest rows per sample: 1 fundus row + 256 OCT B-scan rows, all sharing the same study_id. patient_hash = study_id (file-level, no patient ID in dataset). Glaucoma label mapping (one-hot): non=1 -> diagnosis_group=[], severity=none early=1 -> diagnosis_group=["glaucoma"], severity=mild mid_advanced=1 -> diagnosis_group=["glaucoma"], severity=severe """ import argparse import json import re from concurrent.futures import ProcessPoolExecutor, as_completed from pathlib import Path import numpy as np import pandas as pd from PIL import Image, ImageFile ImageFile.LOAD_TRUNCATED_IMAGES = True from public_common import ( IMAGE_SCHEMA_COLUMNS, CAPTION_SCHEMA_COLUMNS, study_hash_for, default_base_fields, caption_l1_public, caption_l3_public, study_dir_for, rel_file_path, write_meta, coerce_image_row, ) COHORT = "public_gamma_multimodal" COHORT_PHRASE = "GAMMA multimodal glaucoma grading dataset" def _glaucoma_label(row): """Returns (diagnosis_group, severity) from one-hot label row.""" if row.get("non") == 1: return ([], "none") if row.get("early") == 1: return (["glaucoma"], "mild") if row.get("mid_advanced") == 1: return (["glaucoma"], "severe") return ([], "unknown") def _save_three_class_mask(src: Path, dst: Path): arr = np.array(Image.open(src).convert("L")) out = np.zeros_like(arr) out[(arr > 64) & (arr < 192)] = 128 out[arr >= 192] = 255 Image.fromarray(out, mode="L").save(dst, "PNG", optimize=True) def process_sample(args): (sample_id, split, sample_dir_str, label_row, fovea_row, mask_path_str, out_root_str, force) = args sample_dir = Path(sample_dir_str) out_root = Path(out_root_str) basename = f"{split}_{sample_id}" sh = study_hash_for(COHORT, basename) sdir = study_dir_for(out_root, COHORT, sh) sdir.mkdir(parents=True, exist_ok=True) oct_dir = sdir / "oct_bscan_volume" oct_dir.mkdir(exist_ok=True) meta_p = sdir / "meta.json" if meta_p.exists() and not force: try: meta = json.loads(meta_p.read_text()) if meta.get("status") == "ok": return _build_all(meta) except Exception: pass fundus_src = sample_dir / f"{sample_id}.jpg" fundus_dst = sdir / "fundus_color.jpg" img = Image.open(fundus_src).convert("RGB") fw, fh = img.size img.save(fundus_dst, "JPEG", quality=95) oct_slice_dir = sample_dir / sample_id slice_files = sorted(oct_slice_dir.glob("*_image.jpg"), key=lambda p: int(p.name.split("_")[0])) n_slices = len(slice_files) oct_h = oct_w = None for i, sf in enumerate(slice_files): with Image.open(sf) as si: arr = np.array(si.convert("L")) if oct_h is None: oct_h, oct_w = arr.shape Image.fromarray(arr, mode="L").save( oct_dir / f"{i:03d}.png", "PNG", optimize=True) has_dc_mask = False if mask_path_str: mp = Path(mask_path_str) if mp.exists(): _save_three_class_mask(mp, sdir / "disc_cup_mask.png") has_dc_mask = True meta = { "status": "ok", "cohort": COHORT, "study_hash": sh, "source_basename": basename, "split": split, "sample_id": sample_id, "fundus_height_px": int(fh), "fundus_width_px": int(fw), "n_oct_bscan": int(n_slices), "oct_bscan_height_px": int(oct_h) if oct_h else None, "oct_bscan_width_px": int(oct_w) if oct_w else None, "eye": "unknown", "has_dc_mask": has_dc_mask, "label_non": int(label_row.get("non", 0)) if label_row else None, "label_early": int(label_row.get("early", 0)) if label_row else None, "label_mid_advanced": int(label_row.get("mid_advanced", 0)) if label_row else None, "fovea_x_px": float(fovea_row["Fovea_X"]) if fovea_row else None, "fovea_y_px": float(fovea_row["Fovea_Y"]) if fovea_row else None, } write_meta(sdir, meta) return _build_all(meta) def _build_all(meta: dict): sh = meta["study_hash"] if meta.get("label_non") is not None: dx, sev = _glaucoma_label({"non": meta["label_non"], "early": meta["label_early"], "mid_advanced": meta["label_mid_advanced"]}) dx_source = "expert_grade" else: dx, sev = [], "unknown" dx_source = "none" base = default_base_fields(COHORT, sh, eye=meta["eye"]) base["diagnosis_group"] = dx base["severity"] = sev base["diagnosis_source"] = dx_source if dx_source == "expert_grade": base["label_confidence"] = "consensus" rows, caps = [], [] # --- Fundus row --- fundus_id = f"{COHORT}_{sh}_fundus_color" fundus_row = dict(base) fundus_row.update({ "image_id": fundus_id, "file_path": rel_file_path(COHORT, sh, "fundus_color.jpg"), "file_format": "jpg", "modality": "fundus_color", "anatomy": "macula", "device_technology": "fundus_camera", "scan_protocol": "single_shot", "image_height_px": meta["fundus_height_px"], "image_width_px": meta["fundus_width_px"], "has_segmentation": bool(meta.get("has_dc_mask")), "n_layers_visible": 0, "is_valid": True, }) rows.append(fundus_row) caps.extend(caption_l1_public(fundus_id, COHORT_PHRASE, "fundus_color", meta["eye"])) parts = [f"A color fundus photograph from the GAMMA dataset ({meta['split']} split)"] if sev != "unknown": parts.append(f"glaucoma severity {sev}") if meta.get("has_dc_mask"): parts.append("with optic disc and cup segmentation mask") if meta.get("fovea_x_px") is not None: parts.append("with fovea center annotation") caps.append(caption_l3_public(fundus_id, ", ".join(parts) + ".", "manifest_fields+mask_presence")) # --- OCT B-scan rows --- n = int(meta["n_oct_bscan"]) oct_h = meta.get("oct_bscan_height_px") or 992 oct_w = meta.get("oct_bscan_width_px") or 512 for i in range(n): bid = f"{COHORT}_{sh}_oct_bscan_volume_{i:03d}" row = dict(base) row.update({ "image_id": bid, "file_path": rel_file_path(COHORT, sh, f"oct_bscan_volume/{i:03d}.png"), "file_format": "png", "modality": "oct_bscan", "anatomy": "macula", "device_technology": "ss_oct", "scan_protocol": "volume_3d_macula", "bscan_index": i, "image_height_px": int(oct_h), "image_width_px": int(oct_w), "has_segmentation": False, "n_layers_visible": 0, "is_valid": True, }) rows.append(row) caps.extend(caption_l1_public(bid, COHORT_PHRASE, "oct_bscan", meta["eye"])) oct_parts = [f"A macular OCT B-scan from the GAMMA dataset ({meta['split']} split)", f"slice {i+1} of {n} in a 3D macular volume scan"] if sev != "unknown": oct_parts.append(f"glaucoma severity {sev}") caps.append(caption_l3_public(bid, ", ".join(oct_parts) + ".", "manifest_fields+volume_index")) return rows, caps, _sidecar_row(meta) if meta.get("fovea_x_px") is not None else None def _sidecar_row(meta: dict) -> dict: sh = meta["study_hash"] return { "study_id": sh, "fundus_image_id": f"{COHORT}_{sh}_fundus_color", "split": meta["split"], "fovea_x_px": meta.get("fovea_x_px"), "fovea_y_px": meta.get("fovea_y_px"), "fundus_width_px": meta["fundus_width_px"], "fundus_height_px": meta["fundus_height_px"], } def main(): ap = argparse.ArgumentParser() ap.add_argument("--input-root", required=True, help="Path to .../Generation/GAMMA") ap.add_argument("--output-root", required=True) ap.add_argument("--num-workers", type=int, default=4) ap.add_argument("--force", action="store_true") ap.add_argument("--limit", type=int, default=None) args = ap.parse_args() in_root = Path(args.input_root) out_root = Path(args.output_root) train_labels = pd.read_excel( in_root / "grading/Glaucoma_grading/training/glaucoma_grading_training_GT.xlsx") train_labels["data"] = train_labels["data"].apply(lambda x: f"{int(x):04d}") label_idx = train_labels.set_index("data").to_dict(orient="index") fovea_df = pd.read_excel(in_root / "fovea_localization_training_GT.xlsx") fovea_df["data"] = fovea_df["data"].apply(lambda x: f"{int(x):04d}") fovea_idx = fovea_df.set_index("data").to_dict(orient="index") jobs = [] name_re = re.compile(r"^\d{4}$") for split_dir, split_name in [ (in_root / "grading/Glaucoma_grading/training/multi-modality_images", "train"), (in_root / "grading/Glaucoma_grading/testing/multi-modality_images", "test"), ]: for sample in sorted(p.name for p in split_dir.iterdir() if p.is_dir() and name_re.match(p.name)): sd = split_dir / sample lbl = label_idx.get(sample) if split_name == "train" else None fov = fovea_idx.get(sample) if split_name == "train" else None mask_p = (in_root / "mask_DC" / "train" / f"{sample}.png") if split_name == "train" else None jobs.append((sample, split_name, str(sd), lbl, fov, str(mask_p) if mask_p else None, str(out_root), args.force)) if args.limit: jobs = jobs[:args.limit] print(f"[{COHORT}] {len(jobs)} samples to process") all_rows, all_caps, all_side = [], [], [] failures = [] with ProcessPoolExecutor(max_workers=args.num_workers) as ex: fut_to_sid = {ex.submit(process_sample, j): j[0] for j in jobs} for i, fut in enumerate(as_completed(fut_to_sid), 1): sid = fut_to_sid[fut] try: rows, caps, side = fut.result() except Exception as e: failures.append((sid, type(e).__name__, str(e)[:120])) continue all_rows.extend(rows) all_caps.extend(caps) if side: all_side.append(side) if i % 20 == 0: print(f" ... {i}/{len(fut_to_sid)} samples done ({len(failures)} failed)") if failures: print(f"[{COHORT}] {len(failures)} samples FAILED:") for sid, et, msg in failures[:20]: print(f" {sid}: {et}: {msg}") mdir = out_root / "manifest"; cdir = out_root / "captions" mdir.mkdir(parents=True, exist_ok=True); cdir.mkdir(parents=True, exist_ok=True) imgs_df = pd.DataFrame([coerce_image_row(r) for r in all_rows])[IMAGE_SCHEMA_COLUMNS] imgs_df.to_parquet(mdir / f"{COHORT}_images.parquet", index=False) caps_df = pd.DataFrame(all_caps)[CAPTION_SCHEMA_COLUMNS] caps_df.to_parquet(cdir / f"{COHORT}_captions.parquet", index=False) if all_side: pd.DataFrame(all_side).to_parquet(mdir / f"{COHORT}_sidecar.parquet", index=False) print(f"[{COHORT}] wrote {len(imgs_df)} image rows ({(imgs_df.modality=='fundus_color').sum()} fundus + " f"{(imgs_df.modality=='oct_bscan').sum()} oct), {len(caps_df)} captions, {len(all_side)} sidecar rows") print(imgs_df.groupby(["modality", "severity"]).size().to_string()) if __name__ == "__main__": main()