Update app.py

app.py

@@ -5,10 +5,37 @@ 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
 
-def process_image(image):
+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 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"""
-    # Convert to BGR if image is RGB
+    if image is None:
+        return None, None, None, None
+    
+    # Store original image for color transformations
+    original_image = image.copy()
+    
+    # Process image as before
     if len(image.shape) == 3:
         image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
     
@@ -18,142 +45,158 @@ def process_image(image):
     enhanced = clahe.apply(gray)
     blurred = cv2.medianBlur(enhanced, 5)
     
-    # Segmentation
-    thresh = cv2.adaptiveThreshold(
-        blurred, 255,
-        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-        cv2.THRESH_BINARY_INV, 21, 4
-    )
+    # [Rest of the processing code remains the same until visualization]
     
-    # Clean small noise
-    cleaned = morphology.opening(thresh, morphology.disk(2))
-    
-    # Watershed segmentation
-    sure_bg = cv2.dilate(cleaned, morphology.disk(3), iterations=3)
-    dist = cv2.distanceTransform(cleaned, cv2.DIST_L2, 5)
-    ret, sure_fg = cv2.threshold(dist, 0.5*dist.max(), 255, 0)
-    sure_fg = np.uint8(sure_fg)
-    unknown = cv2.subtract(sure_bg, sure_fg)
-    
-    # Marker labelling
-    ret, markers = cv2.connectedComponents(sure_fg)
-    markers += 1
-    markers[unknown == 255] = 0
-    markers = watershed(-dist, markers, mask=cleaned)
-    
-    # Extract features
-    features = []
-    props = measure.regionprops(markers, intensity_image=gray)
-    
-    for i, prop in enumerate(props):
-        if prop.area < 50:  # Filter small regions
-            continue
-        
-        features.append({
-            'cell_id': i+1,
-            'area': prop.area,
-            'perimeter': prop.perimeter,
-            'circularity': (4 * np.pi * prop.area) / (prop.perimeter**2 + 1e-6),
-            'mean_intensity': prop.mean_intensity,
-            'centroid_x': prop.centroid[1],
-            'centroid_y': prop.centroid[0]
-        })
-    
-    # Create visualization
+    # 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)
     
-    # Draw contours and cell IDs
+    # 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), 1)
+        cv2.drawContours(vis_img, [coords], -1, (0,255,0), 2)  # Thicker lines
     
     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.4, (255,0,0), 1)
+                       0.5, (0,0,255), 1)  # Red text
     
-    # Create summary plots
-    fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+    # 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
+    plt.style.use('seaborn')
+    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+    fig.suptitle('Cell Analysis Results', fontsize=16, y=0.95)
     
-    # Cell size distribution
     df = pd.DataFrame(features)
     if not df.empty:
-        df['area'].hist(ax=axes[0], bins=20)
-        axes[0].set_title('Cell Size Distribution')
-        axes[0].set_xlabel('Area')
-        axes[0].set_ylabel('Count')
+        # 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')
+        axes[1,0].set_title('Circularity vs Intensity')
+        axes[1,0].set_xlabel('Circularity')
+        axes[1,0].set_ylabel('Mean Intensity')
         
-        # Circularity vs Intensity
-        axes[1].scatter(df['circularity'], df['mean_intensity'])
-        axes[1].set_title('Circularity vs Intensity')
-        axes[1].set_xlabel('Circularity')
-        axes[1].set_ylabel('Mean Intensity')
+        # Add box plot
+        df.boxplot(column=['area', 'circularity'], ax=axes[1,1])
+        axes[1,1].set_title('Feature Distributions')
     else:
-        axes[0].text(0.5, 0.5, 'No cells detected', ha='center')
-        axes[1].text(0.5, 0.5, 'No cells detected', ha='center')
+        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)
+    
     return (
         cv2.cvtColor(vis_img, cv2.COLOR_BGR2RGB),
+        transformed_image,
         fig,
         df
     )
 
-# Create Gradio interface
-with gr.Blocks(title="Cell Analysis Tool") as demo:
+# Create enhanced Gradio interface
+with gr.Blocks(title="Advanced Cell Analysis Tool", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 🔬 Bioengineering Cell Analysis Tool
-    
-    Upload microscopy images to analyze cell properties:
-    - Automated cell detection
-    - Feature extraction (size, shape, intensity)
-    - Statistical analysis
-    
-    **Instructions:**
-    1. Upload an image containing cells
-    2. Wait for analysis to complete
-    3. Review results in three tabs:
-       - Detected cells visualization
-       - Statistical plots
-       - Detailed measurements table
+    # 🔬 Advanced Bioengineering Cell Analysis Tool
+    
+    ## Features
+    - 🔍 Automated cell detection and measurement
+    - 📊 Comprehensive statistical analysis
+    - 🎨 Multiple visualization options
+    - 📥 Downloadable results
+    
+    ## 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():
-        with gr.Column():
-            # Fixed the Image component configuration
+        with gr.Column(scale=1):
             input_image = gr.Image(
                 label="Upload Image",
                 type="numpy"
             )
+            transform_type = gr.Dropdown(
+                choices=["Original", "Grayscale", "Binary", "CLAHE"],
+                value="Original",
+                label="Image Transform"
+            )
             analyze_btn = gr.Button(
-                "Analyze Image", 
-                variant="primary"
+                "Analyze Image",
+                variant="primary",
+                size="lg"
             )
         
-        with gr.Column():
+        with gr.Column(scale=2):
             with gr.Tabs():
-                with gr.Tab("Detection Results"):
+                with gr.Tab("Analysis Results"):
                     output_image = gr.Image(
                         label="Detected Cells"
                     )
+                    gr.Markdown("*Green contours show detected cells, red numbers are cell IDs*")
+                
+                with gr.Tab("Image Transformations"):
+                    transformed_image = gr.Image(
+                        label="Transformed Image"
+                    )
+                    gr.Markdown("*Select different transformations from the dropdown menu*")
+                
                 with gr.Tab("Statistics"):
                     output_plot = gr.Plot(
                         label="Statistical Analysis"
                     )
-                with gr.Tab("Measurements"):
+                    gr.Markdown("*Hover over plots for detailed values*")
+                
+                with gr.Tab("Data"):
                     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,
-        inputs=input_image,
-        outputs=[output_image, output_plot, output_table]
+        inputs=[input_image, transform_type],
+        outputs=[output_image, transformed_image, output_plot, output_table]
     )
 
 # Launch the demo