Update app.py

app.py

@@ -54,7 +54,7 @@ load_models()
 # --- Helpers ---
 
 def load_excel_data(logs_text):
-    """Finds and loads the Excel report."""
+    """Finds and loads the Excel report, transposing for better display."""
     placeholder = pd.DataFrame({"Status": ["No Data Available"]})
     candidates = glob.glob("/tmp/*.xlsx") + glob.glob("*.xlsx")
     
@@ -65,9 +65,29 @@ def load_excel_data(logs_text):
     
     try:
         xls = pd.ExcelFile(report_file, engine='openpyxl')
-        morph = pd.read_excel(xls, "Morphology") if "Morphology" in xls.sheet_names else placeholder
-        spatial = pd.read_excel(xls, "Spatial") if "Spatial" in xls.sheet_names else placeholder
-        relational = pd.read_excel(xls, "Relational") if "Relational" in xls.sheet_names else placeholder
+        
+        # Read and transpose tables for better horizontal display
+        if "Morphology" in xls.sheet_names:
+            morph = pd.read_excel(xls, "Morphology").T
+            morph.columns = morph.iloc[0]  # Set first row as column headers
+            morph = morph.drop(morph.index[0])  # Remove the header row
+        else:
+            morph = placeholder
+            
+        if "Spatial" in xls.sheet_names:
+            spatial = pd.read_excel(xls, "Spatial").T
+            spatial.columns = spatial.iloc[0]
+            spatial = spatial.drop(spatial.index[0])
+        else:
+            spatial = placeholder
+            
+        if "Relational" in xls.sheet_names:
+            relational = pd.read_excel(xls, "Relational").T
+            relational.columns = relational.iloc[0]
+            relational = relational.drop(relational.index[0])
+        else:
+            relational = placeholder
+            
         return report_file, morph, spatial, relational
     except Exception as e:
         print(f"⚠️ Error reading Excel: {e}")
@@ -82,13 +102,42 @@ def get_available_layers():
         layers.append(name)
     return sorted(layers)
 
-def generate_overlay(image_path_str, selected_layers):
-    """Regenerates the AnnotatedImage based on selected layers."""
+def update_opacity_sliders(layers):
+    """Returns updated slider configurations based on available layers."""
+    updates = []
+    for i in range(4):  # We have 4 sliders
+        if i < len(layers):
+            layer_name = layers[i].replace("_", " ").title()
+            updates.append(gr.update(visible=True, label=f"{layer_name} Opacity", value=0.6))
+        else:
+            updates.append(gr.update(visible=False))
+    return updates
+
+def collect_layer_opacities(layers, op1, op2, op3, op4):
+    """Collects opacity values into a dictionary."""
+    opacities = {}
+    opacity_values = [op1, op2, op3, op4]
+    for i, layer in enumerate(layers[:4]):  # Only use first 4 layers
+        opacities[layer] = opacity_values[i]
+    return opacities
+
+def generate_overlay(image_path_str, selected_layers, layer_opacities=None):
+    """Regenerates the overlay image with adjustable opacity for each layer."""
     if not image_path_str:
         return None
     
-    base_image = Image.open(image_path_str).convert("RGB")
-    annotations = []
+    base_image = Image.open(image_path_str).convert("RGBA")
+    
+    # Default colors for different layers (can expand as needed)
+    color_map = {
+        "green_cell": (0, 255, 0),
+        "blue_nucleus": (0, 0, 255),
+        "cell": (0, 255, 0),
+        "nucleus": (0, 0, 255),
+    }
+    
+    # Create overlay layer
+    overlay = Image.new('RGBA', base_image.size, (0, 0, 0, 0))
     
     for layer_name in selected_layers:
         file_path = f"/tmp/data_{layer_name}.npz"
@@ -105,15 +154,34 @@ def generate_overlay(image_path_str, selected_layers):
                     
                     # Resize if mask dimensions differ from image
                     h_mask, w_mask = combined_mask.shape
