# CVC-ClinicDB Dataset for PixelGen Medical Image Generation # Polyp segmentation dataset: 612 RGB colonoscopy images with binary masks import os import torch import random import numpy as np from torch.utils.data import Dataset from PIL import Image import torchvision.transforms as transforms import torchvision.transforms.functional as TF from torchvision.transforms import Normalize class CVCClinicDBDataset(Dataset): """ CVC-ClinicDB dataset for mask-conditional image generation. Data format: - Images: 384x288 RGB colonoscopy images - Masks: Binary polyp segmentation (0/255) - 612 image pairs total Returns format compatible with PixelGen: - normalized_image: [3, H, W] in range [-1, 1] - label: class label (0 for all) - metadata: dict with 'raw_image', 'mask', 'class' """ def __init__(self, data_root, resolution=256, split='train', train_ratio=0.9, augment=True, seed=42, max_samples=None, random_flip=True): super().__init__() self.data_root = data_root self.resolution = resolution self.split = split self.augment = augment and (split == 'train') self.random_flip = random_flip and (split == 'train') self.img_dir = os.path.join(data_root, 'PNG', 'Original') self.mask_dir = os.path.join(data_root, 'PNG', 'Ground Truth') # Get all image files all_files = sorted([f for f in os.listdir(self.img_dir) if f.endswith('.png')]) # Split by index (no case structure in CVC-ClinicDB) random.seed(seed) indices = list(range(len(all_files))) random.shuffle(indices) split_idx = int(len(indices) * train_ratio) if split == 'train': selected_indices = indices[:split_idx] else: selected_indices = indices[split_idx:] self.images = [all_files[i] for i in sorted(selected_indices)] # Limit samples if specified if max_samples is not None and max_samples < len(self.images): random.seed(seed) self.images = random.sample(self.images, max_samples) # Normalization for images ([-1, 1] range) self.normalize = Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) print(f"[CVCClinicDBDataset] {split} set: {len(self.images)} images") def __len__(self): return len(self.images) def _load_and_process(self, idx): """Load and process a single sample.""" img_name = self.images[idx] img_path = os.path.join(self.img_dir, img_name) mask_path = os.path.join(self.mask_dir, img_name) # Load images - RGB colonoscopy image = Image.open(img_path).convert('RGB') mask = Image.open(mask_path).convert('L') # Binary mask -> single channel # Resize to target size (square) image = TF.resize(image, (self.resolution, self.resolution), interpolation=transforms.InterpolationMode.BILINEAR) mask = TF.resize(mask, (self.resolution, self.resolution), interpolation=transforms.InterpolationMode.NEAREST) # Data augmentation if self.augment: # Random horizontal flip if self.random_flip and random.random() > 0.5: image = TF.hflip(image) mask = TF.hflip(mask) # Random vertical flip if self.random_flip and random.random() > 0.5: image = TF.vflip(image) mask = TF.vflip(mask) # Random color jitter for image only if random.random() > 0.5: brightness_factor = random.uniform(0.85, 1.15) image = TF.adjust_brightness(image, brightness_factor) contrast_factor = random.uniform(0.85, 1.15) image = TF.adjust_contrast(image, contrast_factor) saturation_factor = random.uniform(0.85, 1.15) image = TF.adjust_saturation(image, saturation_factor) return image, mask def __getitem__(self, idx): # Load with retry logic max_retries = 10 for retry in range(max_retries): try: actual_idx = (idx + retry) % len(self.images) image, mask = self._load_and_process(actual_idx) break except Exception as e: if retry == max_retries - 1: raise RuntimeError(f"Failed to load image after {max_retries} retries: {e}") continue # Convert to tensor raw_image = TF.to_tensor(image) # [3, H, W], range [0, 1] # Normalize to [-1, 1] for model input normalized_image = self.normalize(raw_image) # Convert mask to tensor [1, H, W], range [0, 1] mask_tensor = TF.to_tensor(mask) # Already in [0, 1] after to_tensor # Label (single class) label = 0 # Metadata for PixelGen compatibility metadata = { "raw_image": raw_image, # [3, H, W] in [0, 1] for LPIPS/DINO "mask": mask_tensor, # [1, H, W] for mask conditioning "class": label, } return normalized_image, label, metadata class CVCClinicDBRandnDataset(Dataset): """ Random noise dataset for evaluation/prediction. Samples random masks from the dataset. """ def __init__(self, data_root, resolution=256, max_num_instances=1000, noise_scale=1.0, seed=42): super().__init__() self.resolution = resolution self.noise_scale = noise_scale # Load masks mask_dir = os.path.join(data_root, 'PNG', 'Ground Truth') all_files = sorted([f for f in os.listdir(mask_dir) if f.endswith('.png')]) # Sample a subset of masks (with repetition if needed) random.seed(seed) if max_num_instances <= len(all_files): self.mask_files = random.sample(all_files, max_num_instances) else: # Repeat masks to reach desired count self.mask_files = all_files * (max_num_instances // len(all_files) + 1) self.mask_files = self.mask_files[:max_num_instances] self.mask_dir = mask_dir print(f"[CVCClinicDBRandnDataset] {len(self.mask_files)} samples for generation") def __len__(self): return len(self.mask_files) def __getitem__(self, idx): # Random noise xT = self.noise_scale * torch.randn(3, self.resolution, self.resolution) # Load mask mask_path = os.path.join(self.mask_dir, self.mask_files[idx]) mask = Image.open(mask_path).convert('L') mask = TF.resize(mask, (self.resolution, self.resolution), interpolation=transforms.InterpolationMode.NEAREST) mask_tensor = TF.to_tensor(mask) label = 0 metadata = { "mask": mask_tensor, "class": label, } return xT, label, metadata