Upload folder using huggingface_hub

app.py

@@ -6,8 +6,9 @@ from experiments.kmeans_segmenter import generate_kmeans_segmented_image
 from experiments.enhanced_kmeans_segmenter import slic_kmeans
 from experiments.watershed_segmenter import generate_watershed
 from experiments.felzenszwalb_segmentation import segment
-from experiments.SegNet.efficient_b0_backbone.architecture import SegNetEfficientNet, NUM_CLASSES, DEVICE, IMAGE_SIZE
+from experiments.SegNet.efficient_b0_backbone.architecture import SegNetEfficientNet, NUM_CLASSES, DEVICE
 from experiments.SegNet.vgg_backbone.model import SegNet
+# from experiments.ensemble_method import generate_ensemble_segmentation
 import numpy as np
 from PIL import Image
 from matplotlib import cm
@@ -81,14 +82,14 @@ def generate_felzenszwalb(image_path, sigma, k, min_size_factor):
 
 def SegNet_efficient_b0(image_path):
     model = SegNetEfficientNet(NUM_CLASSES).to(DEVICE)
-    model.load_state_dict(torch.load("segnet_efficientnet_voc.pth", map_location=DEVICE))
+    model.load_state_dict(torch.load("saved_models/segnet_efficientnet_camvid.pth", map_location=DEVICE))
     model.eval()
     transform = transforms.Compose([
-        transforms.Resize(IMAGE_SIZE),
-        transforms.ToTensor(),
-        transforms.Normalize([0.485, 0.456, 0.406],
-                             [0.229, 0.224, 0.225])
-    ])
+    transforms.Resize((360, 480)),  # Or larger if needed
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                         std=[0.229, 0.224, 0.225])
+])
 
     image = Image.open(image_path).convert("RGB")
     input_tensor = transform(image).unsqueeze(0).to(DEVICE)
@@ -98,7 +99,7 @@ def SegNet_efficient_b0(image_path):
         pred_mask = torch.argmax(output, dim=1).squeeze(0).cpu().numpy()
 
     # Convert original image for Gradio display
-    original_image_resized = image.resize(IMAGE_SIZE)
+    original_image_resized = image
 
     # Convert predicted mask to a color image using a colormap
     colormap = cm.get_cmap('nipy_spectral')
@@ -108,6 +109,52 @@ def SegNet_efficient_b0(image_path):
 
     return original_image_resized, mask_pil
 
+def ensemble_segmentation(image_path):
+    """
+    Ensemble segmentation combining SegNet and Otsu,
+    assuming Otsu produces a mask with the foreground as black (value 0)
+    and background as white (value 255).
+
+    In this ensemble, we force the SegNet prediction to background (class 0)
+    where Otsu indicates background (after inversion, i.e., where otsu_bin==0).
+
+    Parameters:
+        image_path (str): Path to the input image.
+        
+    Returns:
+        original_image: The original resized image used for segmentation.
+        segnet_mask_pil: SegNet multi-class segmentation output (PIL image).
+        otsu_mask_pil: The original Otsu binary segmentation mask (PIL image).
+        ensemble_mask_pil: Final ensemble segmentation mask (PIL image).
+    """
+    # Run SegNet segmentation (model outputs a multi-class mask).
+    segnet_orig, segnet_mask_pil = SegNet_efficient_b0(image_path)
+    # Convert SegNet output to a NumPy array (assumed grayscale labeling, e.g., background=0).
+    segnet_mask_np = np.array(segnet_mask_pil.convert("L"))
+
+    # Run Otsu segmentation. (generate_segmented_image returns several outputs.)
+    _, otsu_segmented_pil, _, _, _ = generate_segmented_image(image_path)
+    
+    # Resize Otsu mask to match SegNet output shape, e.g., (480, 360) if SegNet works in that resolution.
+    resized_shape = (segnet_mask_np.shape[1], segnet_mask_np.shape[0])
+    otsu_mask_resized = otsu_segmented_pil.resize(resized_shape, Image.NEAREST)
+    otsu_mask_np = np.array(otsu_mask_resized)
+    
+    # Invert Otsu's binary mask:
+    # Assuming that in otsu_mask_np, foreground is black (0) and background is white (255),
+    # we build a binary mask where "1" represents the object's area.
+    otsu_bin = (otsu_mask_np == 0).astype(np.uint8)  # Now, foreground is 1 and background is 0.
+    
+    # Create the ensemble segmentation:
+    # Where Otsu indicates foreground (otsu_bin==1), keep SegNet's prediction;
+    # where Otsu is background (otsu_bin==0), force it to background class (0).
+    ensemble_seg = np.where(otsu_bin == 1, segnet_mask_np, 0)
+    
+    # Convert back to a PIL image.
+    ensemble_mask_pil = Image.fromarray(ensemble_seg.astype(np.uint8))
+    
+    return segnet_orig, segnet_mask_pil, otsu_segmented_pil, ensemble_mask_pil
+
 with gr.Blocks() as demo:
     gr.Markdown("# Image Segmentation using Classical CV")
     
@@ -120,10 +167,10 @@ with gr.Blocks() as demo:
                     threshold_text = gr.Textbox(label="Threshold Comparison", value="", interactive=False)
                 
                 with gr.Column(scale=2):
-                    image_output = gr.Image(label="Original Image", container=False)
-                    histogram_output = gr.Image(label="Histogram", container=False)
-                    segmented_image_output = gr.Image(label="Our Segmented Image", container=False)
-                    opencv_segmented_image_output = gr.Image(label="OpenCV Segmented Image", container=False)
+                    image_output = gr.Image(label="Original Image")
+                    histogram_output = gr.Image(label="Histogram")
+                    segmented_image_output = gr.Image(label="Our Segmented Image")
+                    opencv_segmented_image_output = gr.Image(label="OpenCV Segmented Image")
             display_btn.click(
                 fn=generate_segmented_image,
                 inputs=file_input,
@@ -138,8 +185,8 @@ with gr.Blocks() as demo:
                     kmeans_threshold_text = gr.Textbox(label="K-means Info", value="", interactive=False)
                 
                 with gr.Column(scale=2):
-                    kmeans_image_output = gr.Image(label="Original Image", container=False)
-                    kmeans_segmented_image_output = gr.Image(label="K-means Segmented Image", container=False)
+                    kmeans_image_output = gr.Image(label="Original Image")
+                    kmeans_segmented_image_output = gr.Image(label="K-means Segmented Image")
             
             kmeans_display_btn.click(
                 fn=generate_kmeans,
@@ -156,8 +203,8 @@ with gr.Blocks() as demo:
                     slic_display_btn = gr.Button("Segment this image")
                 
                 with gr.Column(scale=2):
-                    slic_image_output = gr.Image(label="Original Image", container=False)
-                    slic_segmented_image_output = gr.Image(label="SLIC Segmented Image", container=False)
+                    slic_image_output = gr.Image(label="Original Image",container=True)
+                    slic_segmented_image_output = gr.Image(label="SLIC Segmented Image",container=True)
             
             slic_display_btn.click(
                 fn=generate_slic,
@@ -172,8 +219,8 @@ with gr.Blocks() as demo:
                     watershed_display_btn = gr.Button("Segment this image")
                 
                 with gr.Column(scale=2):
-                    watershed_image_output = gr.Image(label="Original Image", container=False)
-                    watershed_segmented_image_output = gr.Image(label="watershed Segmented Image", container=False)
+                    watershed_image_output = gr.Image(label="Original Image",container=True)
+                    watershed_segmented_image_output = gr.Image(label="watershed Segmented Image",container=True)
             
             watershed_display_btn.click(
                 fn=generate_watershed,
@@ -190,8 +237,8 @@ with gr.Blocks() as demo:
                     felzenszwalb_display_btn = gr.Button("Segment this image")
                 
                 with gr.Column(scale=2):
-                    felzenszwalb_image_output = gr.Image(label="Original Image", container=False)
-                    felzenszwalb_segmented_image_output = gr.Image(label="felzenszwalb Segmented Image", container=False)
+                    felzenszwalb_image_output = gr.Image(label="Original Image",container=True)
+                    felzenszwalb_segmented_image_output = gr.Image(label="felzenszwalb Segmented Image",container=True)
             
             felzenszwalb_display_btn.click(
                 fn=generate_felzenszwalb,
@@ -205,8 +252,8 @@ with gr.Blocks() as demo:
                     segnet_display_btn = gr.Button("Segment this image")
                 
                 with gr.Column(scale=2):
-                    segnet_image_output = gr.Image(label="Original Image", container=False)
-                    segnet_segmented_image_output = gr.Image(label="SegNet Segmented Image", container=False)
+                    segnet_image_output = gr.Image(label="Original Image")
+                    segnet_segmented_image_output = gr.Image(label="SegNet Segmented Image")
             
             segnet_display_btn.click(
                 fn=SegNet_efficient_b0,
@@ -220,14 +267,33 @@ with gr.Blocks() as demo:
                     segnet_display_btn = gr.Button("Segment this image")
                 
                 with gr.Column(scale=2):
-                    segnet_image_output = gr.Image(label="Original Image", container=False)
-                    segnet_segmented_image_output = gr.Image(label="SegNet VGG Segmented Image", container=False)
+                    segnet_image_output = gr.Image(label="Original Image")
+                    segnet_segmented_image_output = gr.Image(label="SegNet VGG Segmented Image")
             
             segnet_display_btn.click(
                 fn=generate_segnet_vgg,
                 inputs=[segnet_file_input],
                 outputs=[segnet_image_output,segnet_segmented_image_output]
         )
+        # In app.py
+        with gr.TabItem("Ensemble Segmentation"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    ensemble_file_input = gr.File(label="Upload Image File")
+                    ensemble_display_btn = gr.Button("Segment with Ensemble Method")
+                
+                with gr.Column(scale=2):
+                    ensemble_image_output = gr.Image(label="Original Image")
+                    ensemble_mask = gr.Image(label="Ensemble Segmented Image")
+                    ensemble_segnet_segmented_output = gr.Image(label="SegNet Efficient B0 Segmented Image")
+                    ensemble_otsu_segmented_output = gr.Image(label="Otsu Segmented Image")
+            
+            ensemble_display_btn.click(
+                fn=ensemble_segmentation,
+                inputs=[ensemble_file_input],
+                outputs=[ensemble_image_output, ensemble_segnet_segmented_output, ensemble_otsu_segmented_output, ensemble_mask]
+            )
+
 if __name__ == "__main__":
     demo.launch()
 

experiments/SegNet/efficient_b0_backbone/architecture.py

@@ -1,14 +1,20 @@
+
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 from torchvision import models, transforms
 from torchvision.datasets import VOCSegmentation
 from torch.utils.data import DataLoader
+from torch.utils.data import Dataset
+import glob
 from PIL import Image
 import numpy as np
 import wandb
+import pandas as pd 
 import os
 import matplotlib.pyplot as plt
+import opendatasets as opd
+import zipfile
 
 torch.manual_seed(42)
 np.random.seed(42)
@@ -18,70 +24,155 @@ np.random.seed(42)
 EPOCHS = 25
 BATCH_SIZE = 8
 LR = 1e-3
-NUM_CLASSES = 21  # Pascal VOC has 21 classes including background
-IMAGE_SIZE = (256, 256)
+NUM_CLASSES = 32
 DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 
-# wandb.init(project="segnet-efficientnet-voc", config={
+# wandb.init(project="segnet-efficientnet-camvid", config={
 #     "epochs": EPOCHS,
 #     "batch_size": BATCH_SIZE,
 #     "learning_rate": LR,
 #     "architecture": "SegNet-EfficientNet",
-#     "dataset": "PascalVOC2012"
+#     "dataset": "CamVid"
 # })
 
 class SegNetEfficientNet(nn.Module):
-    def __init__(self, num_classes):
+    def __init__(self, num_classes=32):
         super(SegNetEfficientNet, self).__init__()
         base_model = models.efficientnet_b0(pretrained=True)
         features = list(base_model.features.children())
 
-        # Encoder: Use EfficientNet blocks
-        self.encoder = nn.Sequential(*features)
+        # EfficientNet-B0 backbone (output channels gradually increase to 1280)
+        self.encoder = nn.Sequential(*features)  # Output: [B, 1280, H/32, W/32]
 
-        # Decoder: Up-convolutions
+        # Decoder blocks (mirroring encoder with ConvTranspose2d)
         self.decoder = nn.Sequential(
             nn.ConvTranspose2d(1280, 512, kernel_size=2, stride=2),
+            nn.BatchNorm2d(512),
             nn.ReLU(inplace=True),
+
             nn.ConvTranspose2d(512, 256, kernel_size=2, stride=2),
+            nn.BatchNorm2d(256),
             nn.ReLU(inplace=True),
+
             nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2),
+            nn.BatchNorm2d(128),
             nn.ReLU(inplace=True),
+
             nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+
+            nn.ConvTranspose2d(64, 32, kernel_size=2, stride=2),
+            nn.BatchNorm2d(32),
             nn.ReLU(inplace=True),
-            nn.ConvTranspose2d(64, num_classes, kernel_size=1)
         )
 
+        self.classifier = nn.Conv2d(32, num_classes, kernel_size=1)
+
     def forward(self, x):
-        x = self.encoder(x)
-        x = self.decoder(x)
-        x = F.interpolate(x, size=IMAGE_SIZE, mode='bilinear', align_corners=False)
+        x = self.encoder(x)  # Downsampled features from EfficientNet
+        x = self.decoder(x)  # Upsampled
+        x = self.classifier(x)
+        x = F.interpolate(x, size=(360, 480), mode='bilinear', align_corners=False)
+        
         return x
 
-class VOCSegmentationDataset(VOCSegmentation):
-    def __init__(self, root, image_set='train', transform=None, target_transform=None):
-        super().__init__(root=root, year='2012', image_set=image_set, download=True)
+class CamVidDataset(Dataset):
+    """
+    CamVid dataset loader with RGB mask to class index conversion.
+    Expects directory structure:
+        camvid/
+            train/
+            train_labels/
+            val/
+            val_labels/
+            test/
+            test_labels/
+    """
+    def __init__(self, root, split='train', transform=None, image_size=(360, 480), target_transform=None, class_dict_path='camvid/CamVid/class_dict.csv'):
+        self.root = root
+        self.split = split
         self.transform = transform
         self.target_transform = target_transform
 
-    def __getitem__(self, index):
-        img, target = super().__getitem__(index)
+        self.image_dir = os.path.join(root, split)
+        self.label_dir = os.path.join(root, f"{split}_labels")
+
+        self.image_paths = sorted(glob.glob(os.path.join(self.image_dir, '*.png')))
+        self.label_paths = sorted(glob.glob(os.path.join(self.label_dir, '*.png')))
+        self.label_resize = transforms.Resize(image_size, interpolation=Image.NEAREST)
+        self.image_resize = transforms.Resize(image_size, interpolation=Image.BILINEAR)
+        assert len(self.image_paths) == len(self.label_paths), "Mismatch between images and labels."
+
+        # Load class_dict.csv and build color-to-class mapping
+        df = pd.read_csv(class_dict_path)
+        self.color_to_class = {
+            (row['r'], row['g'], row['b']): idx for idx, row in df.iterrows()
+        }
+
+    def __len__(self):
+        return len(self.image_paths)
+
+    def rgb_to_class(self, mask):
+        """Convert an RGB mask (PIL.Image) to a 2D class index mask."""
+        mask_np = np.array(mask)
+        h, w, _ = mask_np.shape
+        class_mask = np.zeros((h, w), dtype=np.uint8)
+
+        for rgb, class_idx in self.color_to_class.items():
+            matches = (mask_np == rgb).all(axis=2)
+            class_mask[matches] = class_idx
+
+        return class_mask
+
+    def __getitem__(self, idx):
+        image = Image.open(self.image_paths[idx]).convert('RGB')
+        label = Image.open(self.label_paths[idx]).convert('RGB')
+
+        # Resize both to 360x480
+        image = self.image_resize(image)
+        label = self.label_resize(label)
+
         if self.transform:
-            img = self.transform(img)
-        if self.target_transform:
-            target = self.target_transform(target)
-        target = torch.as_tensor(np.array(target), dtype=torch.long)
-        return img, target
+            image = self.transform(image)
+
+        label = self.rgb_to_class(label)
+        label = torch.from_numpy(label).long()
+
+        return image, label
+
 if __name__ == "__main__":  
-    image_transform = transforms.Compose([
-        transforms.Resize(IMAGE_SIZE),
-        transforms.ToTensor(),
-        transforms.Normalize([0.485, 0.456, 0.406],
-                            [0.229, 0.224, 0.225])
-    ])
-    mask_transform = transforms.Resize(IMAGE_SIZE, interpolation=Image.NEAREST)
-
-    train_dataset = VOCSegmentationDataset("voc_data", 'train', image_transform, mask_transform)
-    val_dataset = VOCSegmentationDataset("voc_data", 'val', image_transform, mask_transform)
-    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2)
-    val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=2)
+    dataset_url = "https://www.kaggle.com/datasets/carlolepelaars/camvid"
+    opd.download(dataset_url)
+
+    # Set dataset folder (adjust path if needed)
+    dataset_folder = "camvid"
+    print("Dataset directory contents:")
+    print(os.listdir(dataset_folder))
+    input_transform = transforms.Compose([
+    transforms.Resize((360, 480)),  # Or larger if needed
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                         std=[0.229, 0.224, 0.225])
+])
+
+    def label_transform(label):
+        # Resize using nearest neighbor so that labels are not interpolated
+        label = label.resize((480, 360), Image.NEAREST)
+        label = np.array(label, dtype=np.int64)
+        return torch.from_numpy(label)
+
+    num_classes = 32
+    data_root = 'camvid/CamVid/'  # make sure this matches your structure
+
+    # Load datasets and dataloaders (assuming CamVidDataset is already defined)
+    train_dataset = CamVidDataset(root=data_root, split='train',
+                                transform=input_transform, target_transform=label_transform)
+    val_dataset = CamVidDataset(root=data_root, split='val',
+                                transform=input_transform, target_transform=label_transform)
+    test_dataset = CamVidDataset(root=data_root, split='test',
+                                transform=input_transform, target_transform=label_transform)
+
+    train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True, num_workers=4)
+    val_loader = DataLoader(val_dataset, batch_size=4, shuffle=False, num_workers=4)
+    test_loader = DataLoader(test_dataset, batch_size=1, shuffle=True, num_workers=4)

experiments/SegNet/efficient_b0_backbone/train.py

@@ -76,6 +76,6 @@ for epoch in tqdm(range(EPOCHS)):
 
     print(f"Epoch [{epoch+1}/{EPOCHS}] Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}, Acc: {val_acc:.4f}")
 
-torch.save(model.state_dict(), "segnet_efficientnet_voc.pth")
+torch.save(model.state_dict(), "segnet_efficientnet_camvid.pth")
 # wandb.finish()
 

experiments/ensemble_method.py

@@ -0,0 +1,148 @@
+import torch
+import numpy as np
+from PIL import Image
+import cv2
+from torchvision import transforms
+from experiments.otsu_segmenter import otsu_threshold
+from experiments.SegNet.efficient_b0_backbone.architecture import SegNetEfficientNet, NUM_CLASSES, DEVICE
+
+def ensemble_segmentation(image_path, model_path="segnet_efficientnet_voc.pth", boundary_weight=0.3):
+    """
+    Ensemble segmentation combining Otsu thresholding and SegNet
+    
+    Args:
+        image_path: Path to input image
+        model_path: Path to SegNet model weights
+        boundary_weight: Weight for boundary refinement (0-1)
+        
+    Returns:
+        original_image: Original input image (PIL)
+        ensemble_result: Ensemble segmentation result (PIL)
+        method_comparison: Visualization of all methods side by side (PIL)
+    """
+    # 1. Load the image
+    image = Image.open(image_path).convert('RGB')
+    original = image.copy()
+    image_np = np.array(image)
+    
+    # 2. Run Otsu thresholding for boundary detection
+    # Convert to grayscale and apply Gaussian blur
+    gray = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+    gray = cv2.cvtColor(gray, cv2.COLOR_BGR2GRAY)
+    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+    otsu_threshold_value, otsu_mask = otsu_threshold(blurred)
+    
+    # 3. Run SegNet for semantic segmentation
+    model = SegNetEfficientNet(NUM_CLASSES).to(DEVICE)
+    model.load_state_dict(torch.load(model_path, map_location=DEVICE))
+    model.eval()
+    
+    transform = transforms.Compose([
+    transforms.Resize((360, 480)),  # Or larger if needed
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                         std=[0.229, 0.224, 0.225])
+])
+    
+    input_tensor = transform(image).unsqueeze(0).to(DEVICE)
+    
+    with torch.no_grad():
+        output = model(input_tensor)
+        segnet_pred = torch.argmax(output, dim=1).squeeze(0).cpu().numpy()
+    
+    # 4. Create edge map from Otsu result
+    edges = cv2.Canny(otsu_mask, 50, 150)
+    
+    # Resize to match SegNet output size
+    edges_resized = cv2.resize(edges, (segnet_pred.shape[1], segnet_pred.shape[0]), 
+                               interpolation=cv2.INTER_NEAREST)
+    
+    # 5. Ensemble: Use Otsu edges to refine SegNet boundaries
+    # Create a distance transform from the edges
+    dist_transform = cv2.distanceTransform(255 - edges_resized, cv2.DIST_L2, 5)
+    dist_transform = dist_transform / dist_transform.max()  # Normalize to 0-1
+    
+    # Areas close to edges get more influence from Otsu
+    edge_weight_map = np.exp(-dist_transform * 5) * boundary_weight
+    
+    # Create binary mask from SegNet (foreground = any class other than background)
+    segnet_binary = (segnet_pred > 0).astype(np.uint8) * 255
+    
+    # Resize Otsu mask to match SegNet output
+    otsu_resized = cv2.resize(otsu_mask, (segnet_pred.shape[1], segnet_pred.shape[0]), 
+                              interpolation=cv2.INTER_NEAREST)
+    
+    # Combine: Use SegNet classes but refine boundaries with Otsu
+    # For boundary regions, adjust the segmentation based on Otsu
+    refined_binary = segnet_binary.copy()
+    boundary_region = edge_weight_map > 0.1
+    refined_binary[boundary_region] = (
+        (1 - edge_weight_map[boundary_region]) * segnet_binary[boundary_region] + 
+        edge_weight_map[boundary_region] * otsu_resized[boundary_region]
+    ).astype(np.uint8)
+    
+    # Apply the refined binary mask to the original SegNet prediction
+    ensemble_result = segnet_pred.copy()
+    # Where the refined binary is 0, set to background class (0)
+    ensemble_result[refined_binary < 128] = 0
+    
+    # 6. Visualize results
+    from matplotlib import cm
+    import matplotlib.pyplot as plt
+    import io
+    
+    # Convert semantic maps to color visualizations
+    colormap = cm.get_cmap('nipy_spectral')
+    
+    segnet_colored = colormap(segnet_pred / (NUM_CLASSES - 1))
+    segnet_colored = (segnet_colored[:, :, :3] * 255).astype(np.uint8)
+    
+    ensemble_colored = colormap(ensemble_result / (NUM_CLASSES - 1))
+    ensemble_colored = (ensemble_colored[:, :, :3] * 255).astype(np.uint8)
+    
+    # Create side-by-side comparison
+    fig, axes = plt.subplots(1, 4, figsize=(16, 4))
+    
+    # Resize original image to match the segmentation size
+    original_resized = original.resize((segnet_pred.shape[1], segnet_pred.shape[0]))
+    
+    axes[0].imshow(original_resized)
+    axes[0].set_title("Original Image")
+    axes[0].axis('off')
+    
+    axes[1].imshow(otsu_mask, cmap='gray')
+    axes[1].set_title(f"Otsu (t={otsu_threshold_value})")
+    axes[1].axis('off')
+    
+    axes[2].imshow(segnet_colored)
+    axes[2].set_title("SegNet Prediction")
+    axes[2].axis('off')
+    
+    axes[3].imshow(ensemble_colored)
+    axes[3].set_title("Ensemble Result")
+    axes[3].axis('off')
+    
+    plt.tight_layout()
+    
+    # Convert the plot to an image
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    comparison_image = Image.open(buf)
+    plt.close(fig)
+    
+    # Return results
+    ensemble_pil = Image.fromarray(ensemble_colored)
+    ensemble_pil = ensemble_pil.resize(original.size, Image.NEAREST)
+    
+    return original, ensemble_pil, comparison_image
+
+# Add this function to your app.py
+def generate_ensemble_segmentation(image_path, boundary_weight=0.3):
+    """Wrapper for Gradio interface"""
+    original, ensemble_result, comparison = ensemble_segmentation(
+        image_path, 
+        model_path="saved_models/segnet_efficientnet_camvid.pth",
+        boundary_weight=boundary_weight
+    )
+    return original, ensemble_result, comparison

saved_models/segnet_efficientnet_camvid.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f1e96df359eb0e1c153627880dc93e662b2ae5f998f9ed946ec71e726739481
+size 29641657

saved_models/segnet_vgg.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ac7681151184571d468e4c408c30107dd8b44170b602a06b97a24240f0fb83b
+size 49538462