| import os |
| import re |
| import json |
| import random |
| from pathlib import Path |
|
|
| import numpy as np |
| from PIL import Image |
|
|
| DATASET_A_INPUT_JSON = r"./Kvasir-SEG/kavsir_bboxes.json" |
| DATASET_A_IMAGE_DIR = r"./Kvasir-SEG/images" |
| DATASET_A_SPLIT_CSV = r"./split.csv" |
| DATASET_A_IMAGE_SUFFIX = ".jpg" |
|
|
| DATASET_B_DOWNLOAD_ROOT = r"./Gastronintestinal" |
| DATASET_B_DOWNLOAD_SIZE = 512 |
| DATASET_B_NPZ_PATH = None |
| DATASET_B_NPZ_EXTRACT_ROOT = r"./Gastronintestinal" |
| DATASET_B_SPLITS = ["train", "test", "val"] |
|
|
| OUTPUT_IMAGE_DIR = r"./Gastronintestinal/images" |
|
|
| RANDOM_SEED = 42 |
| IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".bmp", ".tif", ".tiff"} |
|
|
| random.seed(RANDOM_SEED) |
|
|
|
|
| def ensure_dir(path): |
| if path: |
| os.makedirs(path, exist_ok=True) |
|
|
|
|
| def safe_int(x): |
| return int(float(x)) |
|
|
|
|
| def to_uint8(arr): |
| arr = np.asarray(arr) |
| if arr.dtype == np.uint8: |
| return arr |
| arr = arr.astype(np.float32) |
| if arr.size > 0 and arr.min() >= 0 and arr.max() <= 1.0: |
| arr = arr * 255.0 |
| arr = np.clip(arr, 0, 255).astype(np.uint8) |
| return arr |
|
|
|
|
| def save_image_from_array(arr, save_path): |
| arr = to_uint8(arr) |
| if arr.ndim == 2: |
| img = Image.fromarray(arr, mode="L") |
| elif arr.ndim == 3: |
| if arr.shape[2] == 1: |
| img = Image.fromarray(arr[:, :, 0], mode="L") |
| elif arr.shape[2] == 3: |
| img = Image.fromarray(arr, mode="RGB") |
| elif arr.shape[2] == 4: |
| img = Image.fromarray(arr, mode="RGBA") |
| else: |
| raise ValueError(f"Unsupported image shape: {arr.shape}") |
| else: |
| raise ValueError(f"Unsupported image shape: {arr.shape}") |
| img.save(save_path) |
|
|
|
|
| def crop_and_save(bbox_rows, output_image_dir): |
| ensure_dir(output_image_dir) |
| total = len(bbox_rows) |
| saved_count = 0 |
| print(f"[CROP] Total rows: {total}") |
|
|
| for idx, row in enumerate(bbox_rows): |
| split = str(row["split"]).strip() |
| image_name = str(row["image_name"]).strip() |
| image_path = str(row["image_path"]).strip() |
| x_min = safe_int(row["x_min"]) |
| y_min = safe_int(row["y_min"]) |
| x_max = safe_int(row["x_max"]) |
| y_max = safe_int(row["y_max"]) |
|
|
| if not os.path.exists(image_path): |
| print(f"[WARN] Image not found, skip: {image_path}") |
| continue |
|
|
| try: |
| img = Image.open(image_path).convert("RGB") |
| except Exception as e: |
| print(f"[WARN] Failed to open image: {image_path}, error: {e}") |
| continue |
|
|
| w, h = img.size |
| x_min = max(0, min(x_min, w - 1)) |
| y_min = max(0, min(y_min, h - 1)) |
| x_max = max(0, min(x_max, w)) |
| y_max = max(0, min(y_max, h)) |
|
|
| if x_max <= x_min or y_max <= y_min: |
| print(f"[WARN] Invalid box, skip: {image_name}, box=({x_min},{y_min},{x_max},{y_max})") |
| continue |
|
|
| stem = os.path.splitext(image_name)[0] |
| new_image_name = f"{split}_{stem}.png" |
| crop_image_name = f"{split}_{stem}_polyp.png" |
| new_image_path = os.path.join(output_image_dir, new_image_name) |
| crop_image_path = os.path.join(output_image_dir, crop_image_name) |
|
|
| try: |
| img.save(new_image_path, format="PNG") |
| except Exception as e: |
| print(f"[WARN] Failed to save original: {new_image_path}, error: {e}") |
| continue |
|
|
| crop = img.crop((x_min, y_min, x_max, y_max)) |
| try: |
| crop.save(crop_image_path, format="PNG") |
| except Exception as e: |
| print(f"[WARN] Failed to save crop: {crop_image_path}, error: {e}") |
| continue |
|
|
| saved_count += 1 |
| if (idx + 1) % 200 == 0 or (idx + 1) == total: |
| print(f"[CROP] Processed {idx + 1}/{total}") |
|
|
| print(f"[CROP] Saved {saved_count} samples") |
| return saved_count |
|
|
|
|
| def load_split_csv(csv_path): |
| split_map = {} |
| with open(csv_path, "r", encoding="utf-8") as f: |
| header = f.readline() |
| for line in f: |
| line = line.strip() |
| if not line: |
| continue |
| parts = line.split(",", 1) |
| if len(parts) != 2: |
| continue |
| split_name = parts[0].strip() |
| image_filename = parts[1].strip() |
| stem = os.path.splitext(image_filename)[0] |
| split_map[stem] = split_name |
| return split_map |
|
|
|
|
| def bbox_to_int(bbox): |
| return ( |
| int(float(bbox["xmin"])), |
| int(float(bbox["ymin"])), |
| int(float(bbox["xmax"])), |
| int(float(bbox["ymax"])), |
| ) |
|
|
|
|
| def is_valid_bbox(bbox): |
| required_keys = {"xmin", "ymin", "xmax", "ymax"} |
| if not isinstance(bbox, dict): |
| return False |
| return required_keys.issubset(set(bbox.keys())) |
|
|
|
|
| def bbox_area(bbox): |
| try: |
| x_min, y_min, x_max, y_max = bbox_to_int(bbox) |
| w = max(0, x_max - x_min) |
| h = max(0, y_max - y_min) |
| return w * h |
| except Exception: |
| return -1 |
|
|
|
|
| def select_single_bbox(bboxes): |
| valid_bboxes = [b for b in bboxes if is_valid_bbox(b)] |
| if not valid_bboxes: |
| return None |
| return max(valid_bboxes, key=bbox_area) |
|
|
|
|
| def pipeline_dataset_a(): |
| print("\n" + "=" * 60) |
| print("Dataset A: Kvasir-SEG Pipeline") |
| print("=" * 60) |
|
|
| print(f"Loading JSON: {DATASET_A_INPUT_JSON}") |
| with open(DATASET_A_INPUT_JSON, "r", encoding="utf-8") as f: |
| data = json.load(f) |
|
|
| print(f"Loading split CSV: {DATASET_A_SPLIT_CSV}") |
| split_map = load_split_csv(DATASET_A_SPLIT_CSV) |
| print(f"Split CSV entries: {len(split_map)}") |
|
|
| samples = [] |
| missing_images = [] |
| no_split_info = [] |
|
|
| for image_id, info in data.items(): |
| image_name = f"{image_id}{DATASET_A_IMAGE_SUFFIX}" |
| image_path = os.path.join(DATASET_A_IMAGE_DIR, image_name) |
|
|
| if not os.path.isfile(image_path): |
| missing_images.append(image_name) |
| continue |
|
|
| split_name = split_map.get(image_id) |
| if split_name is None: |
| no_split_info.append(image_id) |
| continue |
|
|
| bboxes = info.get("bbox", []) |
| if not isinstance(bboxes, list) or len(bboxes) == 0: |
| continue |
|
|
| selected_bbox = select_single_bbox(bboxes) |
| if selected_bbox is None: |
| continue |
|
|
| samples.append({ |
| "image_id": image_id, |
| "image_name": image_name, |
| "image_path": image_path, |
| "split": split_name, |
| "bbox": selected_bbox, |
| }) |
|
|
| print(f"Valid images: {len(samples)}") |
| print(f"Missing images: {len(missing_images)}") |
| print(f"No split info: {len(no_split_info)}") |
|
|
| if len(samples) == 0: |
| print("[ERROR] Dataset A: No valid samples found.") |
| return 0 |
|
|
| bbox_rows = [] |
| for sample in samples: |
| bb = sample["bbox"] |
| x_min, y_min, x_max, y_max = bbox_to_int(bb) |
| bbox_rows.append({ |
| "split": sample["split"], |
| "image_name": sample["image_name"], |
| "image_path": sample["image_path"], |
| "x_min": x_min, |
| "y_min": y_min, |
| "x_max": x_max, |
| "y_max": y_max, |
| }) |
|
|
| return crop_and_save(bbox_rows, OUTPUT_IMAGE_DIR) |
|
|
|
|
| def is_binary_mask(arr): |
| unique_vals = np.unique(arr) |
| return set(unique_vals.tolist()).issubset({0, 1}) |
|
|
|
|
| def key_to_subdir(key): |
| parts = key.split("_") |
| if len(parts) >= 2 and parts[0] in {"train", "val", "valid", "validation", "test"}: |
| split = parts[0] |
| rest = "_".join(parts[1:]) |
| return Path(split) / rest |
| return Path(key) |
|
|
|
|
| def extract_npz(npz_path, output_root): |
| npz_name = Path(npz_path).stem |
| npz_out_root = Path(output_root) / npz_name |
| ensure_dir(npz_out_root) |
|
|
| print(f"[NPZ] Loading: {npz_path}") |
| data = np.load(npz_path, allow_pickle=True) |
|
|
| print("[NPZ] Keys:") |
| for key in data.files: |
| arr = data[key] |
| print(f" - {key}: shape={arr.shape}, dtype={arr.dtype}") |
|
|
| for key in data.files: |
| arr = np.asarray(data[key]) |
| subdir = key_to_subdir(key) |
| target_dir = npz_out_root / subdir |
| ensure_dir(target_dir) |
|
|
| print(f"[NPZ] Exporting key: {key}") |
|
|
| if is_binary_mask(arr): |
| print(f" [binary mask -> npy] unique={np.unique(arr)[:10].tolist()}") |
| _save_npz_batch_as_npy(arr, target_dir, key) |
| continue |
|
|
| if arr.ndim == 2: |
| save_image_from_array(arr, target_dir / "0.png") |
| continue |
|
|
| if arr.ndim == 3 and arr.shape[-1] in (1, 3, 4): |
| save_image_from_array(arr, target_dir / "0.png") |
| continue |
|
|
| if arr.ndim == 3: |
| for i in range(arr.shape[0]): |
| if is_binary_mask(arr[i]): |
| np.save(target_dir / f"{i:05d}.npy", arr[i]) |
| else: |
| save_image_from_array(arr[i], target_dir / f"{i:05d}.png") |
| continue |
|
|
| if arr.ndim == 4 and arr.shape[-1] in (1, 3, 4): |
| for i in range(arr.shape[0]): |
| save_image_from_array(arr[i], target_dir / f"{i:05d}.png") |
| continue |
|
|
| np.save(target_dir / f"{key}.npy", arr) |
|
|
| return str(npz_out_root) |
|
|
|
|
| def _save_npz_batch_as_npy(arr, target_dir, key): |
| if arr.ndim == 2: |
| np.save(target_dir / "0.npy", arr) |
| return |
| if arr.ndim == 3 and arr.shape[-1] in (1, 3, 4): |
| np.save(target_dir / "0.npy", arr) |
| return |
| if arr.ndim >= 3: |
| for i in range(arr.shape[0]): |
| np.save(target_dir / f"{i:05d}.npy", arr[i]) |
| return |
| np.save(target_dir / f"{key}.npy", arr) |
|
|
|
|
| def get_file_stem_to_path(folder, valid_exts=None): |
| mapping = {} |
| folder = Path(folder) |
| if not folder.exists(): |
| print(f"[WARN] Folder does not exist: {folder}") |
| return mapping |
| for p in folder.iterdir(): |
| if not p.is_file(): |
| continue |
| if valid_exts is not None and p.suffix.lower() not in valid_exts: |
| continue |
| mapping[p.stem] = str(p) |
| return mapping |
|
|
|
|
| def mask_to_bbox(mask): |
| if mask.ndim != 2: |
| raise ValueError(f"Mask should be 2D, got shape={mask.shape}") |
| ys, xs = np.where(mask > 0) |
| if len(xs) == 0 or len(ys) == 0: |
| return None |
| return int(xs.min()), int(ys.min()), int(xs.max()), int(ys.max()) |
|
|
|
|
| def mask_dir_to_bbox_rows(extracted_root, splits): |
| all_rows = [] |
|
|
| for split in splits: |
| image_dir = os.path.join(extracted_root, split, "images") |
| label_dir = os.path.join(extracted_root, split, "label") |
|
|
| image_map = get_file_stem_to_path(image_dir, valid_exts=IMAGE_EXTS) |
| mask_map = get_file_stem_to_path(label_dir, valid_exts={".npy"}) |
|
|
| print(f"[MASK->BBOX] Split: {split}") |
| print(f" Image dir: {image_dir} ({len(image_map)} files)") |
| print(f" Label dir: {label_dir} ({len(mask_map)} files)") |
|
|
| common_names = sorted(set(image_map.keys()) & set(mask_map.keys())) |
| print(f" Matched pairs: {len(common_names)}") |
|
|
| skipped = 0 |
| for name in common_names: |
| image_path = image_map[name] |
| mask_path = mask_map[name] |
|
|
| try: |
| mask = np.load(mask_path) |
| if mask.ndim == 3 and mask.shape[-1] == 1: |
| mask = np.squeeze(mask, axis=-1) |
|
|
| bbox = mask_to_bbox(mask) |
| if bbox is None: |
| skipped += 1 |
| continue |
|
|
| x_min, y_min, x_max, y_max = bbox |
| all_rows.append({ |
| "split": split, |
| "image_name": os.path.basename(image_path), |
| "image_path": image_path, |
| "x_min": x_min, |
| "y_min": y_min, |
| "x_max": x_max, |
| "y_max": y_max, |
| }) |
| except Exception as e: |
| skipped += 1 |
| print(f" [ERROR] {name}: {e}") |
|
|
| print(f" Valid: {len(all_rows)}, Skipped: {skipped}") |
|
|
| return all_rows |
|
|
|
|
| def find_npz_file(download_root): |
| for root, dirs, files in os.walk(download_root): |
| for f in files: |
| if f.endswith(".npz"): |
| return os.path.join(root, f) |
| return None |
|
|
|
|
| def pipeline_dataset_b(): |
| print("\n" + "=" * 60) |
| print("Dataset B: PolypGenMSBench Pipeline") |
| print("=" * 60) |
|
|
| print("[DOWNLOAD] Downloading PolypGenMSBench...") |
| try: |
| from medsegbench import PolypGenMSBench |
|
|
| for split_name in ["train", "test"]: |
| print(f" Downloading split: {split_name}") |
| _ = PolypGenMSBench( |
| root=DATASET_B_DOWNLOAD_ROOT, |
| split=split_name, |
| download=True, |
| size=DATASET_B_DOWNLOAD_SIZE, |
| ) |
| print("[DOWNLOAD] Done.") |
| except ImportError: |
| print("[WARN] medsegbench not installed. Skipping download.") |
| print(" Please install: pip install medsegbench") |
| except Exception as e: |
| print(f"[WARN] Download error: {e}") |
|
|
| npz_path = DATASET_B_NPZ_PATH |
| if npz_path is None: |
| print("[NPZ] Searching for NPZ file...") |
| npz_path = find_npz_file(DATASET_B_DOWNLOAD_ROOT) |
| if npz_path is None: |
| print("[ERROR] No NPZ file found. Dataset B pipeline aborted.") |
| return 0 |
| print(f"[NPZ] Found: {npz_path}") |
|
|
| extracted_root = extract_npz(npz_path, DATASET_B_NPZ_EXTRACT_ROOT) |
|
|
| bbox_rows = mask_dir_to_bbox_rows(extracted_root, DATASET_B_SPLITS) |
|
|
| if len(bbox_rows) == 0: |
| print("[ERROR] Dataset B: No valid bbox rows generated.") |
| return 0 |
|
|
| return crop_and_save(bbox_rows, OUTPUT_IMAGE_DIR) |
|
|
|
|
| def main(): |
| print("=" * 60) |
| print("Integrated Pipeline: Multi-Dataset Processing") |
| print("=" * 60) |
| print(f"Output image dir: {OUTPUT_IMAGE_DIR}") |
|
|
| ensure_dir(OUTPUT_IMAGE_DIR) |
|
|
| count_a = pipeline_dataset_a() |
| count_b = pipeline_dataset_b() |
|
|
| print("\n" + "=" * 60) |
| print("Summary") |
| print("=" * 60) |
| print(f"Dataset A (Kvasir-SEG): {count_a} samples") |
| print(f"Dataset B (PolypGenMSBench): {count_b} samples") |
| print(f"Total: {count_a + count_b} samples") |
| print(f"All images saved to: {OUTPUT_IMAGE_DIR}") |
| print("Done.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