-                    if base_image.size != (w_mask, h_mask):
+                    if overlay.size != (w_mask, h_mask):
+                        overlay = overlay.resize((w_mask, h_mask), Image.Resampling.LANCZOS)
                         base_image = base_image.resize((w_mask, h_mask), Image.Resampling.LANCZOS)
 
                     combined_mask = combined_mask.astype(bool)
-                    annotations.append((combined_mask, layer_name.replace("_", " ").title()))
+                    
+                    # Get color for this layer
+                    color = color_map.get(layer_name.lower(), (255, 255, 0))  # Default to yellow
+                    
+                    # Get opacity (default 0.5)
+                    opacity = 0.5
+                    if layer_opacities and layer_name in layer_opacities:
+                        opacity = layer_opacities[layer_name]
+                    
+                    # Create colored mask with opacity
+                    mask_overlay = np.zeros((*combined_mask.shape, 4), dtype=np.uint8)
+                    mask_overlay[combined_mask] = (*color, int(255 * opacity))
+                    
+                    # Composite onto overlay
+                    mask_image = Image.fromarray(mask_overlay, 'RGBA')
+                    overlay = Image.alpha_composite(overlay, mask_image)
+                    
             except Exception as e:
                 print(f"Error loading layer {layer_name}: {e}")
 
-    return (base_image, annotations)
+    # Composite overlay onto base image
+    result = Image.alpha_composite(base_image, overlay)
+    return result.convert("RGB")
 
 
 # --- Core Logic ---
