tools/data_processing/quality_control/asrm_preprocess.py

import os
import cv2
import torch
import numpy as np
from torch.utils.data import Dataset, DataLoader, WeightedRandomSampler
from torchvision import transforms
from typing import List, Tuple, Dict
import random


class FundusQualityDataset(Dataset):
    """
    Dataset for fundus quality classification
    Combines:
    - Labeled invalid images
    - Labeled valid images
    - Unlabeled raw images (optional)
    """
    def __init__(
        self,
        invalid_dir: str,
        valid_dir: str,
        raw_dir: str = None,
        img_size: int = 512,
        transform=None,
        use_raw: bool = False,
        raw_pseudo_label_threshold: float = 0.5
    ):
        self.img_size = img_size
        self.transform = transform
        self.use_raw = use_raw
        self.raw_pseudo_label_threshold = raw_pseudo_label_threshold
        
        # Load labeled data
        self.invalid_paths = self._load_image_paths(invalid_dir)
        self.valid_paths = self._load_image_paths(valid_dir)
        
        # Load unlabeled raw data
        self.raw_paths = []
        if use_raw and raw_dir is not None:
            self.raw_paths = self._load_image_paths(raw_dir)
            
        # Combine all paths and create labels
        self.image_paths = []
        self.labels = []
        self.is_labeled = []
        
        # Invalid images (label=0)
        for path in self.invalid_paths:
            self.image_paths.append(path)
            self.labels.append(0)
            self.is_labeled.append(True)
            
        # Valid images (label=1)
        for path in self.valid_paths:
            self.image_paths.append(path)
            self.labels.append(1)
            self.is_labeled.append(True)
            
        # Raw images (unlabeled, label=-1 initially)
        if use_raw:
            for path in self.raw_paths:
                self.image_paths.append(path)
                self.labels.append(-1)  # Pseudo label placeholder
                self.is_labeled.append(False)
                
        # Pseudo labels dict (for raw images)
        self.pseudo_labels = {}
        
        print(f"Dataset loaded: {len(self.invalid_paths)} invalid, "
              f"{len(self.valid_paths)} valid, "
              f"{len(self.raw_paths)} raw")
        
    # f:\oinn\image_filter\FQ-ManifoldNet\model_ASRMNet\asrm_preprocess.py

    # 修改第30行附近的 _load_image_paths 函数
    def _load_image_paths(self, directory: str) -> List[str]:
        """Load all image paths from directory"""
        if not os.path.exists(directory):
            print(f"⚠️  目录不存在: {directory}")
            return []
            
        image_paths = []
        # 支持的扩展名（包含DICOM格式）
        valid_extensions = ('.png', '.jpg', '.jpeg', '.tif', '.tiff', '.bmp', '.dcm')
        
        # 列出所有文件进行调试
        all_files = os.listdir(directory)
        print(f"📂 {os.path.basename(directory)}: 找到 {len(all_files)} 个文件")
        
        # 尝试多种方式扫描
        for filename in all_files:
            # 方法1: 检查小写扩展名
            if filename.lower().endswith(valid_extensions):
                image_paths.append(os.path.join(directory, filename))
        
        print(f"✅ {os.path.basename(directory)}: 成功加载 {len(image_paths)} 张图像")
        
        # 如果还是0，尝试直接使用所有文件（跳过目录）
        if len(image_paths) == 0:
            print(f"🔍 {os.path.basename(directory)}: 尝试直接使用所有文件...")
            for filename in all_files:
                filepath = os.path.join(directory, filename)
                if os.path.isfile(filepath):
                    image_paths.append(filepath)
            print(f"   第二次尝试: 加载了 {len(image_paths)} 张")
        
        return image_paths
        
    def set_pseudo_labels(self, pseudo_label_dict: Dict[str, float]):
        """
        Set pseudo labels for raw images
        Args:
            pseudo_label_dict: {image_path: quality_score} (0-1)
        """
        self.pseudo_labels = pseudo_label_dict
        
    def __len__(self) -> int:
        return len(self.image_paths)
        
    def __getitem__(self, idx: int) -> Dict:
        img_path = self.image_paths[idx]
        
        # Load image
        img = cv2.imread(img_path)
        if img is None:
            # Return empty image if loading fails
            img = np.zeros((self.img_size, self.img_size, 3), dtype=np.uint8)
            
        # Convert to RGB
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        
        # Resize
        img = cv2.resize(img, (self.img_size, self.img_size))
        
        # Apply transforms
        if self.transform is not None:
            img = self.transform(img)
        
        # Get label
        if self.is_labeled[idx]:
            label = self.labels[idx]
        else:
            # Use pseudo label if available, else return -1
            if img_path in self.pseudo_labels:
                score = self.pseudo_labels[img_path]
                label = 1 if score > self.raw_pseudo_label_threshold else 0
            else:
                label = -1
                
        return {
            'image': img,
            'label': label,
            'is_labeled': self.is_labeled[idx],
            'path': img_path
        }


