updated stuf

.gitattributes

@@ -33,4 +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
+*.BMP filter=lfs diff=lfs merge=lfs -text
 *.tif filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1,6 +1,9 @@
 #!/usr/bin/env python3
 """
-Minimal Anton Streamlit App - Crash-Safe Version
+Anton Simple UI - Streamlit Web Interface
+
+Simple interface: Load image → Click analyze → See results
+Perfect for quick microscopy analysis with VLM and CMPO annotations.
 """
 
 import streamlit as st
@@ -9,12 +12,7 @@ import sys
 from pathlib import Path
 import numpy as np
 from PIL import Image
-import tempfile
-import traceback
-import gc  # Garbage collection
-
-# Configure PIL to handle large images better
-Image.MAX_IMAGE_PIXELS = None  # Remove PIL size limit
+import random
 
 # Setup page
 st.set_page_config(
@@ -23,148 +21,472 @@ st.set_page_config(
     layout="wide"
 )
 
+# Add Anton to path
+sys.path.append(str(Path(__file__).parent))
+
+# Import Anton components
+try:
+    from anton.core.pipeline import AnalysisPipeline
+    from anton.utils.image_io import ImageLoader
+    from anton.cmpo.mapping import map_to_cmpo
+    from anton.cmpo.ontology import CMPOOntology
+    anton_available = True
+except ImportError as e:
+    anton_available = False
+    import_error = str(e)
+
 # Header
 st.title("🔬 Anton Microscopy Analysis")
-st.markdown("**Simple Interface**: Upload image → See basic analysis")
+st.markdown("**Simple Interface**: Load image → Click analyze → See VLM analysis + CMPO phenotypes")
 
-# Debug info container
-debug_container = st.empty()
+# Add helpful info for cloud users
+st.info("💡 **Demo Mode**: Upload your own microscopy images to test the analysis pipeline. The app works with PNG, JPG, TIFF, and BMP formats.")
 
-# Sidebar
+# Check if Anton is available
+if not anton_available:
+    st.error(f"❌ Anton not available: {import_error}")
+    st.stop()
+
+# Sidebar for controls
 st.sidebar.header("🎛️ Controls")
 
-# Check API status
+# API Key check
 api_status = []
+vlm_provider = "mock"
+
 if os.getenv('GOOGLE_API_KEY'):
     api_status.append("✅ Google API Key")
+    vlm_provider = "gemini"
 elif os.getenv('ANTHROPIC_API_KEY'):
     api_status.append("✅ Anthropic API Key")
+    vlm_provider = "claude"
 else:
-    api_status.append("⚠️ No API key - demo mode")
+    api_status.append("⚠️ No API key - using mock")
 
 for status in api_status:
     st.sidebar.write(status)
 
-# Simple file upload with unique key - avoid st.rerun() issues
-st.sidebar.subheader("📁 Upload Image")
+st.sidebar.write(f"**VLM Provider**: {vlm_provider.upper()}")
 
-# Use session state to track upload state to avoid rerun issues
-if 'upload_key' not in st.session_state:
-    st.session_state.upload_key = 0
+# Dataset selection
+st.sidebar.subheader("📁 Image Source")
 
-uploaded_file = st.sidebar.file_uploader(
-    "Choose an image", 
-    type=['png', 'jpg', 'jpeg', 'tiff', 'bmp'],
-    help="Upload microscopy image",
-    key=f"image_uploader_{st.session_state.upload_key}"  # Dynamic key
-)
+# Check for sample images
+sample_images_path = Path("sample_images")
+sample_images_available = sample_images_path.exists()
 
-# Analysis button with unique key
-analyze_btn = st.sidebar.button("🚀 Analyze", type="primary", key="analyze_button")
+if sample_images_available:
+    # Get sample images
+    sample_images = sorted(list(sample_images_path.glob("*.BMP")))
+    if sample_images:
+        st.sidebar.success(f"✅ Sample Images ({len(sample_images)} available)")
+        
+        use_source = st.sidebar.radio("Select Source:", ["Sample Images", "Upload Image"])
+        
+        if use_source == "Sample Images":
+            # Image selector
+            image_names = [img.name for img in sample_images]
+            selected_image = st.sidebar.selectbox("Choose Sample Image:", image_names)
+            
+            if st.sidebar.button("🎲 Random Sample Image"):
+                selected_image = random.choice(image_names)
+                st.rerun()
+            
+            sample_image_path = sample_images_path / selected_image
+            uploaded_file = None
+        else:
+            sample_image_path = None
+            uploaded_file = st.sidebar.file_uploader(
+                "Upload Image", 
+                type=['png', 'jpg', 'jpeg', 'tiff', 'bmp'],
+                help="Upload your own microscopy image"
+            )
+    else:
+        sample_image_path = None
+        uploaded_file = st.sidebar.file_uploader(
+            "Upload Image", 
+            type=['png', 'jpg', 'jpeg', 'tiff', 'bmp'],
+            help="Upload your own microscopy image for analysis"
+        )
+else:
+    # Cloud deployment - sample images not available
+    st.sidebar.info("📁 Upload your own microscopy images")
+    sample_image_path = None
+    uploaded_file = st.sidebar.file_uploader(
+        "Upload Image", 
+        type=['png', 'jpg', 'jpeg', 'tiff', 'bmp'],
+        help="Upload your own microscopy image for analysis"
+    )
+
+# Analysis controls
+st.sidebar.subheader("🔬 Analysis")
+analyze_btn = st.sidebar.button("🚀 Analyze Image", type="primary", use_container_width=True)
 
-# Main content
+# Main content area
 col1, col2 = st.columns([1, 1])
 
-# Left: Image display
+# Left column: Image display
 with col1:
     st.subheader("🖼️ Image")
     
-    if uploaded_file is not None:
-        debug_msg = f"🐛 DEBUG: File uploaded - {uploaded_file.name}, size: {uploaded_file.size}"
-        print(debug_msg)
-        debug_container.info(debug_msg)
+    # Load and display image
+    current_image = None
+    image_to_analyze = None
+    
+    if sample_image_path and sample_image_path.exists():
+        # Sample image
         try:
-            # Reset file pointer to beginning (important!)
-            uploaded_file.seek(0)
-            print("DEBUG: File pointer reset to beginning")
-            
-            # Simple PIL loading - most reliable
-            image = Image.open(uploaded_file)
-            debug_msg2 = f"🐛 DEBUG: Image loaded successfully - size: {image.size}, mode: {image.mode}"
-            print(debug_msg2)
-            debug_container.success(debug_msg2)
-            
-            # Resize if too large (prevent memory issues)
-            max_size = (1024, 1024)
-            if image.size[0] > max_size[0] or image.size[1] > max_size[1]:
-                print(f"DEBUG: Resizing image from {image.size} to max {max_size}")
-                image.thumbnail(max_size, Image.Resampling.LANCZOS)
-                st.info(f"📏 Image resized to {image.size} for display")
-                print(f"DEBUG: Image resized to {image.size}")
-            
-            # Convert to RGB if needed
-            if image.mode != 'RGB':
-                image = image.convert('RGB')
-            
-            # Store in session state to prevent reprocessing
-            if 'current_image' not in st.session_state or st.session_state.get('uploaded_filename') != uploaded_file.name:
-                # Clear old image from memory
-                if 'current_image' in st.session_state:
-                    del st.session_state.current_image
-                    gc.collect()
+            loader = ImageLoader()
+            current_image = loader.load(str(sample_image_path))
+            image_to_analyze = str(sample_image_path)
+            
+            # Image display controls
+            col_img1, col_img2 = st.columns([3, 1])
+            
+            with col_img2:
+                st.markdown("**🔍 Display Options:**")
+                zoom_level = st.select_slider(
+                    "Zoom Level",
+                    options=[0.5, 0.75, 1.0, 1.5, 2.0, 3.0],
+                    value=1.0,
+                    help="Adjust image size"
+                )
+                
+                crop_enabled = st.checkbox("Enable Crop View", help="Show a cropped region of the image")
                 
-                st.session_state.current_image = image
-                st.session_state.uploaded_filename = uploaded_file.name
+                if crop_enabled:
+                    st.markdown("**Crop Region:**")
+                    crop_x = st.slider("X Start", 0, current_image.shape[1]-100, 0, step=10, key="sample_crop_x")
+                    crop_y = st.slider("Y Start", 0, current_image.shape[0]-100, 0, step=10, key="sample_crop_y")
+                    crop_size = st.slider("Crop Size", 100, min(current_image.shape), 200, step=10, key="sample_crop_size")
             
-            # Display image
-            st.image(st.session_state.current_image, caption=f"Uploaded: {uploaded_file.name}", width=400)
+            with col_img1:
+                # Apply zoom and crop
+                display_image = current_image.copy()
+                
+                if crop_enabled:
+                    # Crop the image
+                    x_end = min(crop_x + crop_size, current_image.shape[1])
+                    y_end = min(crop_y + crop_size, current_image.shape[0])
+                    display_image = current_image[crop_y:y_end, crop_x:x_end]
+                    caption_text = f"Sample: {sample_image_path.name} (Cropped)"
+                else:
+                    caption_text = f"Sample: {sample_image_path.name}"
+                
+                # Calculate display width based on zoom
+                base_width = 400
+                display_width = int(base_width * zoom_level)
+                
+                st.image(
+                    display_image, 
+                    caption=caption_text, 
+                    width=display_width,
+                    use_column_width=False
+                )
             
-            # Basic info
-            st.caption(f"Size: {st.session_state.current_image.size} | Mode: {st.session_state.current_image.mode}")
+            # Image info
+            if crop_enabled:
+                st.caption(f"Original Shape: {current_image.shape} | Crop Shape: {display_image.shape}")
+                st.caption(f"Crop Region: [{crop_x}:{crop_x+crop_size}, {crop_y}:{crop_y+crop_size}]")
+            else:
+                st.caption(f"Shape: {current_image.shape} | Type: {current_image.dtype}")
+                st.caption(f"Range: [{current_image.min():.0f}, {current_image.max():.0f}]")
             
         except Exception as e:
-            error_msg = f"🐛 DEBUG: Error loading image: {e}"
-            st.error(error_msg)
-            debug_container.error(error_msg)
-            # Don't show full traceback to users - just log it
-            print(f"Image loading error: {traceback.format_exc()}")
+            st.error(f"Error loading sample image: {e}")
+            
+    elif uploaded_file:
+        # Uploaded image
+        try:
+            # Use BytesIO to avoid file system issues in cloud deployment
+            from io import BytesIO
+            import tempfile
+            
+            # Create a temporary file that gets cleaned up automatically
+            with tempfile.NamedTemporaryFile(delete=False, suffix=f"_{uploaded_file.name}") as tmp_file:
+                tmp_file.write(uploaded_file.getbuffer())
+                temp_path = tmp_file.name
+            
+            # Try to load with ImageLoader first, fallback to PIL/OpenCV
+            try:
+                loader = ImageLoader()
+                current_image = loader.load(temp_path)
+            except Exception as loader_error:
+                st.warning(f"ImageLoader failed: {loader_error}, trying fallback...")
+                # Fallback to PIL
+                from PIL import Image
+                import numpy as np
+                pil_img = Image.open(temp_path)
+                current_image = np.array(pil_img)
+                if len(current_image.shape) == 3 and current_image.shape[2] == 3:
+                    # Convert RGB to grayscale for analysis
+                    current_image = np.mean(current_image, axis=2).astype(np.uint8)
+            image_to_analyze = temp_path
+            
+            # Image display controls
+            col_img1, col_img2 = st.columns([3, 1])
+            
+            with col_img2:
+                st.markdown("**🔍 Display Options:**")
+                zoom_level = st.select_slider(
+                    "Zoom Level",
+                    options=[0.5, 0.75, 1.0, 1.5, 2.0, 3.0],
+                    value=1.0,
+                    help="Adjust image size"
+                )
+                
+                crop_enabled = st.checkbox("Enable Crop View", help="Show a cropped region of the image")
+                
+                if crop_enabled:
+                    st.markdown("**Crop Region:**")
+                    crop_x = st.slider("X Start", 0, current_image.shape[1]-100, 0, step=10, key="upload_crop_x")
+                    crop_y = st.slider("Y Start", 0, current_image.shape[0]-100, 0, step=10, key="upload_crop_y")
+                    crop_size = st.slider("Crop Size", 100, min(current_image.shape), 200, step=10, key="upload_crop_size")
+            
+            with col_img1:
+                # Apply zoom and crop
+                display_image = current_image.copy()
+                
+                if crop_enabled:
+                    # Crop the image
+                    x_end = min(crop_x + crop_size, current_image.shape[1])
+                    y_end = min(crop_y + crop_size, current_image.shape[0])
+                    display_image = current_image[crop_y:y_end, crop_x:x_end]
+                    caption_text = f"Uploaded: {uploaded_file.name} (Cropped)"
+                else:
+                    caption_text = f"Uploaded: {uploaded_file.name}"
+                
+                # Calculate display width based on zoom
+                base_width = 400
+                display_width = int(base_width * zoom_level)
+                
+                st.image(
+                    display_image, 
+                    caption=caption_text, 
+                    width=display_width,
+                    use_column_width=False
+                )
+            
+            # Image info
+            if crop_enabled:
+                st.caption(f"Original Shape: {current_image.shape} | Crop Shape: {display_image.shape}")
+                st.caption(f"Crop Region: [{crop_x}:{crop_x+crop_size}, {crop_y}:{crop_y+crop_size}]")
+            else:
+                st.caption(f"Shape: {current_image.shape} | Type: {current_image.dtype}")
+                st.caption(f"Range: [{current_image.min():.0f}, {current_image.max():.0f}]")
+            
+        except Exception as e:
+            st.error(f"Error loading uploaded image: {e}")
+            st.info("Please try uploading a different image format (PNG, JPG, TIFF, BMP)")
+            # Clean up temp file if it exists
+            try:
+                if 'temp_path' in locals() and os.path.exists(temp_path):
+                    os.remove(temp_path)
+            except:
+                pass
     else:
-        st.info("👆 Upload an image to start")
+        if sample_images_available:
+            st.info("👆 Select a sample image or upload your own image to analyze")
+        else:
+            st.info("👆 Upload an image to analyze")
 
-# Right: Analysis results
+# Right column: Analysis results
 with col2:
     st.subheader("🧠 Analysis Results")
     
-    if analyze_btn and uploaded_file is not None:
-        print("DEBUG: Analysis button clicked")
+    # Run analysis when button is clicked
+    if analyze_btn and image_to_analyze:
+        
+        # Progress indicator
+        progress_bar = st.progress(0, text="Starting analysis...")
+        
         try:
-            # Simple mock analysis to test if basic functionality works
-            st.success("✅ Analysis Started!")
-            print("DEBUG: Analysis started successfully")
-            
-            with st.spinner("Processing..."):
-                # Mock processing
-                import time
-                print("DEBUG: Starting mock processing...")
-                time.sleep(2)
-                print("DEBUG: Mock processing complete")
-            
-            # Mock results
-            st.markdown("### 📊 Mock Analysis Results")
-            
-            st.write("**Stage 1: Global Analysis**")
-            st.text_area("Description:", 
-                "Mock analysis: This appears to be a microscopy image with cellular structures. "
-                "The image shows good contrast and appears suitable for analysis.", 
-                height=100)
-            
-            st.write("**Stage 2: Object Detection**")
-            st.text_area("Objects:", 
-                "Mock detection: Multiple cellular objects detected. "
-                "Estimated cell count: 15-25 cells visible.", 
-                height=100)
-            
-            st.success("✅ Mock analysis complete!")
+            # Configure pipeline based on image source
+            if sample_image_path:
+                # BBBC013 dataset context
+                biological_context = {
+                    "experiment_type": "protein_translocation",
+                    "cell_line": "U2OS_osteosarcoma", 
+                    "protein": "FKHR-GFP",
+                    "drugs": ["Wortmannin", "LY294002"],
+                    "readout": "nuclear_vs_cytoplasmic_localization",
+                    "channels": ["FKHR-GFP", "DNA_DRAQ"]
+                }
+            else:
+                # General microscopy context for uploaded images
+                biological_context = {
+                    "experiment_type": "general_microscopy",
+                    "cell_line": "unknown", 
+                    "readout": "cellular_morphology_and_phenotypes",
+                    "channels": ["brightfield"]
+                }
+            
+            config = {
+                "vlm_provider": vlm_provider, 
+                "channels": [0],
+                "biological_context": biological_context
+            }
+            
+            progress_bar.progress(20, text="Initializing pipeline...")
+            
+            # Initialize and run pipeline
+            pipeline = AnalysisPipeline(config)
             
+            progress_bar.progress(40, text="Running VLM analysis...")
+            results = pipeline.run_pipeline_sync(image_to_analyze)
+            
+            progress_bar.progress(80, text="Processing CMPO mappings...")
+            
+            # Display results
+            progress_bar.progress(100, text="Analysis complete!")
+            
+            # Clear progress bar
+            progress_bar.empty()
+            
+            # Create tabs for results
+            tab1, tab2 = st.tabs(["🧠 VLM Analysis", "🧬 CMPO Phenotypes"])
+            
+            with tab1:
+                st.markdown("### VLM Analysis Results")
+                
+                # Display each stage
+                stages = [
+                    ("Stage 1: Global Scene", "stage_1_global"),
+                    ("Stage 2: Object Detection", "stage_2_objects"), 
+                    ("Stage 3: Feature Analysis", "stage_3_features"),
+                    ("Stage 4: Population Insights", "stage_4_population")
+                ]
+                
+                for stage_name, stage_key in stages:
+                    if stage_key in results and results[stage_key]:
+                        with st.expander(f"📋 {stage_name}", expanded=(stage_key == "stage_1_global")):
+                            stage_data = results[stage_key]
+                            
+                            # Extract content for display
+                            if 'description' in stage_data:
+                                content = stage_data['description']
+                            elif 'segmentation_guidance' in stage_data:
+                                content = stage_data['segmentation_guidance']
+                            elif 'population_summary' in stage_data:
+                                content = stage_data['population_summary']
+                            else:
+                                content = f"Stage completed. Keys: {list(stage_data.keys())}"
+                            
+                            # Clean up content for display
+                            if content.startswith('```'):
+                                lines = content.split('\n')
+                                content = '\n'.join([line for line in lines if not line.strip().startswith('```')])
+                            
+                            st.text_area(
+                                f"{stage_name} Results:",
+                                content[:2000] + "\n\n[Truncated for display...]" if len(content) > 2000 else content,
+                                height=200,
+                                key=f"text_{stage_key}"
+                            )
+            
+            with tab2:
+                st.markdown("### CMPO Phenotype Classifications")
+                
+                try:
+                    cmpo_mapper = CMPOOntology()
+                    all_cmpo_results = []
+                    
+                    # Test CMPO mapping on all stages
+                    for stage_name, stage_key in stages:
+                        if stage_key in results and results[stage_key]:
+                            stage_data = results[stage_key]
+                            
+                            # Extract text for CMPO mapping
+                            stage_text = ""
+                            if 'description' in stage_data:
+                                stage_text = stage_data['description']
+                            elif 'segmentation_guidance' in stage_data:
+                                stage_text = stage_data['segmentation_guidance']
+                            elif 'population_summary' in stage_data:
+                                stage_text = stage_data['population_summary']
+                            
+                            if stage_text and len(stage_text) > 50:
+                                # Clean JSON formatting
+                                if '```' in stage_text:
+                                    lines = stage_text.split('\n')
+                                    stage_text = '\n'.join([line for line in lines if not line.strip().startswith('```')])
+                                
+                                # Use appropriate CMPO context
+                                cmpo_context = 'protein_localization' if sample_image_path else 'general_microscopy'
+                                cmpo_results = map_to_cmpo(stage_text, cmpo_mapper, context=cmpo_context)
+                                
+                                if cmpo_results:
+                                    st.markdown(f"**{stage_name}:**")
+                                    
+                                    for i, mapping in enumerate(cmpo_results[:3]):  # Top 3 per stage
+                                        term_name = mapping.get('term_name', 'Unknown')
+                                        confidence = mapping.get('confidence', 0)
+                                        cmpo_id = mapping.get('CMPO_ID', 'Unknown')
+                                        
+                                        # Color code by confidence
+                                        if confidence >= 4.5:
+                                            color = "green"
+                                            icon = "🟢"
+                                        elif confidence >= 3.5:
+                                            color = "orange"
+                                            icon = "🟡"
+                                        else:
+                                            color = "red"
+                                            icon = "🟠"
+                                        
+                                        st.markdown(f"{icon} **{term_name}**")
+                                        st.caption(f"Confidence: {confidence:.2f} | ID: {cmpo_id}")
+                                    
+                                    all_cmpo_results.extend(cmpo_results)
+                                    st.markdown("---")
+                    
+                    # Summary
+                    if all_cmpo_results:
+                        st.markdown("### 📊 Summary")
+                        col_a, col_b = st.columns(2)
+                        
+                        with col_a:
+                            st.metric("Total CMPO Terms", len(all_cmpo_results))
+                        with col_b:
+                            unique_terms = len(set(m.get('CMPO_ID') for m in all_cmpo_results))
+                            st.metric("Unique Terms", unique_terms)
+                        
+                        # Top terms overall
+                        st.markdown("**🏆 Top Phenotypes Overall:**")
+                        top_terms = sorted(all_cmpo_results, key=lambda x: x.get('confidence', 0), reverse=True)[:5]
+                        
+                        for i, term in enumerate(top_terms, 1):
+                            name = term.get('term_name', 'Unknown')
+                            conf = term.get('confidence', 0)
+                            st.write(f"{i}. **{name}** ({conf:.2f})")
+                    
+                    else:
+                        st.warning("No CMPO phenotypes identified in the analysis.")
+                        
+                except Exception as e:
+                    st.error(f"CMPO mapping failed: {e}")
+            
+            # Clean up temp file if it exists
+            if uploaded_file and 'temp_path' in locals():
+                try:
+                    if os.path.exists(temp_path):
+                        os.remove(temp_path)
+                except:
+                    pass
+                
         except Exception as e:
-            st.error(f"Analysis failed: {e}")
-            st.code(traceback.format_exc())
+            progress_bar.empty()
+            st.error(f"Analysis failed: {str(e)}")
+            import traceback
+            with st.expander("Error Details"):
+                st.code(traceback.format_exc())
     
     elif analyze_btn:
-        st.warning("Please upload an image first!")
+        st.warning("Please select or upload an image first!")
+    
     else:
-        st.info("👈 Upload image and click Analyze")
+        st.info("👈 Click 'Analyze Image' to start analysis")
 
 # Footer
 st.markdown("---")
-st.markdown("🔬 **Anton Framework** - Minimal Demo Version")
+st.markdown("🔬 **Anton Framework** - Hybrid Microscopy Analysis with VLM + Computer Vision")

requirements.txt

@@ -1,5 +1,13 @@
-altair
 pandas
-streamlit
-Pillow
-numpy
+numpy
+scikit-image
+pillow
+opencv-python
+scipy
+requests
+google-generativeai
+anthropic
+python-dotenv
+streamlit==1.30.0
+plotly
+networkx