Update app.py

app.py

@@ -11,76 +11,96 @@ from datetime import datetime
 def apply_color_transformation(image, transform_type):
     """Apply different color transformations to the image"""
     try:
-        if len(image.shape) == 3:
+        # Convert to BGR if needed
+        if len(image.shape) == 3 and image.shape[2] == 3:
             image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
         
         if transform_type == "Original":
-            return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            return cv2.cvtColor(image, cv2.COLOR_BGR2RGB) if len(image.shape) == 3 else image
         elif transform_type == "Grayscale":
-            return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) if len(image.shape) == 3 else image
         elif transform_type == "Binary":
-            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) if len(image.shape) == 3 else image
             _, 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_BGR2GRAY) if len(image.shape) == 3 else image
             clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
             return clahe.apply(gray)
         return image
     except Exception as e:
-        print(f"Error in apply_color_transformation: {e}")
+        print(f"Transformation error: {str(e)}")
         return None
 
 def process_image(image, transform_type):
     """Process uploaded image and extract cell features"""
     try:
         if image is None:
-            return None, None, None, None
+            return [None]*4
         
         # Store original image for color transformations
         original_image = image.copy()
         
-        # Process image as before
+        # Convert to BGR for OpenCV processing
         if len(image.shape) == 3:
             image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
         
-        # Basic preprocessing
+        # Preprocessing pipeline
         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)
         
-        # [Rest of the processing code remains the same until visualization]
+        # Thresholding
+        _, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
         
-        # Create enhanced visualization with timestamp
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        vis_img = image.copy()
-        contours = measure.find_contours(markers, 0.5)
+        # Noise removal
+        kernel = np.ones((3,3), np.uint8)
+        opening = cv2.morphologyEx(thresh, 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.7*dist_transform.max(), 255, 0)
+        sure_fg = np.uint8(sure_fg)
+        
+        # Unknown region
+        unknown = cv2.subtract(sure_bg, sure_fg)
+        
+        # Marker labelling
+        _, markers = cv2.connectedComponents(sure_fg)
+        markers += 1
+        markers[unknown == 255] = 0
         
-        # Draw contours and cell IDs with improved visibility
-        for contour in contours:
-            coords = contour.astype(int)
-            cv2.drawContours(vis_img, [coords], -1, (0,255,0), 2)  # Thicker lines
+        # Watershed algorithm
+        markers = cv2.watershed(image, markers)
+        
+        # Feature extraction
+        features = []
+        vis_img = image.copy()
         
         for region in measure.regionprops(markers):
             if region.area >= 50:
                 y, x = region.centroid
-                # Add white background for better text visibility
-                cv2.putText(vis_img, str(region.label), 
-                           (int(x), int(y)),
-                           cv2.FONT_HERSHEY_SIMPLEX, 
-                           0.5, (255,255,255), 2)  # White outline
-                cv2.putText(vis_img, str(region.label), 
-                           (int(x), int(y)),
-                           cv2.FONT_HERSHEY_SIMPLEX, 
-                           0.5, (0,0,255), 1)  # Red text
-        
-        # Add timestamp and cell count
-        cv2.putText(vis_img, f"Analyzed: {timestamp}", 
-                    (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
-                    0.7, (255,255,255), 2)
-        
-        # Create summary plots with improved styling
+                # Store features
+                features.append({
+                    'label': region.label,
+                    'area': region.area,
+                    'circularity': (4 * np.pi * region.area) / (region.perimeter ** 2) if region.perimeter > 0 else 0,
+                    'mean_intensity': region.mean_intensity
+                })
+                # Draw text with contrast
+                cv2.putText(vis_img, str(region.label), (int(x), int(y)),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)
+                cv2.putText(vis_img, str(region.label), (int(x), int(y)),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,255), 1)
+        
+        # Convert visualization image back to RGB
+        vis_img = cv2.cvtColor(vis_img, cv2.COLOR_BGR2RGB)
+        
+        # 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)
@@ -90,42 +110,38 @@ def process_image(image, transform_type):
             # 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_ylabel('Count')
             
             df['circularity'].hist(ax=axes[0,1], bins=20, color='lightgreen', edgecolor='black')
             axes[0,1].set_title('Circularity Distribution')
-            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')
+            # Scatter plot
+            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')
             
-            # Add box plot
+            # Box plot
             df.boxplot(column=['area', 'circularity'], ax=axes[1,1])
-            axes[1,1].set_title('Feature Distributions')
         else:
             for ax in axes.flat:
                 ax.text(0.5, 0.5, 'No cells detected', ha='center', va='center')
         
         plt.tight_layout()
         
-        # Apply color transformation to original image
-        transformed_image = apply_color_transformation(original_image, transform_type)
+        # Apply color transformation
+        transformed_img = apply_color_transformation(original_image, transform_type)
+        if transformed_img is not None and len(transformed_img.shape) == 2:
+            transformed_img = cv2.cvtColor(transformed_img, cv2.COLOR_GRAY2RGB)
         
         return (
-            cv2.cvtColor(vis_img, cv2.COLOR_BGR2RGB),
-            transformed_image,
+            vis_img,
+            transformed_img if transformed_img is not None else original_image,
             fig,
             df
         )
+        
     except Exception as e:
-        print(f"Error in process_image: {e}")
-        return None, None, None, None
+        print(f"Processing error: {str(e)}")
+        return [None]*4
+
 
 # Create enhanced Gradio interface
 with gr.Blocks(title="Advanced Cell Analysis Tool", theme=gr.themes.Soft()) as demo: