Update app.py

app.py

@@ -2,12 +2,11 @@ import cv2
 import numpy as np
 import pandas as pd
 import gradio as gr
-from skimage import measure, morphology
 import matplotlib.pyplot as plt
 from datetime import datetime
 
 def detect_blood_cells(image):
-    """Specialized function for blood cell detection"""
+    """Optimized function for blood cell detection"""
     # Convert to RGB if grayscale
     if len(image.shape) == 2:
         image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
@@ -15,45 +14,48 @@ def detect_blood_cells(image):
     # 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])
+    # Optimized red color ranges for blood cells
+    lower_red1 = np.array([0, 100, 100])    # Increased saturation threshold
     upper_red1 = np.array([10, 255, 255])
-    lower_red2 = np.array([170, 70, 50])
+    lower_red2 = np.array([160, 100, 100])  # Increased saturation threshold
     upper_red2 = np.array([180, 255, 255])
     
+    # Create masks for red color
     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)
+
+    # Enhanced noise removal
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=1)
     mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=2)
     
-    # Find contours
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    # Apply distance transform to separate touching cells
+    dist_transform = cv2.distanceTransform(mask, cv2.DIST_L2, 5)
+    _, sure_fg = cv2.threshold(dist_transform, 0.5 * dist_transform.max(), 255, 0)
+    sure_fg = np.uint8(sure_fg)
     
-    return contours, mask
-
-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)
+    # Find connected components
+    _, markers = cv2.connectedComponents(sure_fg)
+    
+    # Find contours with hierarchy to handle nested contours
+    contours, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     
-    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
+    # Filter contours based on area and circularity
+    filtered_contours = []
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        perimeter = cv2.arcLength(contour, True)
+        if perimeter == 0:
+            continue
+            
+        circularity = 4 * np.pi * area / (perimeter * perimeter)
+        
+        # Optimized thresholds for your specific images
+        if 500 < area < 2500 and circularity > 0.8:  # Adjusted thresholds
+            filtered_contours.append(contour)
+    
+    return filtered_contours, markers
 
 def process_image(image, transform_type):
     """Process uploaded image and extract blood cell features"""
@@ -61,64 +63,68 @@ def process_image(image, transform_type):
         return None, None, None, None
     
     try:
-        # Store original image for transformations
+        # Store original image
         original_image = image.copy()
         
         # Detect blood cells
-        contours, mask = detect_blood_cells(image)
+        contours, markers = 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
+            perimeter = cv2.arcLength(contour, True)
+            circularity = 4 * np.pi * area / (perimeter * perimeter)
+            
+            # Calculate centroid
+            M = cv2.moments(contour)
+            if M["m00"] != 0:
+                cx = int(M["m10"] / M["m00"])
+                cy = int(M["m01"] / M["m00"])
+                
+                # Extract mean color intensity
+                mask = np.zeros(image.shape[:2], dtype=np.uint8)
+                cv2.drawContours(mask, [contour], -1, 255, -1)
+                mean_intensity = cv2.mean(cv2.cvtColor(image, cv2.COLOR_RGB2GRAY), mask=mask)[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
-                        })
+                features.append({
+                    'label': i,
+                    'area': area,
+                    'perimeter': perimeter,
+                    'circularity': circularity,
+                    'mean_intensity': mean_intensity,
+                    'centroid_x': cx,
+                    'centroid_y': cy
+                })
         
         # Create visualization
         vis_img = image.copy()
         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         
-        # Draw contours and labels
+        # Draw contours and labels with enhanced visibility
         for feature in features:
-            contour = contours[feature['label']-1]
-            cv2.drawContours(vis_img, [contour], -1, (0, 255, 0), 2)
+            i = feature['label'] - 1
+            cv2.drawContours(vis_img, contours, i, (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)
+                       (x-10, y), cv2.FONT_HERSHEY_SIMPLEX, 
+                       0.4, (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)
+                       (x-10, y), cv2.FONT_HERSHEY_SIMPLEX, 
+                       0.4, (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)
+        # Add timestamp and cell count with better positioning
+        info_text = f"Analyzed: {timestamp} | Cells Detected: {len(features)}"
+        cv2.putText(vis_img, info_text, 
+                    (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 
+                    0.6, (255, 255, 255), 2)
         
-        # Create analysis plots with default style
+        # Create analysis plots
         plt.style.use('default')
         fig, axes = plt.subplots(2, 2, figsize=(15, 12))
         fig.suptitle('Blood Cell Analysis Results', fontsize=16, y=0.95)
@@ -139,11 +145,14 @@ def process_image(image, transform_type):
             axes[0,1].grid(True, alpha=0.3)
             
             # Scatter plot
-            axes[1,0].scatter(df['area'], df['circularity'], alpha=0.6, c='purple')
-            axes[1,0].set_title('Area vs Circularity')
+            scatter = axes[1,0].scatter(df['area'], df['mean_intensity'], 
+                                      c=df['circularity'], cmap='viridis', 
+                                      alpha=0.6)
+            axes[1,0].set_title('Area vs Intensity')
             axes[1,0].set_xlabel('Area')
-            axes[1,0].set_ylabel('Circularity')
+            axes[1,0].set_ylabel('Mean Intensity')
             axes[1,0].grid(True, alpha=0.3)
+            plt.colorbar(scatter, ax=axes[1,0], label='Circularity')
             
             # Box plot
             df.boxplot(column=['area', 'circularity'], ax=axes[1,1])
@@ -168,7 +177,7 @@ def process_image(image, transform_type):
     except Exception as e:
         print(f"Error processing image: {str(e)}")
         import traceback
-        traceback.print_exc()  # This will print the full error trace
+        traceback.print_exc()
         return None, None, None, None