Update app.py

app.py

@@ -2,11 +2,12 @@ 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):
-    """Optimized function for blood cell detection"""
+    """Specialized function for blood cell detection"""
     # Convert to RGB if grayscale
     if len(image.shape) == 2:
         image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
@@ -14,48 +15,45 @@ def detect_blood_cells(image):
     # Convert to HSV color space
     hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
     
-    # Optimized red color ranges for blood cells
-    lower_red1 = np.array([0, 100, 100])    # Increased saturation threshold
+    # 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([160, 100, 100])  # Increased saturation threshold
+    lower_red2 = np.array([170, 70, 50])
     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
-
-    # 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)
-    
-    # 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)
     
-    # Find connected components
-    _, markers = cv2.connectedComponents(sure_fg)
+    # 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 with hierarchy to handle nested contours
-    contours, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    # Find contours
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     
-    # 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 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)
     
-    return filtered_contours, markers
+    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 process_image(image, transform_type):
     """Process uploaded image and extract blood cell features"""
@@ -63,68 +61,64 @@ def process_image(image, transform_type):
         return None, None, None, None
     
     try:
-        # Store original image
+        # Store original image for transformations
         original_image = image.copy()
         
         # Detect blood cells
-        contours, markers = detect_blood_cells(image)
+        contours, mask = detect_blood_cells(image)
         
         # Extract features
         features = []
         for i, contour in enumerate(contours, 1):
             area = cv2.contourArea(contour)
-            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]
+            # 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
                 
-                features.append({
-                    'label': i,
-                    'area': area,
-                    'perimeter': perimeter,
-                    'circularity': circularity,
-                    'mean_intensity': mean_intensity,
-                    'centroid_x': cx,
-                    'centroid_y': cy
-                })
+                # 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
+                        })
         
         # Create visualization
         vis_img = image.copy()
         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         
-        # Draw contours and labels with enhanced visibility
+        # Draw contours and labels
         for feature in features:
-            i = feature['label'] - 1
-            cv2.drawContours(vis_img, contours, i, (0, 255, 0), 2)
+            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-10, y), cv2.FONT_HERSHEY_SIMPLEX, 
-                       0.4, (255, 255, 255), 2)
+                       (x, y), cv2.FONT_HERSHEY_SIMPLEX, 
+                       0.5, (255, 255, 255), 2)
             # Red text
             cv2.putText(vis_img, str(feature['label']), 
-                       (x-10, y), cv2.FONT_HERSHEY_SIMPLEX, 
-                       0.4, (0, 0, 255), 1)
+                       (x, y), cv2.FONT_HERSHEY_SIMPLEX, 
+                       0.5, (0, 0, 255), 1)
         
-        # 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)
+        # 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
+        # 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)
@@ -145,14 +139,11 @@ def process_image(image, transform_type):
             axes[0,1].grid(True, alpha=0.3)
             
             # Scatter plot
-            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].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('Mean Intensity')
+            axes[1,0].set_ylabel('Circularity')
             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])
@@ -177,7 +168,7 @@ def process_image(image, transform_type):
     except Exception as e:
         print(f"Error processing image: {str(e)}")
         import traceback
-        traceback.print_exc()
+        traceback.print_exc()  # This will print the full error trace
         return None, None, None, None