Update app.py

app.py

@@ -2,177 +2,184 @@ import cv2
 import numpy as np
 import pandas as pd
 import gradio as gr
-from skimage import measure, morphology
+from skimage import morphology, segmentation
 import matplotlib.pyplot as plt
 from datetime import datetime
 
-def detect_blood_cells(image):
-    """Specialized function for blood cell detection"""
-    # Convert to RGB if grayscale
-    if len(image.shape) == 2:
-        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
-    
-    # Convert to HSV color space
-    hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
-    
-    # Create mask for red blood cells
-    # Red color has two ranges in HSV
-    lower_red1 = np.array([0, 70, 50])
-    upper_red1 = np.array([10, 255, 255])
-    lower_red2 = np.array([170, 70, 50])
-    upper_red2 = np.array([180, 255, 255])
-    
-    mask1 = cv2.inRange(hsv, lower_red1, upper_red1)
-    mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
-    mask = mask1 + mask2
-    
-    # Noise removal and smoothing
-    kernel = np.ones((3,3), np.uint8)
-    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=2)
-    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=2)
-    
-    # Find contours
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    
-    return contours, mask
+def enhanced_preprocessing(image):
+    """Advanced image preprocessing pipeline"""
+    # Convert to LAB color space for better color separation
+    lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
+    
+    # CLAHE on L-channel
+    l_channel = lab[:,:,0]
+    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
+    lab[:,:,0] = clahe.apply(l_channel)
+    
+    # Convert back to RGB
+    enhanced = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
+    
+    # Edge-preserving smoothing
+    filtered = cv2.bilateralFilter(enhanced, 9, 75, 75)
+    
+    return filtered
+
+def detect_cells(image):
+    """Advanced cell detection using multiple techniques"""
+    # Enhanced preprocessing
+    processed = enhanced_preprocessing(image)
+    
+    # Convert to grayscale
+    gray = cv2.cvtColor(processed, cv2.COLOR_RGB2GRAY)
+    
+    # Adaptive thresholding
+    binary = cv2.adaptiveThreshold(gray, 255, 
+                                  cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                                  cv2.THRESH_BINARY_INV, 21, 4)
+    
+    # Morphological operations
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))
+    cleaned = morphology.area_opening(binary, area_threshold=128)
+    cleaned = cv2.morphologyEx(cleaned, cv2.MORPH_CLOSE, kernel, iterations=2)
+    
+    # Watershed segmentation for overlapping cells
+    distance = cv2.distanceTransform(cleaned, cv2.DIST_L2, 3)
+    _, sure_fg = cv2.threshold(distance, 0.5*distance.max(), 255, 0)
+    sure_fg = np.uint8(sure_fg)
+    
+    # Marker labeling
+    _, markers = cv2.connectedComponents(sure_fg)
+    markers += 1  # Add one to all labels
+    markers[cleaned == 0] = 0  # Set background to 0
+    
+    # Apply watershed
+    segmented = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    markers = segmentation.watershed(segmented, markers)
+    
+    # Find contours from markers
+    contours = []
+    for label in np.unique(markers):
+        if label < 1:  # Skip background
+            continue
+        mask = np.zeros(gray.shape, dtype="uint8")
+        mask[markers == label] = 255
+        cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        contours.extend(cnts)
+    
+    return contours, cleaned
+
+def feature_analysis(contours, image):
+    """Comprehensive feature extraction and validation"""
+    features = []
+    for i, contour in enumerate(contours, 1):
+        area = cv2.contourArea(contour)
+        perimeter = cv2.arcLength(contour, True)
+        
+        # Improved circularity calculation
+        circularity = (4 * np.pi * area) / (perimeter**2 + 1e-6)
+        
+        # Advanced shape validation
+        if 50 < area < 10000 and 0.4 < circularity < 1.2:
+            M = cv2.moments(contour)
+            if M["m00"] != 0:
+                cx = int(M["m10"] / M["m00"])
+                cy = int(M["m01"] / M["m00"])
+                
+                # Convexity check
+                hull = cv2.convexHull(contour)
+                hull_area = cv2.contourArea(hull)
+                convexity = area / hull_area if hull_area > 0 else 0
+                
+                features.append({
+                    'Cell ID': i,
+                    'Area (px²)': area,
+                    'Perimeter (px)': perimeter,
+                    'Circularity': round(circularity, 3),
+                    'Convexity': round(convexity, 3),
+                    'Centroid X': cx,
+                    'Centroid Y': cy
+                })
+    
+    return features
 