@@ -124,10 +192,11 @@ async def run_analysis(image_path_str, user_prompt, session_id_state):
     Updates the global ACTIVE_RUNNER and returns a session ID.
     """
     waiting_df = pd.DataFrame({"Status": ["Waiting..."]})
+    empty_slider_updates = [gr.update()] * 4  # Placeholder for 4 sliders
     
     if not image_path_str:
         # Return empty state
-        yield [], None, None, [], None, waiting_df, waiting_df, waiting_df
+        yield [], None, None, [], None, waiting_df, waiting_df, waiting_df, *empty_slider_updates
         return
 
     # Cleanup previous run files
@@ -179,7 +248,7 @@ async def run_analysis(image_path_str, user_prompt, session_id_state):
             {"role": "assistant", "content": full_log}
         ]
 
-    yield yield_status(logs), session_id, None, [], None, waiting_df, waiting_df, waiting_df
+    yield yield_status(logs), session_id, None, [], None, waiting_df, waiting_df, waiting_df, *empty_slider_updates
     try:
         async for event in ACTIVE_RUNNER.run_async(user_id="demo_user", session_id=session.id, new_message=content):
             author = event.author
@@ -187,7 +256,7 @@ async def run_analysis(image_path_str, user_prompt, session_id_state):
             if event.get_function_calls():
                 for fc in event.get_function_calls():
                     logs.append(f"🔧 **{author}**: Calling `{fc.name}`")
-                    yield yield_status(logs), session_id, None, [], None, waiting_df, waiting_df, waiting_df
+                    yield yield_status(logs), session_id, None, [], None, waiting_df, waiting_df, waiting_df, *empty_slider_updates
             
             if event.content and event.content.parts:
                 for part in event.content.parts:
@@ -203,16 +272,16 @@ async def run_analysis(image_path_str, user_prompt, session_id_state):
                             else:
                                 logs.append(f"✅ **{author}**: {part.text}")
             
-            yield yield_status(logs), session_id, None, [], None, waiting_df, waiting_df, waiting_df
+            yield yield_status(logs), session_id, None, [], None, waiting_df, waiting_df, waiting_df, *empty_slider_updates
 
     except Exception as e:
         logs.append(f"❌ Error: {e}")
-        yield yield_status(logs), session_id, None, [], None, waiting_df, waiting_df, waiting_df
+        yield yield_status(logs), session_id, None, [], None, waiting_df, waiting_df, waiting_df, *empty_slider_updates
         return
 
     # Finalize
     logs.append("\n🏁 Analysis Complete. Loading results...")
-    yield yield_status(logs), session_id, None, [], None, waiting_df, waiting_df, waiting_df
+    yield yield_status(logs), session_id, None, [], None, waiting_df, waiting_df, waiting_df, *empty_slider_updates
     
     await asyncio.sleep(0.5) 
     
@@ -227,7 +296,8 @@ async def run_analysis(image_path_str, user_prompt, session_id_state):
         {"role": "user", "content": user_prompt},
         {"role": "assistant", "content": full_log_text}
     ]
-    yield final_history, session_id, initial_overlay, gr.CheckboxGroup(choices=layers, value=layers), report_file, df_m, df_s, df_r
+    slider_updates = update_opacity_sliders(layers)
+    yield final_history, session_id, initial_overlay, gr.CheckboxGroup(choices=layers, value=layers), report_file, df_m, df_s, df_r, *slider_updates
 
 
 async def run_qa_turn(user_message, history, session_id):
@@ -283,12 +353,13 @@ with gr.Blocks(title="Cellemetry Agent") as demo:
     # State to hold the session ID
     session_id_state = gr.State(None)
     current_image_path = gr.State()
+    layer_opacity_state = gr.State({})  # Store opacity values per layer
 
     gr.Markdown("## 🔬 Cellemetry: Agentic Microscopy Analysis")
     
     with gr.Row():
         
-        # --- LEFT COLUMN ---
+        # --- LEFT COLUMN (1/3) ---
         with gr.Column(scale=1):
             gr.Markdown("### 1. Configuration")
             img_input = gr.Image(type="filepath", label="Microscopy Image", height=300)
@@ -301,65 +372,97 @@ with gr.Blocks(title="Cellemetry Agent") as demo:
             
             run_btn = gr.Button("🧪 Run Analysis", variant="primary", size="lg")
             
-            gr.Markdown("### 3. Interactive Results")
-            # 2. REMOVED 'type="tuples"' from Chatbot
+            gr.Markdown("### 2. Agent Conversation")
             chatbot = gr.Chatbot(
-                label="Agent Conversation", 
+                label="Live Analysis", 
                 height=400, 
                 elem_id="chatbot"
-                # type="messages" is now the default
             )
             qa_input = gr.Textbox(
                 label="Ask a follow-up question", 
                 placeholder="e.g. 'What was the average cell area?'"
             )
 
-        # --- RIGHT COLUMN ---
+        # --- RIGHT COLUMN (2/3) WITH TABS ---
         with gr.Column(scale=2):
-            
-            # UPPER PANEL
-            gr.Markdown("### 2. Interactive Segmentation")
-            with gr.Row():
-                with gr.Column(scale=3):
-                    overlay_output = gr.AnnotatedImage(
-                        label="Segmentation Result", 
-                        height=500,
-                        color_map={"Green Cell": "#00ff00", "Blue Nucleus": "#0000ff"}
-                    )
-                with gr.Column(scale=1):
-                    layer_checkboxes = gr.CheckboxGroup(
-                        label="Visible Layers",
-                        choices=[], 
-                        value=[],
-                        interactive=True
-                    )
-            
-            # BOTTOM PANEL
-            gr.Markdown("### 4. Quantitative Results")
             with gr.Tabs():
-                with gr.Tab("Morphology"):
-                    tbl_morph = gr.Dataframe(interactive=False)
-                with gr.Tab("Spatial"):
-                    tbl_spatial = gr.Dataframe(interactive=False)
-                with gr.Tab("Relational"):
-                    tbl_rel = gr.Dataframe(interactive=False)
-            
-            download_btn = gr.File(label="Download Excel Report")
+                # TAB 1: Overlays
+                with gr.Tab("🔍 Segmentation"):
+                    with gr.Row():
+                        with gr.Column(scale=3):
+                            overlay_output = gr.Image(
+                                label="Segmentation Result", 
+                                height=600,
+                                type="pil"
+                            )
+                        with gr.Column(scale=1):
+                            gr.Markdown("**Layer Controls**")
+                            layer_checkboxes = gr.CheckboxGroup(
+                                label="Visible Layers",
+                                choices=[], 
+                                value=[],
+                                interactive=True
+                            )
+                            gr.Markdown("**Opacity Controls**")
+                            # Pre-create sliders for common layer types
+                            opacity_slider_1 = gr.Slider(
+                                minimum=0, maximum=1, value=0.6, step=0.1,
+                                label="Layer 1 Opacity", visible=False
+                            )
+                            opacity_slider_2 = gr.Slider(
+                                minimum=0, maximum=1, value=0.6, step=0.1,
+                                label="Layer 2 Opacity", visible=False
+                            )
+                            opacity_slider_3 = gr.Slider(
+                                minimum=0, maximum=1, value=0.6, step=0.1,
+                                label="Layer 3 Opacity", visible=False
+                            )
+                            opacity_slider_4 = gr.Slider(
+                                minimum=0, maximum=1, value=0.6, step=0.1,
+                                label="Layer 4 Opacity", visible=False
+                            )
+                
+                # TAB 2: Data Tables
+                with gr.Tab("📊 Quantitative Results"):
+                    download_btn = gr.File(label="Download Excel Report")
+                    with gr.Tabs():
+                        with gr.Tab("Morphology"):
+                            tbl_morph = gr.Dataframe(interactive=False, wrap=True)
+                        with gr.Tab("Spatial"):
+                            tbl_spatial = gr.Dataframe(interactive=False, wrap=True)
+                        with gr.Tab("Relational"):
+                            tbl_rel = gr.Dataframe(interactive=False, wrap=True)
 
     # --- Event Wiring ---
 
+    # Wrapper function to regenerate overlay with opacity
+    def regenerate_overlay_with_opacity(img_path, selected_layers, op1, op2, op3, op4):
+        if not img_path or not selected_layers:
+            return None
+        # Map slider values to selected layers
+        opacities = {}
+        opacity_values = [op1, op2, op3, op4]
+        all_layers = get_available_layers()
+        for i, layer in enumerate(all_layers[:4]):
+            opacities[layer] = opacity_values[i]
+        return generate_overlay(img_path, selected_layers, opacities)
+
     run_btn.click(
         fn=run_analysis,
         inputs=[img_input, prompt_input, session_id_state],
         outputs=[
             chatbot,            # Output to Chatbot
             session_id_state,   # Save Session ID
-            overlay_output,     # Annotated Image
+            overlay_output,     # Image
             layer_checkboxes,   # Checkbox Options
             download_btn,       # Excel File
             tbl_morph,          # Tables...
             tbl_spatial,
-            tbl_rel
+            tbl_rel,
+            opacity_slider_1,   # Opacity sliders
+            opacity_slider_2,
+            opacity_slider_3,
+            opacity_slider_4
         ]
     )
     
@@ -372,11 +475,13 @@ with gr.Blocks(title="Cellemetry Agent") as demo:
     
     img_input.change(lambda x: x, inputs=img_input, outputs=current_image_path)
 
-    layer_checkboxes.change(
-        fn=generate_overlay,
-        inputs=[current_image_path, layer_checkboxes],
-        outputs=[overlay_output]
-    )
+    # Update overlay when checkboxes or sliders change
+    for component in [layer_checkboxes, opacity_slider_1, opacity_slider_2, opacity_slider_3, opacity_slider_4]:
+        component.change(
+            fn=regenerate_overlay_with_opacity,
+            inputs=[current_image_path, layer_checkboxes, opacity_slider_1, opacity_slider_2, opacity_slider_3, opacity_slider_4],
+            outputs=[overlay_output]
+        )
 
 if __name__ == "__main__":
     # 3. ADDED 'theme' to launch()