Update app.py

app.py

@@ -5,200 +5,105 @@ import gradio as gr
 import matplotlib.pyplot as plt
 from datetime import datetime
 
-class BloodCellAnalyzer:
-    def __init__(self):
-        # 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 different color spaces
-        hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
-        lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
-        
-        # 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])
-        
-        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)
-        
-        # 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)
-        
-        # 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)
-        
-        # 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)
-        
-        cells = []
-        valid_contours = []
-        
-        # 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
-            
-            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):
-        """Analyze the blood cell image and generate visualizations."""
-        if image is None:
-            return None, None, None, None
-        
-        # Detect cells
-        contours, cells, mask = self.detect_cells(image)
-        vis_img = image.copy()
-        
-        # Draw detections
-        for cell in cells:
-            contour = contours[cell['label'] - 1]
-            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, color, 1)
-        
-        # 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_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,
-            }
-            
-            # Add summary stats to DataFrame
-            for k, v in summary_stats.items():
-                df[k] = v
-        
-        # Generate visualization
-        fig = self.generate_analysis_plots(df)
-        
-        return vis_img, mask, fig, df
-
-    def generate_analysis_plots(self, df):
-        """Generate analysis plots for the detected cells."""
-        if df.empty:
-            return None
-            
-        plt.style.use('dark_background')
-        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
-
-# Create Gradio interface
-analyzer = BloodCellAnalyzer()
+def preprocess_image(image):
+    """Enhance image contrast, apply thresholding, and clean noise."""
+    if len(image.shape) == 2:
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    
+    # Apply Gaussian blur to remove noise
+    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+    
+    # Otsu's Thresholding (more robust than adaptive for blood cells)
+    _, binary = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+
+    # Morphological operations to improve segmentation
+    kernel = np.ones((3, 3), np.uint8)
+    clean_mask = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel, iterations=2)
+    clean_mask = cv2.morphologyEx(clean_mask, cv2.MORPH_OPEN, kernel, iterations=1)
+
+    return clean_mask
+
+def detect_blood_cells(image):
+    """Detect blood cells and extract features."""
+    mask = preprocess_image(image)
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    features = []
+    total_area = 0
+
+    for i, contour in enumerate(contours, 1):
+        area = cv2.contourArea(contour)
+        perimeter = cv2.arcLength(contour, True)
+        circularity = (4 * np.pi * area / (perimeter * perimeter)) if perimeter > 0 else 0
+
+        # Filtering: Only count reasonable-sized circular objects
+        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({
+                    'ID': i, 'Area': area, 'Perimeter': perimeter, 
+                    'Circularity': circularity, 'Centroid_X': cx, 'Centroid_Y': cy
+                })
+                total_area += area
+
+    # Summary Statistics
+    avg_cell_size = total_area / len(features) if features else 0
+    cell_density = len(features) / (image.shape[0] * image.shape[1])  # Density per pixel
+
+    summary = {
+        'Total Cells': len(features),
+        'Avg Cell Size': avg_cell_size,
+        'Cell Density': cell_density
+    }
+
+    return contours, features, mask, summary
+
+def process_image(image):
+    if image is None:
+        return None, None, None, None, None
+
+    contours, features, mask, summary = detect_blood_cells(image)
+    vis_img = image.copy()
+
+    for feature in features:
+        contour = contours[feature['ID'] - 1]
+        cv2.drawContours(vis_img, [contour], -1, (0, 255, 0), 2)
+        cv2.putText(vis_img, str(feature['ID']), (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, summary
+
+def analyze(image):
+    vis_img, mask, df, summary = 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, summary
+
+# Gradio Interface
 demo = gr.Interface(
-    fn=analyzer.analyze_image,
+    fn=analyze,
     inputs=gr.Image(type="numpy"),
     outputs=[
-        gr.Image(label="Detected Cells"),
-        gr.Image(label="Segmentation Mask"),
+        gr.Image(label="Processed Image"),
+        gr.Image(label="Binary Mask"),
         gr.Plot(label="Analysis Plots"),
-        gr.DataFrame(label="Cell Data")
-    ],
-    title="Blood Cell Analysis Tool",
-    description="Upload an image to analyze red and white blood cells."
+        gr.Dataframe(label="Detected Cells Data"),
+        gr.JSON(label="Summary Statistics")
+    ]
 )
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()