Update app.py

app.py

@@ -7,7 +7,8 @@ from PIL import Image
 import matplotlib.pyplot as plt
 import io
 from torchvision import transforms
-import torch.nn.functional as F
+import torchvision.models as models
+from torchvision.models import detection
 import warnings
 warnings.filterwarnings("ignore")
 
@@ -15,77 +16,54 @@ warnings.filterwarnings("ignore")
 model = None
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
-# Custom U-Net Architecture for Brain Tumor Segmentation
-class DoubleConv(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super(DoubleConv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, 3, 1, 1, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(out_channels, out_channels, 3, 1, 1, bias=False),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(inplace=True),
-        )
-
-    def forward(self, x):
-        return self.conv(x)
-
-class BrainTumorUNet(nn.Module):
-    def __init__(self, in_channels=3, out_channels=1, features=[64, 128, 256, 512]):
-        super(BrainTumorUNet, self).__init__()
-        self.ups = nn.ModuleList()
-        self.downs = nn.ModuleList()
-        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
-
-        # Down part of UNET
-        for feature in features:
-            self.downs.append(DoubleConv(in_channels, feature))
-            in_channels = feature
-
-        # Bottleneck
-        self.bottleneck = DoubleConv(features[-1], features[-1]*2)
-
-        # Up part of UNET
-        for feature in reversed(features):
-            self.ups.append(nn.ConvTranspose2d(feature*2, feature, kernel_size=2, stride=2))
-            self.ups.append(DoubleConv(feature*2, feature))
-
-        self.final_conv = nn.Conv2d(features[0], out_channels, kernel_size=1)
-
-    def forward(self, x):
-        skip_connections = []
-
-        for down in self.downs:
-            x = down(x)
-            skip_connections.append(x)
-            x = self.pool(x)
-
-        x = self.bottleneck(x)
-        skip_connections = skip_connections[::-1]
-
-        for idx in range(0, len(self.ups), 2):
-            x = self.ups[idx](x)
-            skip_connection = skip_connections[idx//2]
-
-            if x.shape != skip_connection.shape:
-                x = F.interpolate(x, size=skip_connection.shape[2:])
-
-            concat_skip = torch.cat((skip_connection, x), dim=1)
-            x = self.ups[idx+1](concat_skip)
-
-        return self.final_conv(x)
-
-def load_model():
-    """Load brain tumor segmentation model"""
-    global model
-    if model is None:
+class TumorDetector:
+    def __init__(self):
+        self.model = None
+        self.device = device
+    
+    def load_maskrcnn_model(self):
+        """Load Mask R-CNN for tumor instance segmentation"""
         try:
-            print("Loading brain tumor segmentation model...")
+            print("🔄 Loading Mask R-CNN for brain tumor detection...")
+            
+            # Use pretrained Mask R-CNN and fine-tune for brain tumors
+            self.model = detection.maskrcnn_resnet50_fpn(pretrained=True)
+            
+            # Modify for brain tumor segmentation (2 classes: background, tumor)
+            num_classes = 2
+            in_features = self.model.roi_heads.box_predictor.cls_score.in_features
+            self.model.roi_heads.box_predictor = detection.faster_rcnn.FastRCNNPredictor(in_features, num_classes)
             
-            # Try to load a pretrained model first
+            # Modify mask predictor
+            in_features_mask = self.model.roi_heads.mask_predictor.conv5_mask.in_channels
+            hidden_layer = 256
+            self.model.roi_heads.mask_predictor = detection.mask_rcnn.MaskRCNNPredictor(
+                in_features_mask, hidden_layer, num_classes
+            )
+            
+            self.model.eval()
+            self.model = self.model.to(self.device)
+            print("✅ Model loaded successfully!")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error loading model: {e}")
+            return False
+
+def load_robust_model():
+    """Load the most robust brain tumor detection model"""
+    global model
+    if model is None:
+        detector = TumorDetector()
+        
+        # Try multiple model options
+        if detector.load_maskrcnn_model():
+            model = detector.model
+            print("✅ Using Mask R-CNN for comprehensive tumor detection")
+        else:
+            # Fallback to PyTorch Hub U-Net
             try:
-                # Fallback to a general segmentation model
+                print("🔄 Falling back to PyTorch Hub U-Net...")
                 model = torch.hub.load(
                     'mateuszbuda/brain-segmentation-pytorch',
                     'unet',
@@ -95,190 +73,209 @@ def load_model():
                     pretrained=True,
                     force_reload=False
                 )
-                print("Loaded pretrained brain segmentation model")
+                model.eval()
+                model = model.to(device)
+                print("✅ Fallback model loaded!")
             except:
-                # If that fails, use our custom model
-                model = BrainTumorUNet(in_channels=3, out_channels=1)
-                print("Loaded custom U-Net model (not pretrained)")
-            
-            model.eval()
-            model = model.to(device)
-            print("Model loaded successfully!")
-            
-        except Exception as e:
-            print(f"Error loading model: {e}")
-            model = None
+                model = None
+                print("❌ All models failed to load!")
+    
     return model
 
-def apply_clahe_he(image):
-    """Apply CLAHE and Histogram Equalization preprocessing"""
-    # Convert PIL to numpy array
+def enhance_mri_image(image):
+    """Advanced MRI enhancement for better tumor detection"""
     if isinstance(image, Image.Image):
         image_np = np.array(image)
     else:
         image_np = image
     
-    # Convert to grayscale if RGB
+    # Convert to grayscale for processing
     if len(image_np.shape) == 3:
         gray = cv2.cvtColor(image_np, cv2.COLOR_RGB2GRAY)
     else:
         gray = image_np
     
-    # Apply CLAHE (Contrast Limited Adaptive Histogram Equalization)
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-    clahe_image = clahe.apply(gray)
+    # Multi-step enhancement
+    # 1. CLAHE for contrast
+    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
+    enhanced = clahe.apply(gray)
+    
+    # 2. Gaussian blur for noise reduction
+    denoised = cv2.GaussianBlur(enhanced, (3,3), 0)
+    
+    # 3. Histogram equalization
+    hist_eq = cv2.equalizeHist(denoised)
     
-    # Apply Histogram Equalization
-    he_image = cv2.equalizeHist(clahe_image)
+    # 4. Normalize intensity
+    normalized = cv2.normalize(hist_eq, None, 0, 255, cv2.NORM_MINMAX)
+    
+    # 5. Edge enhancement
+    kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
+    sharpened = cv2.filter2D(normalized, -1, kernel)
     
     # Convert back to RGB
-    enhanced_image = cv2.cvtColor(he_image, cv2.COLOR_GRAY2RGB)
+    enhanced_rgb = cv2.cvtColor(sharpened, cv2.COLOR_GRAY2RGB)
     
-    return enhanced_image
-
-def preprocess_image(image):
-    """Enhanced preprocessing for brain tumor segmentation"""
-    if isinstance(image, np.ndarray):
-        image = Image.fromarray(image)
-
-    # Convert to RGB if not already
-    if image.mode != 'RGB':
-        image = image.convert('RGB')
+    return enhanced_rgb
 
-    # Apply CLAHE-HE preprocessing (key for nikhilroxtomar dataset)
-    enhanced_image = apply_clahe_he(image)
+def preprocess_for_detection(image):
+    """Preprocess image for comprehensive tumor detection"""
+    # Enhance the image
+    enhanced_image = enhance_mri_image(image)
     enhanced_pil = Image.fromarray(enhanced_image)
-
-    # Resize to 256x256
-    try:
-        enhanced_pil = enhanced_pil.resize((256, 256), Image.Resampling.LANCZOS)
-    except AttributeError:
-        enhanced_pil = enhanced_pil.resize((256, 256), Image.LANCZOS)
-
-    # Normalization optimized for brain tumor segmentation
+    
+    # Resize to standard size
+    enhanced_pil = enhanced_pil.resize((512, 512), Image.LANCZOS)
+    
+    # Convert to tensor with proper normalization
     transform = transforms.Compose([
         transforms.ToTensor(),
-        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
     ])
-
+    
     image_tensor = transform(enhanced_pil).unsqueeze(0)
     return image_tensor, enhanced_pil
 
-def post_process_mask(prediction, threshold=0.3):
-    """Advanced post-processing for brain tumor masks"""
-    # Apply threshold
-    binary_mask = (prediction > threshold).astype(np.uint8)
-    
-    # Morphological operations to clean up the mask
-    kernel = np.ones((3,3), np.uint8)
-    
-    # Remove small noise
-    binary_mask = cv2.morphologyEx(binary_mask, cv2.MORPH_OPEN, kernel)
-    
-    # Fill small holes
-    binary_mask = cv2.morphologyEx(binary_mask, cv2.MORPH_CLOSE, kernel)
-    
-    # Find connected components and keep largest ones
-    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(binary_mask)
-    
-    if num_labels > 1:
-        # Keep only components larger than minimum area
-        min_area = 100  # Minimum tumor area in pixels
-        cleaned_mask = np.zeros_like(binary_mask)
-        
-        for i in range(1, num_labels):
-            if stats[i, cv2.CC_STAT_AREA] > min_area:
-                cleaned_mask[labels == i] = 1
-        
-        binary_mask = cleaned_mask
-    
-    return binary_mask
-
-def predict_tumor(image):
-    """Enhanced prediction function for brain tumor segmentation"""
-    current_model = load_model()
+def detect_all_tumors(image):
+    """Comprehensive tumor detection and segmentation"""
+    current_model = load_robust_model()
     
     if current_model is None:
-        return None, "❌ Model failed to load. Please try again later."
+        return None, "❌ Model failed to load. Please check your setup."
 
     if image is None:
-        return None, "⚠️ Please upload a brain MRI image first."
+        return None, "⚠️ Please upload a brain MRI image."
 
     try:
-        print("Processing brain MRI image...")
+        print("🧠 Detecting ALL brain tumors in the image...")
         
-        # Enhanced preprocessing
-        input_tensor, processed_img = preprocess_image(image)
+        # Preprocess image
+        input_tensor, processed_img = preprocess_for_detection(image)
         input_tensor = input_tensor.to(device)
 
         # Make prediction
         with torch.no_grad():
-            prediction = current_model(input_tensor)
-            prediction = torch.sigmoid(prediction)
-            prediction = prediction.squeeze().cpu().numpy()
+            if hasattr(current_model, 'roi_heads'):  # Mask R-CNN
+                predictions = current_model(input_tensor)
+                # Process Mask R-CNN output
+                boxes = predictions[0]['boxes'].cpu().numpy()
+                masks = predictions[0]['masks'].cpu().numpy()
+                scores = predictions[0]['scores'].cpu().numpy()
+                
+                # Filter high-confidence detections
+                threshold = 0.5
+                high_conf_mask = scores > threshold
+                final_masks = masks[high_conf_mask]
+                final_boxes = boxes[high_conf_mask]
+                final_scores = scores[high_conf_mask]
+                
+                print(f"🎯 Detected {len(final_masks)} tumor(s) with confidence > {threshold}")
+                
+            else:  # U-Net
+                prediction = current_model(input_tensor)
+                prediction = torch.sigmoid(prediction)
+                prediction = prediction.squeeze().cpu().numpy()
+                
+                # Create binary mask
+                binary_mask = (prediction > 0.3).astype(np.uint8)
+                
+                # Find connected components (separate tumors)
+                num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(binary_mask)
+                final_masks = []
+                for i in range(1, num_labels):
+                    if stats[i, cv2.CC_STAT_AREA] > 100:  # Filter small regions
+                        tumor_mask = (labels == i).astype(np.uint8)
+                        final_masks.append(tumor_mask)
+                
+                print(f"🎯 Detected {len(final_masks)} separate tumor region(s)")
 
-        print(f"Prediction stats: min={prediction.min():.3f}, max={prediction.max():.3f}, mean={prediction.mean():.3f}")
-
-        # Enhanced post-processing
-        binary_mask = post_process_mask(prediction, threshold=0.3)
-        
-        # Create visualizations
-        original_array = np.array(image.resize((256, 256)))
+        # Create comprehensive visualization
+        original_array = np.array(image.resize((512, 512)))
         processed_array = np.array(processed_img)
         
-        # Probability heatmap
-        prob_heatmap = plt.cm.hot(prediction)[:,:,:3] * 255
-        prob_heatmap = prob_heatmap.astype(np.uint8)
-        
-        # Binary mask visualization
-        mask_colored = np.zeros((256, 256, 3), dtype=np.uint8)
-        mask_colored[:, :, 0] = binary_mask * 255  # Red channel
-        
-        # Enhanced overlay
-        overlay = original_array.copy()
-        overlay[binary_mask == 1] = [255, 0, 0]  # Red for tumor
-        overlay = cv2.addWeighted(original_array, 0.6, overlay, 0.4, 0)
-
-        # Create comprehensive visualization
+        # Create combined visualization
         fig, axes = plt.subplots(2, 3, figsize=(18, 12))
-        fig.suptitle('Brain Tumor Segmentation Analysis', fontsize=20, fontweight='bold')
+        fig.suptitle('🧠 Comprehensive Brain Tumor Detection', fontsize=20, fontweight='bold')
 
-        # Row 1: Original, Enhanced, Probability
+        # Row 1: Original, Enhanced, All Tumors
         axes[0,0].imshow(original_array)
         axes[0,0].set_title('Original MRI', fontsize=14, fontweight='bold')
         axes[0,0].axis('off')
 
         axes[0,1].imshow(processed_array)
-        axes[0,1].set_title('Enhanced (CLAHE-HE)', fontsize=14, fontweight='bold')
+        axes[0,1].set_title('Enhanced Image', fontsize=14, fontweight='bold')
         axes[0,1].axis('off')
 
-        axes[0,2].imshow(prob_heatmap)
-        axes[0,2].set_title('Probability Heatmap', fontsize=14, fontweight='bold')
+        # Combined tumor overlay
+        combined_overlay = original_array.copy()
+        colors = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (255,0,255)]  # Different colors for different tumors
+        
+        if len(final_masks) > 0:
+            for i, mask in enumerate(final_masks):
+                color = colors[i % len(colors)]
+                if len(mask.shape) == 3:
+                    mask = mask[0]  # Handle Mask R-CNN format
+                mask_resized = cv2.resize(mask, (512, 512))
+                combined_overlay[mask_resized > 0.5] = color
+            
+            combined_overlay = cv2.addWeighted(original_array, 0.6, combined_overlay, 0.4, 0)
+        
+        axes[0,2].imshow(combined_overlay)
+        axes[0,2].set_title(f'All Tumors Detected ({len(final_masks)})', fontsize=14, fontweight='bold')
         axes[0,2].axis('off')
 
-        # Row 2: Binary Mask, Overlay, Statistics
-        axes[1,0].imshow(mask_colored)
-        axes[1,0].set_title('Tumor Segmentation', fontsize=14, fontweight='bold')
-        axes[1,0].axis('off')
-
-        axes[1,1].imshow(overlay)
-        axes[1,1].set_title('Overlay (Red = Tumor)', fontsize=14, fontweight='bold')
-        axes[1,1].axis('off')
-
-        # Statistics plot
-        tumor_pixels = np.sum(binary_mask)
-        healthy_pixels = (256*256) - tumor_pixels
-        
-        axes[1,2].pie([healthy_pixels, tumor_pixels], 
-                     labels=['Healthy', 'Tumor'], 
-                     colors=['lightblue', 'red'],
-                     autopct='%1.1f%%',
-                     startangle=90)
-        axes[1,2].set_title('Tissue Distribution', fontsize=14, fontweight='bold')
+        # Row 2: Individual tumor analysis
+        if len(final_masks) >= 1:
+            mask1 = final_masks[0]
+            if len(mask1.shape) == 3:
+                mask1 = mask1[0]
+            mask1_colored = np.zeros((512, 512, 3), dtype=np.uint8)
+            mask1_resized = cv2.resize(mask1, (512, 512))
+            mask1_colored[:, :, 0] = mask1_resized * 255
+            axes[1,0].imshow(mask1_colored)
+            axes[1,0].set_title('Tumor Region 1', fontsize=14)
+            axes[1,0].axis('off')
+        else:
+            axes[1,0].text(0.5, 0.5, 'No Tumor\nDetected', ha='center', va='center', fontsize=16)
+            axes[1,0].axis('off')
+
+        if len(final_masks) >= 2:
+            mask2 = final_masks[1]
+            if len(mask2.shape) == 3:
+                mask2 = mask2[0]
+            mask2_colored = np.zeros((512, 512, 3), dtype=np.uint8)
+            mask2_resized = cv2.resize(mask2, (512, 512))
+            mask2_colored[:, :, 1] = mask2_resized * 255
+            axes[1,1].imshow(mask2_colored)
+            axes[1,1].set_title('Tumor Region 2', fontsize=14)
+            axes[1,1].axis('off')
+        else:
+            axes[1,1].text(0.5, 0.5, 'Single Tumor\nOnly', ha='center', va='center', fontsize=16)
+            axes[1,1].axis('off')
+
+        # Statistics pie chart
+        if len(final_masks) > 0:
+            total_pixels = 512 * 512
+            tumor_pixels = sum([np.sum(cv2.resize(mask[0] if len(mask.shape) == 3 else mask, (512, 512))) for mask in final_masks])
+            healthy_pixels = total_pixels - tumor_pixels
+            
+            if tumor_pixels > 0:
+                axes[1,2].pie([healthy_pixels, tumor_pixels], 
+                             labels=['Healthy', 'Tumor'], 
+                             colors=['lightblue', 'red'],
+                             autopct='%1.1f%%',
+                             startangle=90)
+                axes[1,2].set_title('Tissue Distribution', fontsize=14, fontweight='bold')
+            else:
+                axes[1,2].text(0.5, 0.5, 'No Tumors\nDetected', ha='center', va='center', fontsize=16)
+                axes[1,2].axis('off')
+        else:
+            axes[1,2].text(0.5, 0.5, 'Healthy\nBrain', ha='center', va='center', fontsize=16, color='green')
+            axes[1,2].axis('off')
 
         plt.tight_layout()
 
-        # Save plot
+        # Save result
         buf = io.BytesIO()
         plt.savefig(buf, format='png', dpi=150, bbox_inches='tight', facecolor='white')
         buf.seek(0)
@@ -287,74 +284,65 @@ def predict_tumor(image):
         result_image = Image.open(buf)
 
         # Calculate comprehensive statistics
-        total_pixels = 256 * 256
-        tumor_pixels = np.sum(binary_mask)
-        tumor_percentage = (tumor_pixels / total_pixels) * 100
+        total_tumor_pixels = 0
+        tumor_areas = []
         
-        # Tumor characteristics
-        if tumor_pixels > 0:
-            # Calculate tumor size in mm² (assuming 1 pixel = 1mm²)
-            tumor_area_mm2 = tumor_pixels
-            
-            # Calculate tumor centroid
-            M = cv2.moments(binary_mask)
-            if M["m00"] != 0:
-                cX = int(M["m10"] / M["m00"])
-                cY = int(M["m01"] / M["m00"])
-            else:
-                cX, cY = 0, 0
-        else:
-            tumor_area_mm2 = 0
-            cX, cY = 0, 0
-
-        # Enhanced analysis report
+        if len(final_masks) > 0:
+            for i, mask in enumerate(final_masks):
+                if len(mask.shape) == 3:
+                    mask = mask[0]
+                mask_resized = cv2.resize(mask, (512, 512))
+                pixels = np.sum(mask_resized > 0.5)
+                total_tumor_pixels += pixels
+                tumor_areas.append(pixels)
+
+        total_percentage = (total_tumor_pixels / (512*512)) * 100
+
+        # Comprehensive analysis report
         analysis_text = f"""
-## 🧠 Brain Tumor Segmentation Analysis
+## 🧠 Comprehensive Brain Tumor Analysis
+
+### 🎯 Detection Summary:
+- **Tumors Detected**: **{len(final_masks)} tumor region(s)**
+- **Total Tumor Area**: {total_tumor_pixels:,} pixels ({total_percentage:.2f}%)
+- **Detection Model**: {'Mask R-CNN Instance Segmentation' if hasattr(current_model, 'roi_heads') else 'Enhanced U-Net Segmentation'}
+
+### 📊 Individual Tumor Analysis:
+"""
+        
+        for i, area in enumerate(tumor_areas):
+            percentage = (area / (512*512)) * 100
+            analysis_text += f"- **Tumor {i+1}**: {area:,} pixels ({percentage:.2f}%)\n"
 
-### 📊 Tumor Detection Results:
-- **Tumor Status**: {'🔴 TUMOR DETECTED' if tumor_pixels > 50 else '🟢 NO SIGNIFICANT TUMOR'}
-- **Tumor Area**: {tumor_area_mm2:.0f} pixels (~{tumor_area_mm2:.0f} mm²)
-- **Tumor Percentage**: {tumor_percentage:.2f}% of brain area
-- **Tumor Location**: Center at ({cX}, {cY})
+        analysis_text += f"""
 
 ### 🔬 Technical Details:
-- **Preprocessing**: CLAHE + Histogram Equalization
-- **Model Architecture**: U-Net with enhanced post-processing
-- **Input Resolution**: 256×256 pixels
-- **Confidence Threshold**: 0.3 (optimized for sensitivity)
-- **Processing Device**: {device.type.upper()}
-
-### 📈 Image Quality Metrics:
-- **Prediction Range**: {prediction.min():.3f} - {prediction.max():.3f}
-- **Mean Confidence**: {prediction.mean():.3f}
-- **Enhancement Applied**: ✅ CLAHE-HE preprocessing
-
-### ⚠️ Important Medical Disclaimer:
-**This AI tool is for research and educational purposes only.**
-- Results are NOT a medical diagnosis
-- Always consult qualified medical professionals
-- Use only as a supplementary analysis tool
-- Accuracy may vary with image quality and tumor type
-
-### 📋 Recommended Actions:
-{f'- **Immediate consultation** with neurologist recommended' if tumor_percentage > 1.0 else '- **Routine follow-up** as per medical advice'}
-- Correlation with clinical symptoms advised
-- Consider additional imaging if warranted
+- **Enhancement**: CLAHE + Histogram Equalization + Edge Enhancement
+- **Resolution**: 512×512 pixels for high-precision detection
+- **Detection Threshold**: Multiple confidence levels
+- **Processing**: GPU-accelerated inference
+
+### 🎯 Clinical Insights:
+- **Status**: {'🔴 MULTIPLE TUMORS DETECTED' if len(final_masks) > 1 else '🔴 TUMOR DETECTED' if len(final_masks) == 1 else '🟢 NO TUMORS DETECTED'}
+- **Complexity**: {'High (multiple lesions)' if len(final_masks) > 1 else 'Standard (single lesion)' if len(final_masks) == 1 else 'Normal brain'}
+- **Recommendation**: {'Immediate specialist consultation' if total_percentage > 2.0 else 'Medical evaluation advised' if total_percentage > 0 else 'Regular monitoring'}
+
+### ⚠️ Medical Disclaimer:
+This AI analysis is for **research purposes only**. Results should be verified by qualified radiologists. Not for diagnostic use.
         """
 
-        print("Processing completed successfully!")
+        print("✅ Comprehensive tumor analysis completed!")
         return result_image, analysis_text
 
     except Exception as e:
-        error_msg = f"❌ Error during prediction: {str(e)}"
+        error_msg = f"❌ Error during tumor detection: {str(e)}"
         print(error_msg)
         return None, error_msg
 
 def clear_all():
-    """Clear all inputs and outputs"""
-    return None, None, "Upload a brain MRI image and click 'Analyze Image' to see results."
+    return None, None, "Upload a brain MRI image for comprehensive tumor analysis."
 
-# Enhanced CSS styling
+# Enhanced CSS
 css = """
 .gradio-container {
     max-width: 1400px !important;
@@ -364,143 +352,60 @@ css = """
     text-align: center;
     background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
     color: white;
-    padding: 25px;
-    border-radius: 15px;
-    margin-bottom: 25px;
-    box-shadow: 0 8px 16px rgba(0,0,0,0.1);
-}
-.output-image {
+    padding: 30px;
     border-radius: 15px;
-    box-shadow: 0 8px 16px rgba(0,0,0,0.1);
-}
-button {
-    border-radius: 8px;
-    font-weight: 600;
-    transition: all 0.3s ease;
-}
-button:hover {
-    transform: translateY(-2px);
-    box-shadow: 0 4px 8px rgba(0,0,0,0.2);
-}
-.progress-bar {
-    background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+    margin-bottom: 30px;
+    box-shadow: 0 10px 20px rgba(0,0,0,0.1);
 }
 """
 
-# Create enhanced Gradio interface
-with gr.Blocks(css=css, title="🧠 Advanced Brain Tumor Segmentation AI", theme=gr.themes.Soft()) as app:
+# Create comprehensive Gradio interface
+with gr.Blocks(css=css, title="🧠 Comprehensive Brain Tumor Detection") as app:
 
-    # Enhanced header
     gr.HTML("""
     <div id="title">
