Update app.py

app.py

@@ -5,102 +5,118 @@ import gradio as gr
 from skimage import measure, morphology
 from skimage.segmentation import watershed
 import matplotlib.pyplot as plt
-import base64
 from datetime import datetime
+import logging
 
 def apply_color_transformation(image, transform_type):
     """Apply different color transformations to the image"""
-    try:
-        # 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) if len(image.shape) == 3 else image
-        elif transform_type == "Grayscale":
-            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) 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) 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"Transformation error: {str(e)}")
-        return None
+    if len(image.shape) == 3:
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    
+    if transform_type == "Original":
+        return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    elif transform_type == "Grayscale":
+        return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    elif transform_type == "Binary":
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
+        return binary
+    elif transform_type == "CLAHE":
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        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"""
+    if image is None:
+        return None, None, None, None
+    
     try:
-        if image is None:
-            return [None]*4
-        
         # Store original image for color transformations
         original_image = image.copy()
         
-        # Convert to BGR for OpenCV processing
+        # Convert to BGR if needed
         if len(image.shape) == 3:
             image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
         
-        # Preprocessing pipeline
+        # 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
-        _, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        _, binary = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
         
-        # Noise removal
+        # Noise removal and cell separation
         kernel = np.ones((3,3), np.uint8)
-        opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)
+        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.7*dist_transform.max(), 255, 0)
-        sure_fg = np.uint8(sure_fg)
+        _, sure_fg = cv2.threshold(dist_transform, 0.5 * dist_transform.max(), 255, 0)
+        sure_fg = sure_fg.astype(np.uint8)
         
-        # Unknown region
+        # Finding unknown region
         unknown = cv2.subtract(sure_bg, sure_fg)
         
         # Marker labelling
         _, markers = cv2.connectedComponents(sure_fg)
-        markers += 1
+        markers = markers + 1
         markers[unknown == 255] = 0
         
-        # Watershed algorithm
+        # Apply watershed
         markers = cv2.watershed(image, markers)
         
-        # Feature extraction
+        # Extract features
         features = []
-        vis_img = image.copy()
-        
         for region in measure.regionprops(markers):
-            if region.area >= 50:
-                y, x = region.centroid
-                # Store features
+            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
+                    'mean_intensity': region.mean_intensity,
+                    'centroid_x': region.centroid[1],
+                    'centroid_y': region.centroid[0]
                 })
-                # 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 visualization
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        vis_img = image.copy()
         
-        # Create analysis plots
+        # 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
+        for feature in features:
+            x = int(feature['centroid_x'])
+            y = int(feature['centroid_y'])
+            # White outline
+            cv2.putText(vis_img, str(feature['label']), 
+                       (x, y), cv2.FONT_HERSHEY_SIMPLEX, 
+                       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)
+        
+        # Add timestamp
+        cv2.putText(vis_img, f"Analyzed: {timestamp}", 
+                    (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
+                    0.7, (255,255,255), 2)
+        
+        # Create plots
         plt.style.use('seaborn')
         fig, axes = plt.subplots(2, 2, figsize=(15, 12))
         fig.suptitle('Cell Analysis Results', fontsize=16, y=0.95)
@@ -110,16 +126,24 @@ 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 plot
-            axes[1,0].scatter(df['circularity'], df['mean_intensity'], alpha=0.6, c='purple')
+            # 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')
             
             # 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')
@@ -127,23 +151,20 @@ def process_image(image, transform_type):
         plt.tight_layout()
         
         # 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)
+        transformed_image = apply_color_transformation(original_image, transform_type)
         
         return (
-            vis_img,
-            transformed_img if transformed_img is not None else original_image,
+            cv2.cvtColor(vis_img, cv2.COLOR_BGR2RGB),
+            transformed_image,
             fig,
             df
         )
-        
+    
     except Exception as e:
-        print(f"Processing error: {str(e)}")
-        return [None]*4
-
+        print(f"Error processing image: {str(e)}")
+        return None, None, None, None
 
-# Create enhanced Gradio interface
+# Create Gradio interface
 with gr.Blocks(title="Advanced Cell Analysis Tool", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 🔬 Advanced Bioengineering Cell Analysis Tool
@@ -157,7 +178,6 @@ with gr.Blocks(title="Advanced Cell Analysis Tool", theme=gr.themes.Soft()) as d
     ## Author
     - **Muhammad Ibrahim Qasmi**
     - [LinkedIn](https://www.linkedin.com/in/muhammad-ibrahim-qasmi-9876a1297/)
-    - [GitHub](https://github.com/yourusername)  <!-- Add your GitHub URL -->
     """)
     
     with gr.Row():
@@ -201,21 +221,6 @@ with gr.Blocks(title="Advanced Cell Analysis Tool", theme=gr.themes.Soft()) as d
                     output_table = gr.DataFrame(
                         label="Cell Features"
                     )
-                    download_btn = gr.Button(
-                        "Download Results",
-                        variant="secondary"
-                    )
-    
-    # Add footer
-    gr.Markdown("""
-    ---
-    ### 📝 Notes
-    - Supported image formats: PNG, JPG, JPEG
-    - Minimum recommended resolution: 512x512 pixels
-    - Processing time varies with image size and cell count
-    
-    *Last updated: January 2025*
-    """)
     
     analyze_btn.click(
         fn=process_image,
@@ -225,7 +230,4 @@ with gr.Blocks(title="Advanced Cell Analysis Tool", theme=gr.themes.Soft()) as d
 
 # Launch the demo
 if __name__ == "__main__":
-    try:
-        demo.launch()
-    except Exception as e:
-        print(f"Error launching Gradio interface: {e}")
+    demo.launch()