Update app.py

app.py

@@ -4,179 +4,183 @@ 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
 
 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."""
+        # Adjusted parameters for the specific image characteristics
+        self.min_rbc_area = 400
+        self.max_rbc_area = 2000
+        self.min_wbc_area = 500
+        self.max_wbc_area = 3000
+        self.min_circularity = 0.75
+
+    def detect_cells(self, image):
+        """Detect both red and white blood cells using color-based segmentation."""
+        if image is None:
+            return None, [], None
+            
+        # Convert to RGB if grayscale
         if len(image.shape) == 2:
             image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
-        
-        # Convert to multiple color spaces for robust detection
+            
+        # Convert to different color spaces
         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]))
+        # Red blood cell detection (red color range)
+        lower_red1 = np.array([0, 50, 50])
+        upper_red1 = np.array([10, 255, 255])
+        lower_red2 = np.array([160, 50, 50])
+        upper_red2 = np.array([180, 255, 255])
         
-        # Combine masks
-        combined_mask = cv2.bitwise_or(hsv_mask, lab_mask)
+        red_mask1 = cv2.inRange(hsv, lower_red1, upper_red1)
+        red_mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
+        red_mask = cv2.bitwise_or(red_mask1, red_mask2)
         
-        # 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)
+        # White blood cell detection (blue color range)
+        lower_blue = np.array([90, 50, 50])
+        upper_blue = np.array([130, 255, 255])
+        blue_mask = cv2.inRange(hsv, lower_blue, upper_blue)
         
-        # 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)
+        # Enhance masks
+        kernel = np.ones((3,3), np.uint8)
+        red_mask = cv2.morphologyEx(red_mask, cv2.MORPH_OPEN, kernel, iterations=1)
+        red_mask = cv2.morphologyEx(red_mask, cv2.MORPH_CLOSE, kernel, iterations=1)
+        blue_mask = cv2.morphologyEx(blue_mask, cv2.MORPH_OPEN, kernel, iterations=1)
+        blue_mask = cv2.morphologyEx(blue_mask, cv2.MORPH_CLOSE, kernel, iterations=1)
         
-        return clean_mask.astype(np.uint8), sure_fg.astype(np.uint8)
-
-    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 ** 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 for both cell types
+        rbc_contours, _ = cv2.findContours(red_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        wbc_contours, _ = cv2.findContours(blue_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
         
-        # 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)
+        # Process RBCs
+        for i, contour in enumerate(rbc_contours):
+            area = cv2.contourArea(contour)
+            perimeter = cv2.arcLength(contour, True)
+            circularity = 4 * np.pi * area / (perimeter * perimeter) if perimeter > 0 else 0
+            
+            if (self.min_rbc_area < area < self.max_rbc_area and 
+                circularity > self.min_circularity):
+                M = cv2.moments(contour)
+                if M["m00"] != 0:
+                    cx = int(M["m10"] / M["m00"])
+                    cy = int(M["m01"] / M["m00"])
+                    cells.append({
+                        'label': len(valid_contours) + 1,
+                        'type': 'RBC',
+                        'area': area,
+                        'circularity': circularity,
+                        'centroid_x': cx,
+                        'centroid_y': cy
+                    })
+                    valid_contours.append(contour)
+        
+        # Process WBCs
+        for i, contour in enumerate(wbc_contours):
+            area = cv2.contourArea(contour)
+            perimeter = cv2.arcLength(contour, True)
+            circularity = 4 * np.pi * area / (perimeter * perimeter) if perimeter > 0 else 0
             
-            # 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
+            if (self.min_wbc_area < area < self.max_wbc_area):
+                M = cv2.moments(contour)
+                if M["m00"] != 0:
+                    cx = int(M["m10"] / M["m00"])
+                    cy = int(M["m01"] / M["m00"])
+                    cells.append({
+                        'label': len(valid_contours) + 1,
+                        'type': 'WBC',
+                        'area': area,
+                        'circularity': circularity,
+                        'centroid_x': cx,
+                        'centroid_y': cy
+                    })
+                    valid_contours.append(contour)
+        
+        return valid_contours, cells, red_mask
 
     def analyze_image(self, image):
-        """Perform comprehensive image analysis and generate visualizations."""
+        """Analyze the blood cell image and generate visualizations."""
         if image is None:
             return None, None, None, None
         
-        # Detect cells and extract features
+        # Detect cells
         contours, cells, mask = self.detect_cells(image)
         vis_img = image.copy()
         
-        # Draw detections and labels
+        # Draw detections
         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']), 
+            color = (0, 0, 255) if cell['type'] == 'RBC' else (255, 0, 0)
+            cv2.drawContours(vis_img, [contour], -1, color, 2)
+            cv2.putText(vis_img, f"{cell['type']}", 
                        (cell['centroid_x'], cell['centroid_y']),
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
         
-        # Create DataFrame and calculate summary statistics
+        # Create DataFrame
         df = pd.DataFrame(cells)
+        
+        # Generate summary statistics
         if not df.empty:
+            rbc_count = len(df[df['type'] == 'RBC'])
+            wbc_count = len(df[df['type'] == 'WBC'])
+            
             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])
+                'total_rbc': rbc_count,
+                'total_wbc': wbc_count,
+                'rbc_avg_size': df[df['type'] == 'RBC']['area'].mean() if rbc_count > 0 else 0,
+                'wbc_avg_size': df[df['type'] == 'WBC']['area'].mean() if wbc_count > 0 else 0,
             }
-            df = df.assign(**{k: [v] * len(df) for k, v in summary_stats.items()})
+            
+            # Add summary stats to DataFrame
+            for k, v in summary_stats.items():
+                df[k] = v
         
-        # Generate visualizations
+        # Generate visualization
         fig = self.generate_analysis_plots(df)
         
         return vis_img, mask, fig, df
 
     def generate_analysis_plots(self, df):
-        """Generate comprehensive analysis plots."""
+        """Generate analysis plots for the detected cells."""
         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')
+        fig, axes = plt.subplots(2, 2, figsize=(12, 10))
+        
+        # Cell count by type
+        cell_counts = df['type'].value_counts()
+        axes[0, 0].bar(cell_counts.index, cell_counts.values, color=['red', 'blue'])
+        axes[0, 0].set_title('Cell Count by Type')
+        
+        # Size distribution
+        for cell_type, color in zip(['RBC', 'WBC'], ['red', 'blue']):
+            if len(df[df['type'] == cell_type]) > 0:
+                axes[0, 1].hist(df[df['type'] == cell_type]['area'], 
+                              bins=20, alpha=0.5, color=color, label=cell_type)
+        axes[0, 1].set_title('Cell Size Distribution')
+        axes[0, 1].legend()
+        
+        # Circularity by type
+        for cell_type, color in zip(['RBC', 'WBC'], ['red', 'blue']):
+            cell_data = df[df['type'] == cell_type]
+            if len(cell_data) > 0:
+                axes[1, 0].scatter(cell_data['area'], cell_data['circularity'], 
+                                 c=color, label=cell_type, alpha=0.6)
+        axes[1, 0].set_title('Area vs Circularity')
+        axes[1, 0].legend()
+        
+        # Spatial distribution
+        for cell_type, color in zip(['RBC', 'WBC'], ['red', 'blue']):
+            cell_data = df[df['type'] == cell_type]
+            if len(cell_data) > 0:
+                axes[1, 1].scatter(cell_data['centroid_x'], cell_data['centroid_y'], 
+                                 c=color, label=cell_type, alpha=0.6)
+        axes[1, 1].set_title('Spatial Distribution')
+        axes[1, 1].legend()
         
         plt.tight_layout()
         return fig
@@ -193,7 +197,7 @@ demo = gr.Interface(
         gr.DataFrame(label="Cell Data")
     ],
     title="Blood Cell Analysis Tool",
-    description="Upload an image to analyze blood cells and extract features."
+    description="Upload an image to analyze red and white blood cells."
 )
 
 if __name__ == "__main__":