Upload 24 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+imgs/0a3c588e-bbbe-11e8-b2ba-ac1f6b6435d0_blue.png filter=lfs diff=lfs merge=lfs -text
+imgs/0a8caf00-bb9b-11e8-b2b9-ac1f6b6435d0_blue.png filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,591 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.patches import Rectangle
+from pathlib import Path
+from skimage import io, measure, color, segmentation
+import os
+import warnings
+from PIL import Image
+import pandas as pd
+
+try:
+    from cellpose import models
+    CELLPOSE_AVAILABLE = True
+except ImportError:
+    CELLPOSE_AVAILABLE = False
+
+try:
+    from ultralytics import YOLO
+    YOLO_AVAILABLE = True
+except ImportError:
+    YOLO_AVAILABLE = False
+
+# Configuration
+IMAGE_FOLDER = "./imgs"
+CSV_FILE = "train.csv"
+
+# Category names mapping (0-27)
+CATEGORY_NAMES = {
+    0: "Nucleoplasm", 1: "Nuclear membrane", 2: "Nucleoli",
+    3: "Nucleoli fibrillar center", 4: "Nuclear speckles", 5: "Nuclear bodies",
+    6: "Endoplasmic reticulum", 7: "Golgi apparatus", 8: "Peroxisomes",
+    9: "Endosomes", 10: "Lysosomes", 11: "Intermediate filaments",
+    12: "Actin filaments", 13: "Focal adhesion sites", 14: "Microtubules",
+    15: "Microtubule ends", 16: "Cytokinetic bridge", 17: "Mitotic spindle",
+    18: "Microtubule organizing center", 19: "Centrosome", 20: "Lipid droplets",
+    21: "Plasma membrane", 22: "Cell junctions", 23: "Mitochondria",
+    24: "Aggresome", 25: "Cytosol", 26: "Cytoplasmic bodies", 27: "Rods & rings"
+}
+
+# Global state
+class AppState:
+    def __init__(self):
+        self.image_files = []
+        self.selected_image = None
+        self.current_image = None
+        self.masks = None
+        self.cell_properties = []
+        self.cellpose_model = None
+        self.yolo_model = None
+        self.current_model_type = None
+        self.selected_cell = None
+        self.csv_data = None
+        self.image_categories = {}
+        
+state = AppState()
+
+def extract_image_id(filename):
+    """Extract image ID from filename."""
+    basename = os.path.basename(filename)
+    name_without_ext = os.path.splitext(basename)[0]
+    for color in ['_blue', '_green', '_red', '_yellow']:
+        if name_without_ext.endswith(color):
+            return name_without_ext.replace(color, '')
+    return name_without_ext
+
+def load_csv_data():
+    """Auto-load CSV file."""
+    if not os.path.exists(CSV_FILE):
+        return
+    
+    try:
+        state.csv_data = pd.read_csv(CSV_FILE)
+        state.image_categories = {}
+        
+        for _, row in state.csv_data.iterrows():
+            img_id = row['Id']
+            target = str(row['Target'])
+            category_indices = [int(x) for x in target.split()]
+            category_names = [CATEGORY_NAMES.get(idx, f"Unknown-{idx}") for idx in category_indices]
+            
+            state.image_categories[img_id] = {
+                'indices': category_indices,
+                'names': category_names
+            }
+    except Exception as e:
+        print(f"Could not load CSV: {e}")
+
+def scan_folder():
+    """Auto-scan folder for images."""
+    if not os.path.exists(IMAGE_FOLDER) or not os.path.isdir(IMAGE_FOLDER):
+        return None
+    
+    try:
+        extensions = {'.png', '.jpg', '.jpeg', '.tif', '.tiff', '.bmp'}
+        state.image_files = []
+        
+        for f in sorted(Path(IMAGE_FOLDER).iterdir()):
+            if f.suffix.lower() in extensions:
+                state.image_files.append(str(f))
+        
+        if len(state.image_files) == 0:
+            return None
+        
+        # Generate gallery
+        gallery_items = [(img, os.path.basename(img)) for img in state.image_files]
+        return gallery_items
+    except Exception as e:
+        print(f"Scan error: {e}")
+        return None
+
+def prepare_image_for_yolo(image):
+    """Convert grayscale to RGB for YOLO."""
+    if image.ndim == 2:
+        return np.stack([image, image, image], axis=-1)
+    elif image.ndim == 3 and image.shape[2] == 3:
+        return image
+    elif image.ndim == 3 and image.shape[2] == 1:
+        gray = image[:, :, 0]
+        return np.stack([gray, gray, gray], axis=-1)
+    return image
+
+def select_image_from_gallery(evt: gr.SelectData):
+    """Handle image selection from gallery."""
+    if not state.image_files or evt.index >= len(state.image_files):
+        return None, "Invalid selection", "", gr.update(choices=[])
+    
+    state.selected_image = state.image_files[evt.index]
+    
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            state.current_image = io.imread(state.selected_image)
+        
+        if state.current_image.dtype == np.uint16:
+            state.current_image = ((state.current_image / state.current_image.max()) * 255).astype(np.uint8)
+        
+        # Reset segmentation
+        state.masks = None
+        state.cell_properties = []
+        state.selected_cell = None
+        
+        # Get categories
+        categories_text = get_image_categories()
+        
+        # Show original image
+        fig = create_visualization(show_numbers=False)
+        
+        return fig, f"Loaded: {os.path.basename(state.selected_image)}", categories_text, gr.update(choices=[])
+    except Exception as e:
+        return None, f"Load failed: {str(e)}", "", gr.update(choices=[])
+
+def get_image_categories():
+    """Get category information for selected image."""
+    if not state.image_categories or not state.selected_image:
+        return ""
+    
+    img_id = extract_image_id(state.selected_image)
+    categories = state.image_categories.get(img_id)
+    
+    if categories:
+        result = "Image Categories\n" + "=" * 30 + "\n"
+        for idx, name in zip(categories['indices'], categories['names']):
+            result += f"[{idx}] {name}\n"
+        return result
+    return ""
+
+def run_cellpose_segmentation(model_type, diameter, use_gpu):
+    """Run Cellpose segmentation."""
+    if state.current_image is None:
+        return None, "No image selected", gr.update(choices=[])
+    
+    if not CELLPOSE_AVAILABLE:
+        return None, "Cellpose not installed", gr.update(choices=[])
+    
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            
+            # Parse diameter
+            if diameter == "auto":
+                diam = None
+            else:
+                try:
+                    diam = float(diameter)
+                except:
+                    diam = None
+            
+            # Load model
+            if state.cellpose_model is None or state.current_model_type != model_type:
+                state.cellpose_model = models.CellposeModel(
+                    gpu=use_gpu,
+                    model_type=model_type
+                )
+                state.current_model_type = model_type
+            
+            # Run segmentation
+            channels = [0, 0]
+            state.masks, flows, styles = state.cellpose_model.eval(
+                state.current_image,
+                diameter=diam,
+                channels=channels
+            )
+            
+            if state.masks is None or state.masks.max() == 0:
+                return None, "No cells detected", gr.update(choices=[])
+            
+            return finalize_segmentation()
+            
+    except Exception as e:
+        return None, f"Error: {str(e)}", gr.update(choices=[])
+
+def run_yolo_segmentation(model_path, confidence, iou, use_gpu):
+    """Run YOLO segmentation."""
+    if state.current_image is None:
+        return None, "No image selected", gr.update(choices=[])
+    
+    if not YOLO_AVAILABLE:
+        return None, "YOLO not installed", gr.update(choices=[])
+    
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            
+            # Load model
+            if state.yolo_model is None or state.current_model_type != model_path:
+                state.yolo_model = YOLO(model_path)
+                state.current_model_type = model_path
+            
+            device = 'cuda' if use_gpu else 'cpu'
+            yolo_image = prepare_image_for_yolo(state.current_image)
+            
+            # Run prediction
+            results = state.yolo_model.predict(
+                yolo_image,
+                conf=confidence,
+                iou=iou,
+                device=device,
+                verbose=False
+            )
+            
+            # Convert to masks
+            state.masks = yolo_results_to_masks(results[0])
+            
+            if state.masks is None or state.masks.max() == 0:
+                return None, "No objects detected", gr.update(choices=[])
+            
+            return finalize_segmentation()
+            
+    except Exception as e:
+        return None, f"Error: {str(e)}", gr.update(choices=[])
+
+def yolo_results_to_masks(result):
+    """Convert YOLO results to mask format."""
+    if result.masks is None:
+        return None
+    
+    h, w = state.current_image.shape[:2]
+    combined_mask = np.zeros((h, w), dtype=np.int32)
+    masks = result.masks.data.cpu().numpy()
+    
+    for idx, mask in enumerate(masks, start=1):
+        mask_resized = np.array(Image.fromarray(mask).resize((w, h), Image.NEAREST))
+        combined_mask[mask_resized > 0.5] = idx
+    
+    return combined_mask
+
+def finalize_segmentation():
+    """Finalize segmentation (common for both methods)."""
+    try:
+        if state.current_image.ndim == 3:
+            from skimage.color import rgb2gray
+            intensity = (rgb2gray(state.current_image) * 255).astype(np.uint8)
+        else:
+            intensity = state.current_image
+        
+        state.cell_properties = measure.regionprops(state.masks, intensity_image=intensity)
+        
+        # Create visualization
+        fig = create_visualization(show_numbers=False)
+        
+        # Create cell list
+        cell_list = [f"Cell {prop.label} | Area: {prop.area}px²" for prop in state.cell_properties]
+        
+        return fig, f"{state.masks.max()} cells detected", gr.update(choices=cell_list)
+        
+    except Exception as e:
+        return None, f"Error: {str(e)}", gr.update(choices=[])
+
+def create_visualization(show_numbers=False, highlight_cell=None):
+    """Create segmentation visualization."""
+    if state.current_image is None:
+        return None
+    
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            
+            fig, ax = plt.subplots(figsize=(8, 8))
+            
+            if state.masks is not None:
+                # Prepare display image
+                if state.current_image.ndim == 2:
+                    display_img = state.current_image
+                else:
+                    from skimage.color import rgb2gray
+                    display_img = (rgb2gray(state.current_image) * 255).astype(np.uint8)
+                
+                # Create overlay
+                overlay = color.label2rgb(state.masks, display_img, bg_label=0, alpha=0.4)
+                ax.imshow(overlay)
+                
+                # Add outlines
+                outlines = segmentation.find_boundaries(state.masks, mode='outer')
+                outline_img = np.zeros((*state.masks.shape, 4))
+                outline_img[outlines] = [1, 0, 0, 1]
+                ax.imshow(outline_img)
+                
+                # Show cell numbers
+                if show_numbers and state.cell_properties:
+                    for prop in state.cell_properties:
+                        cy, cx = prop.centroid
+                        ax.text(cx, cy, str(prop.label),
+                               color='yellow',
+                               fontsize=8,
+                               fontweight='bold',
+                               ha='center',
+                               va='center',
+                               bbox=dict(boxstyle='round,pad=0.3',
+                                       facecolor='black',
+                                       alpha=0.5,
+                                       edgecolor='yellow',
+                                       linewidth=1))
+                
+                # Highlight selected cell
+                if highlight_cell is not None:
+                    cell_mask = state.masks == highlight_cell
+                    cell_outline = segmentation.find_boundaries(cell_mask, mode='outer')
+                    highlight_img = np.zeros((*state.masks.shape, 4))
+                    highlight_img[cell_outline] = [1, 1, 0, 1]
+                    ax.imshow(highlight_img)
+                    
+                    for prop in state.cell_properties:
+                        if prop.label == highlight_cell:
+                            minr, minc, maxr, maxc = prop.bbox
+                            rect = Rectangle((minc, minr), maxc-minc, maxr-minr,
+                                            fill=False, edgecolor='yellow', linewidth=2)
+                            ax.add_patch(rect)
+                            break
+                
+                ax.set_title(f'Segmentation Overlay ({state.masks.max()} cells)')
+            else:
+                # Show original
+                if state.current_image.ndim == 2:
+                    ax.imshow(state.current_image, cmap='gray')
+                else:
+                    ax.imshow(state.current_image)
+                ax.set_title('Original Image')
+            
+            ax.axis('off')
+            plt.tight_layout()
+            return fig
+            
+    except Exception as e:
+        print(f"Visualization error: {e}")
+        return None
+
+def toggle_view(view_type, show_numbers):
+    """Toggle between original and overlay view."""
+    if view_type == "Original" and state.masks is not None:
+        # Show original without overlay
+        fig, ax = plt.subplots(figsize=(8, 8))
+        if state.current_image.ndim == 2:
+            ax.imshow(state.current_image, cmap='gray')
+        else:
+            ax.imshow(state.current_image)
+        ax.set_title('Original Image')
+        ax.axis('off')
+        plt.tight_layout()
+        return fig
+    else:
+        return create_visualization(show_numbers=show_numbers, highlight_cell=state.selected_cell)
+
+def toggle_cell_numbers(show_numbers):
+    """Toggle cell number display."""
+    if state.masks is None:
+        return None
+    fig = create_visualization(show_numbers=show_numbers, highlight_cell=state.selected_cell)
+    return fig
+
+def select_cell(cell_choice):
+    """Handle cell selection from dropdown."""
+    if not cell_choice or not state.cell_properties:
+        return None, ""
+    
+    try:
+        # Extract cell ID from choice string "Cell X | Area: Ypx²"
+        cell_id = int(cell_choice.split('|')[0].replace('Cell', '').strip())
+        state.selected_cell = cell_id
+        
+        # Find cell properties
+        for prop in state.cell_properties:
+            if prop.label == cell_id:
+                details = f"Cell {cell_id}\n"
+                details += "=" * 25 + "\n"
+                details += f"Area: {prop.area}px²\n"
+                details += f"Centroid: ({prop.centroid[1]:.0f}, {prop.centroid[0]:.0f})\n"
+                details += f"Eccentricity: {prop.eccentricity:.3f}\n"
+                details += f"Solidity: {prop.solidity:.3f}\n"
+                details += f"Intensity: {prop.mean_intensity:.1f}\n"
+                
+                # Add categories if available
+                categories = get_image_categories()
+                if categories:
+                    details += "\n" + categories
+                
+                # Update visualization
+                fig = create_visualization(show_numbers=False, highlight_cell=cell_id)
+                return fig, details
+        
+        return None, "Cell not found"
+    except Exception as e:
+        return None, f"Error: {str(e)}"
+
+def run_segmentation(method, cp_model, diameter, yolo_model, confidence, iou, use_gpu):
+    """Run segmentation based on selected method."""
+    if method == "Cellpose":
+        return run_cellpose_segmentation(cp_model, diameter, use_gpu)
+    else:
+        return run_yolo_segmentation(yolo_model, confidence, iou, use_gpu)
+
+def save_results():
+    """Save segmentation results."""
+    if state.masks is None:
+        return None, "No results to save"
+    
+    try:
+        import tempfile
+        temp_dir = tempfile.mkdtemp()
+        
+        base_name = Path(state.selected_image).stem if state.selected_image else "segmentation"
+        
+        # Save mask
+        mask_path = os.path.join(temp_dir, f"{base_name}_masks.npy")
+        np.save(mask_path, state.masks)
+        
+        # Save CSV
+        csv_path = os.path.join(temp_dir, f"{base_name}_measurements.csv")
+        with open(csv_path, 'w') as f:
+            f.write("ID,Area,Centroid_X,Centroid_Y,Eccentricity,Solidity,Mean_Intensity\n")
+            for prop in state.cell_properties:
+                f.write(f"{prop.label},{prop.area},{prop.centroid[1]:.1f},"
+                       f"{prop.centroid[0]:.1f},{prop.eccentricity:.3f},"
+                       f"{prop.solidity:.3f},{prop.mean_intensity:.1f}\n")
+        
+        return [mask_path, csv_path], "Results saved"
+    except Exception as e:
+        return None, f"Error: {str(e)}"
+
+# Initialize: Load CSV and scan folder
+load_csv_data()
+initial_gallery = scan_folder()
+
+# Create Gradio interface
+with gr.Blocks(title="Cell Segmentation Tool", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Cell Segmentation Application")
+    
+    with gr.Row():
+        # LEFT COLUMN - Image Gallery
+        with gr.Column(scale=1):
+            gr.Markdown("### Image Gallery")
+            
+            image_gallery = gr.Gallery(
+                value=initial_gallery,
+                label=f"{len(state.image_files)} images" if state.image_files else "No images",
+                show_label=True,
+                elem_id="gallery",
+                columns=1,
+                rows=None,
+                height=600,
+                object_fit="contain"
+            )
+            
+            status_text = gr.Textbox(label="Status", interactive=False)
+        
+        # CENTER COLUMN - Image View
+        with gr.Column(scale=2):
+            gr.Markdown("### Image View")
+            
+            with gr.Row():
+                view_mode = gr.Radio(
+                    ["Original", "Overlay"],
+                    value="Overlay",
+                    label="View Mode"
+                )
+                show_numbers = gr.Checkbox(label="Show Cell Numbers", value=False)
+            
+            image_display = gr.Plot(label="")
+        
+        # RIGHT COLUMN - Controls & Results
+        with gr.Column(scale=1):
+            gr.Markdown("### Segmentation Settings")
+            
+            method = gr.Radio(
+                ["Cellpose", "YOLO"],
+                label="Method",
+                value="Cellpose"
+            )
+            
+            # Cellpose controls
+            with gr.Group(visible=True) as cellpose_group:
+                cp_model = gr.Dropdown(
+                    ["nuclei", "cyto", "cyto2", "cyto3"],
+                    label="Cellpose Model",
+                    value="nuclei"
+                )
+                diameter = gr.Textbox(label="Diameter", value="auto")
+            
+            # YOLO controls
+            with gr.Group(visible=False) as yolo_group:
+                yolo_model = gr.Textbox(label="YOLO Model", value="yolov8n-seg.pt")
+                confidence = gr.Slider(0, 1, value=0.25, label="Confidence")
+                iou = gr.Slider(0, 1, value=0.45, label="IoU")
+            
+            use_gpu = gr.Checkbox(label="Use GPU", value=False)
+            
+            run_button = gr.Button("Run Segmentation", variant="primary", size="lg")
+            
+            gr.Markdown("### Detected Cells")
+            
+            cell_dropdown = gr.Dropdown(
+                label="Select Cell",
+                choices=[],
+                interactive=True
+            )
+            
+            gr.Markdown("### Cell Details")
+            cell_details = gr.Textbox(
+                label="",
+                lines=12,
+                interactive=False
+            )
+            
+            save_button = gr.Button("Save Results", variant="secondary")
+            output_files = gr.File(label="Download", file_count="multiple")
+    
+    # Event handlers
+    def toggle_method(method_choice):
+        return (
+            gr.update(visible=method_choice == "Cellpose"),
+            gr.update(visible=method_choice == "YOLO")
+        )
+    
+    method.change(toggle_method, inputs=[method], outputs=[cellpose_group, yolo_group])
+    
+    image_gallery.select(
+        select_image_from_gallery,
+        outputs=[image_display, status_text, cell_details, cell_dropdown]
+    )
+    
+    view_mode.change(
+        toggle_view,
+        inputs=[view_mode, show_numbers],
+        outputs=[image_display]
+    )
+    
+    show_numbers.change(
+        toggle_cell_numbers,
+        inputs=[show_numbers],
+        outputs=[image_display]
+    )
+    
+    run_button.click(
+        run_segmentation,
+        inputs=[method, cp_model, diameter, yolo_model, confidence, iou, use_gpu],
+        outputs=[image_display, status_text, cell_dropdown]
+    )
+    
+    cell_dropdown.change(
+        select_cell,
+        inputs=[cell_dropdown],
+        outputs=[image_display, cell_details]
+    )
+    
+    save_button.click(
+        save_results,
+        outputs=[output_files, status_text]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=False)

requirements.txt

@@ -0,0 +1,11 @@
+gradio
+numpy
+matplotlib
+scikit-image
+pandas
+Pillow
+cellpose
+torch
+torchvision
+ultralytics
+opencv-python-headless