Update app.py

app.py

@@ -4,75 +4,197 @@ import pandas as pd
 import gradio as gr
 import matplotlib.pyplot as plt
 from datetime import datetime
+from sklearn.cluster import DBSCAN
+from scipy import ndimage
 
-def preprocess_image(image):
-    """Convert image to HSV and apply adaptive thresholding for better detection."""
-    if len(image.shape) == 2:
-        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
-    
-    hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-    
-    # Adaptive thresholding for better contrast
-    adaptive_thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)
-    
-    # Morphological operations to remove noise
-    kernel = np.ones((3,3), np.uint8)
-    clean_mask = cv2.morphologyEx(adaptive_thresh, cv2.MORPH_CLOSE, kernel, iterations=2)
-    clean_mask = cv2.morphologyEx(clean_mask, cv2.MORPH_OPEN, kernel, iterations=2)
-    
-    return clean_mask
+class BloodCellAnalyzer:
+    def __init__(self):
+        self.min_cell_area = 100
+        self.max_cell_area = 5000
+        self.min_circularity = 0.7
+        
+    def preprocess_image(self, image):
+        """Enhanced image preprocessing with multiple color spaces and filtering."""
+        if len(image.shape) == 2:
+            image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+        
+        # Convert to multiple color spaces for robust detection
+        hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+        lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        
+        # Create masks for different color ranges
+        hsv_mask = cv2.inRange(hsv, np.array([0, 20, 20]), np.array([180, 255, 255]))
+        lab_mask = cv2.inRange(lab, np.array([20, 120, 120]), np.array([200, 140, 140]))
+        
+        # Combine masks
+        combined_mask = cv2.bitwise_or(hsv_mask, lab_mask)
+        
+        # Apply advanced morphological operations
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+        clean_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_CLOSE, kernel, iterations=2)
+        clean_mask = cv2.morphologyEx(clean_mask, cv2.MORPH_OPEN, kernel, iterations=1)
+        
+        # Apply distance transform to separate touching cells
+        dist_transform = cv2.distanceTransform(clean_mask, cv2.DIST_L2, 5)
+        _, sure_fg = cv2.threshold(dist_transform, 0.5 * dist_transform.max(), 255, 0)
+        
+        return clean_mask.astype(np.uint8), sure_fg.astype(np.uint8)
 
-def detect_blood_cells(image):
-    """Detect blood cells using contour analysis with refined filtering."""
-    mask = preprocess_image(image)
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    
-    features = []
-    for i, contour in enumerate(contours, 1):
+    def extract_cell_features(self, contour):
+        """Extract comprehensive features for each detected cell."""
         area = cv2.contourArea(contour)
         perimeter = cv2.arcLength(contour, True)