-def apply_color_transformation(image, transform_type):
-    """Apply different color transformations to the image"""
-    if len(image.shape) == 2:
-        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
-    
-    if transform_type == "Original":
-        return image
-    elif transform_type == "Grayscale":
-        return cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-    elif transform_type == "Binary":
-        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-        _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
-        return binary
-    elif transform_type == "CLAHE":
-        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
-        return clahe.apply(gray)
-    return image
+def visualize_results(image, contours, features):
+    """Enhanced visualization with better annotations"""
+    vis_img = image.copy()
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    # Draw refined contours
+    for idx, feature in enumerate(features):
+        contour = contours[idx]
+        cv2.drawContours(vis_img, [contour], -1, (0, 255, 0), 2)
+        
+        # Improved annotation placement
+        x, y = feature['Centroid X'], feature['Centroid Y']
+        cv2.putText(vis_img, str(feature['Cell ID']), 
+                   (x+5, y-5), cv2.FONT_HERSHEY_SIMPLEX, 
+                   0.6, (255, 255, 255), 3)
+        cv2.putText(vis_img, str(feature['Cell ID']), 
+                   (x+5, y-5), cv2.FONT_HERSHEY_SIMPLEX, 
+                   0.6, (0, 0, 255), 2)
+    
+    # Add enhanced overlay
+    cv2.putText(vis_img, f"Cells Detected: {len(features)} | {timestamp}", 
+               (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
+               0.7, (0, 0, 0), 3)
+    cv2.putText(vis_img, f"Cells Detected: {len(features)} | {timestamp}", 
+               (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
+               0.7, (255, 255, 255), 2)
+    
+    return vis_img
 
 def process_image(image, transform_type):
-    """Process uploaded image and extract blood cell features"""
+    """Upgraded image processing pipeline"""
     if image is None:
         return None, None, None, None
     
     try:
-        # Store original image for transformations
-        original_image = image.copy()
-        
-        # Detect blood cells
-        contours, mask = detect_blood_cells(image)
-        
-        # Extract features
-        features = []
-        for i, contour in enumerate(contours, 1):
-            area = cv2.contourArea(contour)
-            # Filter out very small or very large regions
-            if 100 < area < 5000:  # Adjust these thresholds based on your images
-                perimeter = cv2.arcLength(contour, True)
-                circularity = 4 * np.pi * area / (perimeter * perimeter) if perimeter > 0 else 0
-                
-                # Only include if it's reasonably circular
-                if circularity > 0.7:  # Adjust threshold as needed
-                    M = cv2.moments(contour)
-                    if M["m00"] != 0:
-                        cx = int(M["m10"] / M["m00"])
-                        cy = int(M["m01"] / M["m00"])
-                        
-                        features.append({
-                            'label': i,
-                            'area': area,
-                            'perimeter': perimeter,
-                            'circularity': circularity,
-                            'centroid_x': cx,
-                            'centroid_y': cy
-                        })
+        original = image.copy()
+        contours, mask = detect_cells(image)
+        features = feature_analysis(contours, image)
+        vis_img = visualize_results(image, contours, features)
         
-        # Create visualization
-        vis_img = image.copy()
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
-        # Draw contours and labels
-        for feature in features:
-            contour = contours[feature['label']-1]
-            cv2.drawContours(vis_img, [contour], -1, (0, 255, 0), 2)
-            
-            # Add cell labels
-            x = feature['centroid_x']
-            y = feature['centroid_y']
-            # White outline
-            cv2.putText(vis_img, str(feature['label']), 
-                       (x, y), cv2.FONT_HERSHEY_SIMPLEX, 
-                       0.5, (255, 255, 255), 2)
-            # Red text
-            cv2.putText(vis_img, str(feature['label']), 
-                       (x, y), cv2.FONT_HERSHEY_SIMPLEX, 
-                       0.5, (0, 0, 255), 1)
-        
-        # Add timestamp and cell count
-        cv2.putText(vis_img, f"Analyzed: {timestamp} | Cells: {len(features)}", 
-                    (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
-                    0.7, (255, 255, 255), 2)
-        
-        # Create analysis plots with default style
-        plt.style.use('default')
-        fig, axes = plt.subplots(2, 2, figsize=(15, 12))
-        fig.suptitle('Blood Cell Analysis Results', fontsize=16, y=0.95)
+        # Create analysis plots
+        plt.style.use('seaborn-v0_8')
+        fig, ax = plt.subplots(2, 2, figsize=(15, 12))
+        fig.suptitle('Advanced Cell Analysis', fontsize=16)
         
         df = pd.DataFrame(features)
         if not df.empty:
-            # Distribution plots
-            axes[0,0].hist(df['area'], bins=20, color='skyblue', edgecolor='black')
-            axes[0,0].set_title('Cell Size Distribution')
-            axes[0,0].set_xlabel('Area (pixels)')
-            axes[0,0].set_ylabel('Count')
-            axes[0,0].grid(True, alpha=0.3)
+            ax[0,0].hist(df['Area (px²)'], bins=30, color='#1f77b4', ec='black')
+            ax[0,0].set_title('Area Distribution')
             
-            axes[0,1].hist(df['circularity'], bins=20, color='lightgreen', edgecolor='black')
-            axes[0,1].set_title('Circularity Distribution')
-            axes[0,1].set_xlabel('Circularity')
-            axes[0,1].set_ylabel('Count')
-            axes[0,1].grid(True, alpha=0.3)
+            ax[0,1].scatter(df['Circularity'], df['Convexity'], 
+                           c=df['Area (px²)'], cmap='viridis', alpha=0.7)
+            ax[0,1].set_title('Shape Correlation')
             
-            # Scatter plot
-            axes[1,0].scatter(df['area'], df['circularity'], alpha=0.6, c='purple')
-            axes[1,0].set_title('Area vs Circularity')
-            axes[1,0].set_xlabel('Area')
-            axes[1,0].set_ylabel('Circularity')
-            axes[1,0].grid(True, alpha=0.3)
+            ax[1,0].boxplot([df['Area (px²)'], df['Circularity']], 
+                           labels=['Area', 'Circularity'])
+            ax[1,0].set_title('Feature Distribution')
+            
+            ax[1,1].hexbin(df['Centroid X'], df['Centroid Y'], 
+                          gridsize=20, cmap='plasma', bins='log')
+            ax[1,1].set_title('Spatial Distribution')
             
-            # Box plot
-            df.boxplot(column=['area', 'circularity'], ax=axes[1,1])
-            axes[1,1].set_title('Feature Distributions')
-            axes[1,1].grid(True, alpha=0.3)
-        else:
-            for ax in axes.flat:
-                ax.text(0.5, 0.5, 'No cells detected', ha='center', va='center')
-        
         plt.tight_layout()
         
-        # Apply color transformation
-        transformed_image = apply_color_transformation(original_image, transform_type)
-        
         return (
             vis_img,
-            transformed_image,
+            apply_color_transformation(original, transform_type),
             fig,
             df
         )
     
     except Exception as e:
-        print(f"Error processing image: {str(e)}")
-        import traceback
-        traceback.print_exc()  # This will print the full error trace
+        print(f"Error: {str(e)}")
         return None, None, None, None
 
 
 
+
 # Create Gradio interface
 with gr.Blocks(title="Advanced Cell Analysis Tool", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""