def get_train_transforms(img_size: int = 512):
    """Training data transforms with augmentation"""
    return transforms.Compose([
        transforms.ToPILImage(),
        transforms.RandomHorizontalFlip(p=0.5),
        transforms.RandomRotation(degrees=15),
        transforms.ColorJitter(
            brightness=0.2,
            contrast=0.2,
            saturation=0.2,
            hue=0.1
        ),
        transforms.ToTensor(),
        transforms.Normalize(
            mean=[0.485, 0.456, 0.406],
            std=[0.229, 0.224, 0.225]
        )
    ])


def get_val_transforms(img_size: int = 512):
    """Validation/test data transforms (no augmentation)"""
    return transforms.Compose([
        transforms.ToPILImage(),
        transforms.ToTensor(),
        transforms.Normalize(
            mean=[0.485, 0.456, 0.406],
            std=[0.229, 0.224, 0.225]
        )
    ])


def create_data_loaders(
    invalid_dir: str,
    valid_dir: str,
    raw_dir: str = None,
    img_size: int = 512,
    batch_size: int = 32,
    num_workers: int = 8,
    use_raw: bool = False,
    use_weighted_sampler: bool = True
) -> Tuple[DataLoader, DataLoader]:
    """
    Create train and validation data loaders
    Args:
        invalid_dir: Directory with invalid fundus images
        valid_dir: Directory with valid fundus images
        raw_dir: Directory with raw unlabeled images (optional)
        img_size: Target image size
        batch_size: Batch size
        num_workers: Number of data loading workers
        use_raw: Whether to include raw unlabeled images
        use_weighted_sampler: Whether to use weighted sampler for class imbalance
    Returns:
        (train_loader, val_loader)
    """
    # Create train dataset
    train_dataset = FundusQualityDataset(
        invalid_dir=invalid_dir,
        valid_dir=valid_dir,
        raw_dir=raw_dir,
        img_size=img_size,
        transform=get_train_transforms(img_size),
        use_raw=use_raw
    )
    
    # Split into train/val
    dataset_size = len(train_dataset)
    val_size = int(0.2 * dataset_size)
    train_size = dataset_size - val_size
    
    from torch.utils.data import random_split
    train_subset, val_subset = random_split(
        train_dataset,
        [train_size, val_size],
        generator=torch.Generator().manual_seed(42)
    )
    
    # Create samplers
    if use_weighted_sampler:
        # Weighted sampler to handle class imbalance
        labeled_indices = [i for i in range(len(train_dataset)) 
                          if train_dataset.is_labeled[i]]
        
        if len(labeled_indices) > 0:
            labeled_labels = [train_dataset.labels[i] for i in labeled_indices]
            class_counts = np.bincount(labeled_labels, minlength=2)
            class_weights = 1.0 / (class_counts + 1e-8)
            
            # Create weights for all samples (unlabeled get weight 1)
            weights = torch.ones(len(train_subset))
            for idx_in_subset, idx_in_dataset in enumerate(train_subset.indices):
                if train_dataset.is_labeled[idx_in_dataset]:
                    label = train_dataset.labels[idx_in_dataset]
                    weights[idx_in_subset] = class_weights[label]
                    
            sampler = WeightedRandomSampler(weights, len(weights))
        else:
            sampler = None
    else:
        sampler = None
    
    # Create data loaders
    train_loader = DataLoader(
        train_subset,
        batch_size=batch_size,
        sampler=sampler,
        shuffle=(sampler is None),
        num_workers=num_workers,
        pin_memory=True,
        drop_last=True
    )
    
    val_loader = DataLoader(
        val_subset,
        batch_size=batch_size,
        shuffle=False,
        num_workers=num_workers,
        pin_memory=True
    )
    
    return train_loader, val_loader