app.py

import cv2
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
import base64
from datetime import datetime

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

def process_image(image, transform_type):
    """Process uploaded image and extract cell features"""
    try:
        if image is None:
            return [None]*4
        
        # Store original image for color transformations
        original_image = image.copy()
        
        # Convert to BGR for OpenCV processing
        if len(image.shape) == 3:
            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
        
        # 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)
        
        # Thresholding
        _, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
        
        # 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
        
        # 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
                # 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)
        
        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')
            
            df['circularity'].hist(ax=axes[0,1], bins=20, color='lightgreen', edgecolor='black')
            axes[0,1].set_title('Circularity Distribution')
            
            # Scatter plot
            axes[1,0].scatter(df['circularity'], df['mean_intensity'], alpha=0.6, c='purple')
            axes[1,0].set_title('Circularity vs Intensity')
            
            # Box plot
            df.boxplot(column=['area', 'circularity'], ax=axes[1,1])
        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
        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 (
            vis_img,
            transformed_img if transformed_img is not None else original_image,
            fig,
            df
        )
        
    except Exception as e:
        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:
    gr.Markdown("""
    # 🔬 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(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",
                size="lg"
            )
        
        with gr.Column(scale=2):
            with gr.Tabs():
                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"
                    )
                    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, transform_type],
        outputs=[output_image, transformed_image, output_plot, output_table]
    )

# Launch the demo
if __name__ == "__main__":
    try:
        demo.launch()
    except Exception as e:
        print(f"Error launching Gradio interface: {e}")