Update app.py

app.py

@@ -3,130 +3,132 @@ import numpy as np
 import pandas as pd
 import gradio as gr
 from skimage import measure, morphology
-from skimage.segmentation import watershed
 import matplotlib.pyplot as plt
 from datetime import datetime
-import logging
+
+def detect_blood_cells(image):
+    """Specialized function for blood cell detection"""
+    # Convert to RGB if grayscale
+    if len(image.shape) == 2:
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+    
+    # 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])
+    upper_red1 = np.array([10, 255, 255])
+    lower_red2 = np.array([170, 70, 50])
+    upper_red2 = np.array([180, 255, 255])
+    
+    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)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=2)
+    
+    # Find contours
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    return contours, mask
 
 def apply_color_transformation(image, transform_type):
     """Apply different color transformations to the image"""
-    if len(image.shape) == 3:
-        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    if len(image.shape) == 2:
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
     
     if transform_type == "Original":
-        return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        return image
     elif transform_type == "Grayscale":
-        return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        return cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
     elif transform_type == "Binary":
-        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        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_BGR2GRAY)
+        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 cell features"""
+    """Process uploaded image and extract blood cell features"""
     if image is None:
         return None, None, None, None
     
     try:
-        # Store original image for color transformations
+        # Store original image for transformations
         original_image = image.copy()
         
-        # Convert to BGR if needed
-        if len(image.shape) == 3:
-            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-        
-        # Basic preprocessing
-        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
-        enhanced = clahe.apply(gray)
-        blurred = cv2.medianBlur(enhanced, 5)
-        
-        # Thresholding
-        _, binary = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-        
-        # Noise removal and cell separation
-        kernel = np.ones((3,3), np.uint8)
-        opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel, iterations=2)
-        
-        # Sure background area
-        sure_bg = cv2.dilate(opening, kernel, iterations=3)
-        
-        # Finding sure foreground area
-        dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
-        _, sure_fg = cv2.threshold(dist_transform, 0.5 * dist_transform.max(), 255, 0)
-        sure_fg = sure_fg.astype(np.uint8)
-        
-        # Finding unknown region
-        unknown = cv2.subtract(sure_bg, sure_fg)
-        
-        # Marker labelling
-        _, markers = cv2.connectedComponents(sure_fg)
-        markers = markers + 1
-        markers[unknown == 255] = 0
-        
-        # Apply watershed
-        markers = cv2.watershed(image, markers)
+        # Detect blood cells
+        contours, mask = detect_blood_cells(image)
         
         # Extract features
         features = []
-        for region in measure.regionprops(markers):
-            if region.area >= 50:  # Filter small regions
-                features.append({
-                    'label': region.label,
-                    'area': region.area,
-                    'perimeter': region.perimeter,
-                    'circularity': (4 * np.pi * region.area) / (region.perimeter ** 2) if region.perimeter > 0 else 0,
-                    'mean_intensity': region.mean_intensity,
-                    'centroid_x': region.centroid[1],
-                    'centroid_y': region.centroid[0]
-                })
+        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
+                
+                # 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
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         vis_img = image.copy()
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         
-        # Draw contours
-        contours = measure.find_contours(markers, 0.5)
-        for contour in contours:
-            coords = np.array(contour).astype(int)
-            coords = coords[:, [1, 0]]  # Swap x and y coordinates
-            coords = coords.reshape((-1, 1, 2))
-            cv2.polylines(vis_img, [coords], True, (0, 255, 0), 2)
-        
-        # Add cell labels and measurements
+        # Draw contours and labels
         for feature in features:
-            x = int(feature['centroid_x'])
-            y = int(feature['centroid_y'])
+            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, y), cv2.FONT_HERSHEY_SIMPLEX, 
-                       0.5, (255,255,255), 2)
+                       0.5, (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)
+                       0.5, (0, 0, 255), 1)
         
-        # Add timestamp
-        cv2.putText(vis_img, f"Analyzed: {timestamp}", 
+        # 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)
+                    0.7, (255, 255, 255), 2)
         
-        # Create plots
+        # Create analysis plots
         plt.style.use('seaborn')
         fig, axes = plt.subplots(2, 2, figsize=(15, 12))
-        fig.suptitle('Cell Analysis Results', fontsize=16, y=0.95)
+        fig.suptitle('Blood Cell Analysis Results', fontsize=16, y=0.95)
         
         df = pd.DataFrame(features)
         if not df.empty:
             # Distribution plots
             df['area'].hist(ax=axes[0,0], bins=20, color='skyblue', edgecolor='black')
             axes[0,0].set_title('Cell Size Distribution')
-            axes[0,0].set_xlabel('Area')
+            axes[0,0].set_xlabel('Area (pixels)')
             axes[0,0].set_ylabel('Count')
             
             df['circularity'].hist(ax=axes[0,1], bins=20, color='lightgreen', edgecolor='black')
@@ -134,12 +136,11 @@ def process_image(image, transform_type):
             axes[0,1].set_xlabel('Circularity')
             axes[0,1].set_ylabel('Count')
             
-            # Scatter plots
-            axes[1,0].scatter(df['circularity'], df['mean_intensity'], 
-                         alpha=0.6, c='purple')
-            axes[1,0].set_title('Circularity vs Intensity')
-            axes[1,0].set_xlabel('Circularity')
-            axes[1,0].set_ylabel('Mean Intensity')
+            # Scatter plot
+            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('Circularity')
             
             # Box plot
             df.boxplot(column=['area', 'circularity'], ax=axes[1,1])
@@ -154,7 +155,7 @@ def process_image(image, transform_type):
         transformed_image = apply_color_transformation(original_image, transform_type)
         
         return (
-            cv2.cvtColor(vis_img, cv2.COLOR_BGR2RGB),
+            vis_img,
             transformed_image,
             fig,
             df
@@ -164,6 +165,8 @@ def process_image(image, transform_type):
         print(f"Error processing image: {str(e)}")
         return None, None, None, None
 
+
+
 # Create Gradio interface
 with gr.Blocks(title="Advanced Cell Analysis Tool", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""