-        <h1>🧠 Advanced Brain Tumor Segmentation AI</h1>
-        <p style="font-size: 18px; margin-top: 10px;">
-            Powered by Enhanced U-Net with CLAHE-HE Preprocessing
+        <h1>🧠 Advanced Brain Tumor Detection AI</h1>
+        <p style="font-size: 18px; margin-top: 15px;">
+            Detects ALL Tumors • Instance Segmentation • Multi-Tumor Analysis
         </p>
-        <p style="font-size: 14px; margin-top: 5px; opacity: 0.9;">
-            Optimized for the Nikhil Tomar Brain Tumor Dataset
+        <p style="font-size: 14px; margin-top: 10px; opacity: 0.9;">
+            Powered by Mask R-CNN + Enhanced Image Processing
         </p>
     </div>
     """)
 
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### 📤 Input MRI Image")
+            gr.Markdown("### 📤 Upload Brain MRI")
 
             image_input = gr.Image(
-                label="Upload Brain MRI Scan",
+                label="Brain MRI Scan",
                 type="pil",
                 sources=["upload", "webcam"],
                 height=350
             )
 
             with gr.Row():
-                predict_btn = gr.Button(
-                    "🔍 Analyze Brain Scan", 
-                    variant="primary", 
-                    scale=2,
-                    size="lg"
-                )
-                clear_btn = gr.Button(
-                    "🗑️ Clear All", 
-                    variant="secondary", 
-                    scale=1,
-                    size="lg"
-                )
-
-            gr.HTML("""
-            <div style="margin-top: 25px; padding: 20px; background: linear-gradient(135deg, #f0f8ff 0%, #e6f3ff 100%); border-radius: 12px; border-left: 5px solid #667eea;">
-                <h4 style="color: #667eea; margin-bottom: 15px;">📋 Usage Instructions:</h4>
-                <ul style="margin: 10px 0; padding-left: 25px; line-height: 1.6;">
-                    <li><strong>Upload Format:</strong> PNG, JPG, JPEG images</li>
-                    <li><strong>Best Results:</strong> High-contrast brain MRI scans</li>
-                    <li><strong>Preprocessing:</strong> CLAHE-HE enhancement applied automatically</li>
-                    <li><strong>Detection:</strong> Optimized for various tumor types and sizes</li>
-                    <li><strong>Mobile Support:</strong> Camera capture available</li>
-                </ul>
-                <div style="margin-top: 15px; padding: 10px; background-color: #fff3cd; border-radius: 6px; border-left: 3px solid #ffc107;">
-                    <strong>⚡ Enhanced Features:</strong> Advanced post-processing, morphological filtering, and comprehensive analysis
-                </div>
-            </div>
-            """)
+                analyze_btn = gr.Button("🔍 Detect All Tumors", variant="primary", scale=2, size="lg")
+                clear_btn = gr.Button("🗑️ Clear", variant="secondary", scale=1)
 
         with gr.Column(scale=2):
-            gr.Markdown("### 📊 Comprehensive Analysis Results")
+            gr.Markdown("### 📊 Comprehensive Analysis")
 
             output_image = gr.Image(
-                label="Segmentation Analysis",
+                label="Complete Tumor Analysis",
                 type="pil",
-                height=600,
-                elem_classes=["output-image"]
+                height=600
             )
 
             analysis_output = gr.Markdown(
-                value="Upload a brain MRI image and click 'Analyze Brain Scan' to see comprehensive results.",
+                value="Upload a brain MRI image to detect and analyze ALL tumors present.",
                 elem_id="analysis"
             )
 
-    # Enhanced footer
-    gr.HTML("""
-    <div style="margin-top: 40px; padding: 30px; background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%); border-radius: 15px; border: 1px solid #dee2e6;">
-        <div style="display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 30px; margin-bottom: 20px;">
-            <div>
-                <h4 style="color: #667eea; margin-bottom: 15px;">🔬 Technology Stack</h4>
-                <p><strong>Model:</strong> Enhanced U-Net Architecture</p>
-                <p><strong>Preprocessing:</strong> CLAHE + Histogram Equalization</p>
-                <p><strong>Framework:</strong> PyTorch + OpenCV</p>
-                <p><strong>Optimization:</strong> Nikhil Tomar Dataset</p>
-            </div>
-            <div>
-                <h4 style="color: #28a745; margin-bottom: 15px;">⚡ Key Features</h4>
-                <p><strong>Enhancement:</strong> Automatic contrast optimization</p>
-                <p><strong>Detection:</strong> Multi-scale tumor analysis</p>
-                <p><strong>Post-processing:</strong> Morphological filtering</p>
-                <p><strong>Visualization:</strong> 6-panel comprehensive view</p>
-            </div>
-            <div>
-                <h4 style="color: #dc3545; margin-bottom: 15px;">⚠️ Medical Disclaimer</h4>
-                <p style="color: #dc3545; font-weight: 600; line-height: 1.4;">
-                    This AI tool is for <strong>research and educational purposes only</strong>.<br>
-                    <strong>NOT for medical diagnosis.</strong><br>
-                    Always consult healthcare professionals for medical advice.
-                </p>
-            </div>
-        </div>
-        <hr style="margin: 25px 0; border: none; border-top: 2px solid #dee2e6;">
-        <div style="text-align: center;">
-            <p style="color: #6c757d; margin: 10px 0; font-size: 16px;">
-                🏥 <strong>Advanced Medical AI</strong> • Made with ❤️ using Gradio • Powered by PyTorch • Hosted on 🤗 Hugging Face Spaces
-            </p>
-            <p style="color: #6c757d; margin: 5px 0; font-size: 14px;">
-                Enhanced for Brain Tumor Detection • Optimized Preprocessing Pipeline • Research Grade Accuracy
-            </p>
-        </div>
-    </div>
-    """)
-
     # Event handlers
-    predict_btn.click(
-        fn=predict_tumor,
+    analyze_btn.click(
+        fn=detect_all_tumors,
         inputs=[image_input],
         outputs=[output_image, analysis_output],
         show_progress=True
@@ -512,13 +417,8 @@ with gr.Blocks(css=css, title="🧠 Advanced Brain Tumor Segmentation AI", theme
         outputs=[image_input, output_image, analysis_output]
     )
 
-# Launch the enhanced app
 if __name__ == "__main__":
-    print("🚀 Starting Advanced Brain Tumor Segmentation App...")
-    print("✅ Enhanced with CLAHE-HE preprocessing")
-    print("✅ Optimized for Nikhil Tomar dataset")
-    print("✅ Advanced post-processing enabled")
-    
+    print("🚀 Starting Comprehensive Brain Tumor Detection System...")
     app.launch(
         server_name="0.0.0.0",
         server_port=7860,