-        circularity = 4 * np.pi * area / (perimeter * perimeter) if perimeter > 0 else 0
-        
-        if 100 < area < 5000 and circularity > 0.7:
-            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})
-    
-    return contours, features, mask
+        circularity = 4 * np.pi * area / (perimeter ** 2) if perimeter > 0 else 0
+        
+        # Calculate additional shape features
+        hull = cv2.convexHull(contour)
+        hull_area = cv2.contourArea(hull)
+        solidity = float(area) / hull_area if hull_area > 0 else 0
+        
+        # Calculate moments and orientation
+        moments = cv2.moments(contour)
+        cx = int(moments['m10'] / moments['m00']) if moments['m00'] != 0 else 0
+        cy = int(moments['m01'] / moments['m00']) if moments['m00'] != 0 else 0
+        
+        # Calculate eccentricity using ellipse fitting
+        if len(contour) >= 5:
+            (x, y), (MA, ma), angle = cv2.fitEllipse(contour)
+            eccentricity = np.sqrt(1 - (ma / MA) ** 2) if MA > 0 else 0
+        else:
+            eccentricity = 0
+            angle = 0
+        
+        return {
+            'area': area,
+            'perimeter': perimeter,
+            'circularity': circularity,
+            'solidity': solidity,
+            'eccentricity': eccentricity,
+            'orientation': angle,
+            'centroid_x': cx,
+            'centroid_y': cy
+        }
+
+    def detect_cells(self, image):
+        """Detect and analyze blood cells with advanced filtering."""
+        mask, sure_fg = self.preprocess_image(image)
+        
+        # Find contours
+        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Extract features and filter cells
+        cells = []
+        valid_contours = []
+        
+        for i, contour in enumerate(contours):
+            features = self.extract_cell_features(contour)
+            
+            # Apply multiple criteria for cell validation
+            if (self.min_cell_area < features['area'] < self.max_cell_area and 
+                features['circularity'] > self.min_circularity and 
+                features['solidity'] > 0.8):
+                
+                features['label'] = i + 1
+                cells.append(features)
+                valid_contours.append(contour)
+        
+        return valid_contours, cells, mask
+
+    def analyze_image(self, image):
+        """Perform comprehensive image analysis and generate visualizations."""
+        if image is None:
+            return None, None, None, None
+        
+        # Detect cells and extract features
+        contours, cells, mask = self.detect_cells(image)
+        vis_img = image.copy()
+        
+        # Draw detections and labels
+        for cell in cells:
+            contour = contours[cell['label'] - 1]
+            cv2.drawContours(vis_img, [contour], -1, (0, 255, 0), 2)
+            cv2.putText(vis_img, str(cell['label']), 
+                       (cell['centroid_x'], cell['centroid_y']),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
+        
+        # Create DataFrame and calculate summary statistics
+        df = pd.DataFrame(cells)
+        if not df.empty:
+            summary_stats = {
+                'total_cells': len(cells),
+                'avg_cell_size': df['area'].mean(),
+                'std_cell_size': df['area'].std(),
+                'avg_circularity': df['circularity'].mean(),
+                'cell_density': len(cells) / (image.shape[0] * image.shape[1])
+            }
+            df = df.assign(**{k: [v] * len(df) for k, v in summary_stats.items()})
+        
+        # Generate visualizations
+        fig = self.generate_analysis_plots(df)
+        
+        return vis_img, mask, fig, df
 
-def process_image(image):
-    if image is None:
-        return None, None, None, None
-    
-    contours, features, mask = detect_blood_cells(image)
-    vis_img = image.copy()
-    
-    for feature in features:
-        contour = contours[feature['label'] - 1]
-        cv2.drawContours(vis_img, [contour], -1, (0, 255, 0), 2)
-        cv2.putText(vis_img, str(feature['label']), (feature['centroid_x'], feature['centroid_y']), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
-    
-    df = pd.DataFrame(features)
-    return vis_img, mask, df
+    def generate_analysis_plots(self, df):
+        """Generate comprehensive analysis plots."""
+        if df.empty:
+            return None
+            
+        plt.style.use('dark_background')
+        fig = plt.figure(figsize=(15, 10))
+        
+        # Create subplot grid
+        gs = plt.GridSpec(2, 3, figure=fig)
+        ax1 = fig.add_subplot(gs[0, 0])
+        ax2 = fig.add_subplot(gs[0, 1])
+        ax3 = fig.add_subplot(gs[0, 2])
+        ax4 = fig.add_subplot(gs[1, :])
+        
+        # Cell size distribution
+        ax1.hist(df['area'], bins=20, color='cyan', edgecolor='black')
+        ax1.set_title('Cell Size Distribution')
+        ax1.set_xlabel('Area')
+        ax1.set_ylabel('Count')
+        
+        # Area vs Circularity
+        scatter = ax2.scatter(df['area'], df['circularity'], 
+                            c=df['solidity'], cmap='viridis', alpha=0.6)
+        ax2.set_title('Area vs Circularity')
+        ax2.set_xlabel('Area')
+        ax2.set_ylabel('Circularity')
+        plt.colorbar(scatter, ax=ax2, label='Solidity')
+        
+        # Eccentricity distribution
+        ax3.hist(df['eccentricity'], bins=15, color='magenta', edgecolor='black')
+        ax3.set_title('Eccentricity Distribution')
+        ax3.set_xlabel('Eccentricity')
+        ax3.set_ylabel('Count')
+        
+        # Cell position scatter plot
+        scatter = ax4.scatter(df['centroid_x'], df['centroid_y'], 
+                            c=df['area'], cmap='plasma', alpha=0.6, s=100)
+        ax4.set_title('Cell Positions and Sizes')
+        ax4.set_xlabel('X Position')
+        ax4.set_ylabel('Y Position')
+        plt.colorbar(scatter, ax=ax4, label='Cell Area')
+        
+        plt.tight_layout()
+        return fig
 
-def analyze(image):
-    vis_img, mask, df = process_image(image)
-    
-    plt.style.use('dark_background')
-    fig, axes = plt.subplots(1, 2, figsize=(12, 5))
-    
-    if not df.empty:
-        axes[0].hist(df['area'], bins=20, color='cyan', edgecolor='black')
-        axes[0].set_title('Cell Size Distribution')
-        
-        axes[1].scatter(df['area'], df['circularity'], alpha=0.6, c='magenta')
-        axes[1].set_title('Area vs Circularity')
-    
-    return vis_img, mask, fig, df
+# Create Gradio interface
+analyzer = BloodCellAnalyzer()
+demo = gr.Interface(
+    fn=analyzer.analyze_image,
+    inputs=gr.Image(type="numpy"),
+    outputs=[
+        gr.Image(label="Detected Cells"),
+        gr.Image(label="Segmentation Mask"),
+        gr.Plot(label="Analysis Plots"),
+        gr.DataFrame(label="Cell Data")
+    ],
+    title="Blood Cell Analysis Tool",
+    description="Upload an image to analyze blood cells and extract features."
+)
 
-# Gradio Interface
-demo = gr.Interface(fn=analyze, inputs=gr.Image(type="numpy"), outputs=[gr.Image(), gr.Image(), gr.Plot(), gr.Dataframe()])
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()