add RoofSegmentationDataset

model_and_lightning_module.py

@@ -1,12 +1,18 @@
 """
-PyTorch Lightning modules for roof segmentation.
+Modules for roof segmentation.
 """
-from typing import Any, Dict
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional, Tuple
 
+import albumentations as A
+import cv2
+import numpy as np
 import pytorch_lightning as pl
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+from albumentations.pytorch import ToTensorV2
+from torch.utils.data import Dataset
 
 
 class DoubleConv(nn.Module):
@@ -150,3 +156,179 @@ class SegmentationLightningModule(pl.LightningModule):
 
     def forward(self, x):
         return self.model(x)
+
+
+class RoofSegmentationDataset(Dataset):
+    """Dataset for roof segmentation with images and masks."""
+    
+    def __init__(
+        self,
+        images_dir: Path,
+        masks_dir: Path,
+        transform: Optional[Callable] = None,
+        image_size: Tuple[int, int] = (512, 512)
+    ):
+        """
+        Args:
+            images_dir: Directory containing input images
+            masks_dir: Directory containing segmentation masks
+            transform: Albumentations transforms to apply
+            image_size: Target size for images (height, width)
+        """
+        self.images_dir = Path(images_dir)
+        self.masks_dir = Path(masks_dir)
+        self.image_size = image_size
+        self.transform = transform
+        
+        # Get all image files
+        self.image_files = []
+        for ext in ['.jpg', '.jpeg', '.png', '.tiff', '.tif']:
+            self.image_files.extend(self.images_dir.glob(f'*{ext}'))
+            self.image_files.extend(self.images_dir.glob(f'*{ext.upper()}'))
+        
+        self.image_files = sorted(self.image_files)
+        
+        # Verify that corresponding masks exist
+        self.valid_pairs = []
+        for image_path in self.image_files:
+            mask_candidates = []
+            for ext in ['.jpg', '.jpeg', '.png', '.tiff', '.tif']:
+                mask_path = self.masks_dir / f"{image_path.stem}{ext}"
+                if mask_path.exists():
+                    mask_candidates.append(mask_path)
+            
+            if mask_candidates:
+                self.valid_pairs.append((image_path, mask_candidates[0]))
+        
+        print(f"Dataset initialized with {len(self.valid_pairs)} image-mask pairs")
+    
+    def __len__(self) -> int:
+        return len(self.valid_pairs)
+    
+    def __getitem__(self, idx: int) -> dict:
+        image_path, mask_path = self.valid_pairs[idx]
+        
+        # Load image
+        image = cv2.imread(str(image_path))
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        # Load mask
+        mask = cv2.imread(str(mask_path), cv2.IMREAD_GRAYSCALE)
+        
+        # Resize to target size
+        image = cv2.resize(image, self.image_size)
+        mask = cv2.resize(mask, self.image_size, interpolation=cv2.INTER_NEAREST)
+        
+        # Normalize mask to 0-1 (assuming binary segmentation)
+        mask = (mask > 127).astype(np.uint8)
+        
+        # Apply transforms
+        if self.transform:
+            transformed = self.transform(image=image, mask=mask)
+            image = transformed['image']
+            mask = transformed['mask']
+            
+            # Ensure mask is float for loss calculations
+            if isinstance(mask, torch.Tensor):
+                mask = mask.float()
+        else:
+            # Convert to tensors manually if no transforms
+            image = torch.from_numpy(image.transpose(2, 0, 1)).float()
+            mask = torch.from_numpy(mask).float()
+        
+        return {
+            'image': image,
+            'mask': mask,
+            'image_path': str(image_path),
+            'mask_path': str(mask_path)
+        }
+
+
+def get_training_transforms(image_size: Tuple[int, int] = (512, 512)) -> A.Compose:
+    """Get augmentation transforms for training."""
+    return A.Compose([
+        A.HorizontalFlip(p=0.5),
+        A.VerticalFlip(p=0.5),
+        A.RandomRotate90(p=0.5),
+        A.ShiftScaleRotate(
+            shift_limit=0.1,
+            scale_limit=0.2,
+            rotate_limit=45,
+            border_mode=cv2.BORDER_CONSTANT,
+            value=0,
+            p=0.5
+        ),
+        A.OneOf([
+            A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=1.0),
+            A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, p=1.0),
+        ], p=0.5),
+        A.OneOf([
+            A.GaussianBlur(blur_limit=(3, 7), p=1.0),
+            A.MedianBlur(blur_limit=5, p=1.0),
+        ], p=0.3),
+        A.Resize(image_size[0], image_size[1]),
+        A.Normalize(
+            mean=[0.485, 0.456, 0.406],
+            std=[0.229, 0.224, 0.225]
+        ),
+        ToTensorV2()
+    ])
+
+
+def get_validation_transforms(image_size: Tuple[int, int] = (512, 512)) -> A.Compose:
+    """Get transforms for validation (no augmentation)."""
+    return A.Compose([
+        A.Resize(image_size[0], image_size[1]),
+        A.Normalize(
+            mean=[0.485, 0.456, 0.406],
+            std=[0.229, 0.224, 0.225]
+        ),
+        ToTensorV2()
+    ])
+
+
+def create_dataloaders(
+    train_images_dir: Path,
+    train_masks_dir: Path,
+    val_images_dir: Path,
+    val_masks_dir: Path,
+    batch_size: int = 8,
+    num_workers: int = 4,
+    image_size: Tuple[int, int] = (512, 512)
+) -> Tuple[torch.utils.data.DataLoader, torch.utils.data.DataLoader]:
+    """Create training and validation dataloaders."""
+    
+    # Create datasets
+    train_dataset = RoofSegmentationDataset(
+        images_dir=train_images_dir,
+        masks_dir=train_masks_dir,
+        transform=get_training_transforms(image_size),
+        image_size=image_size
+    )
+    
+    val_dataset = RoofSegmentationDataset(
+        images_dir=val_images_dir,
+        masks_dir=val_masks_dir,
+        transform=get_validation_transforms(image_size),
+        image_size=image_size
+    )
+    
+    # Create dataloaders
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=num_workers,
+        pin_memory=True,
+        drop_last=True
+    )
+    
+    val_loader = torch.utils.data.DataLoader(
+        val_dataset,
+        batch_size=batch_size,
+        shuffle=False,
+        num_workers=num_workers,
+        pin_memory=True
+    )
+    
+    return train_loader, val_loader