Update app.py

app.py

@@ -19,6 +19,7 @@ loaded_models = {}
 # Global variable for region coordinates (can remain global if only for info display)
 current_region_coords = None
 
+'''
 def debug_editor_data(editor_data):
     """Debug function to understand the structure of ImageEditor data"""
     if editor_data is None:
@@ -39,7 +40,8 @@ def debug_editor_data(editor_data):
         if hasattr(editor_data, 'size'):
             info += f"Size: {editor_data.size}\n"
             info += f"Mode: {editor_data.mode}\n"
-    return info
+    return info 
+'''
 
 def extract_region_from_editor(editor_data):
     """Extract the selected region from ImageEditor data"""
@@ -47,23 +49,23 @@ def extract_region_from_editor(editor_data):
         print("DEBUG: extract_region_from_editor - editor_data is None")
         return None, None
     
-    print(f"DEBUG: extract_region_from_editor - editor_data type: {type(editor_data)}")
+    #print(f"DEBUG: extract_region_from_editor - editor_data type: {type(editor_data)}")
     
     if isinstance(editor_data, dict):
         background = editor_data.get('background')
         layers = editor_data.get('layers', [])
         
         if background is None:
-            print("DEBUG: extract_region_from_editor - background is None")
+            #print("DEBUG: extract_region_from_editor - background is None")
             return None, None
         
         background_np = np.array(background)
-        print(f"DEBUG: extract_region_from_editor - background_np shape: {background_np.shape}")
+        #print(f"DEBUG: extract_region_from_editor - background_np shape: {background_np.shape}")
         
         if layers and len(layers) > 0:
             selection_layer = layers[0]
             selection_np = np.array(selection_layer)
-            print(f"DEBUG: extract_region_from_editor - selection_np shape: {selection_np.shape}")
+            #print(f"DEBUG: extract_region_from_editor - selection_np shape: {selection_np.shape}")
             
             if len(selection_np.shape) == 3:
                 if selection_np.shape[2] == 4:  # RGBA
@@ -86,17 +88,17 @@ def extract_region_from_editor(editor_data):
                 x_max = min(w, x_max + pad)
                 
                 region = background_np[y_min:y_max+1, x_min:x_max+1]
-                print(f"DEBUG: extract_region_from_editor - Extracted region shape: {region.shape}")
+                #print(f"DEBUG: extract_region_from_editor - Extracted region shape: {region.shape}")
                 return region, (x_min, y_min, x_max, y_max)
-        print("DEBUG: extract_region_from_editor - No selection or empty selection, returning full background.")
+        #print("DEBUG: extract_region_from_editor - No selection or empty selection, returning full background.")
         return background_np, None
     else: # Assuming it's a direct PIL Image if not dict
         if hasattr(editor_data, 'size'):
             image_np = np.array(editor_data)
-            print(f"DEBUG: extract_region_from_editor - Direct PIL image, shape: {image_np.shape}")
+            #print(f"DEBUG: extract_region_from_editor - Direct PIL image, shape: {image_np.shape}")
             return image_np, None
         else:
-            print("DEBUG: extract_region_from_editor - editor_data is not dict and no size attribute, returning None.")
+            #print("DEBUG: extract_region_from_editor - editor_data is not dict and no size attribute, returning None.")
             return None, None
 
 def calculate_blue_intensity(image_np, masks):
@@ -113,9 +115,9 @@ def calculate_blue_intensity(image_np, masks):
     cell_blue_intensities = {}
     unique_cells = np.unique(masks)
     
-    print(f"DEBUG: Found {len(unique_cells)} unique mask values: {unique_cells}")
-    print(f"DEBUG: Image shape: {image_np.shape}, dtype: {image_np.dtype}")
-    print(f"DEBUG: Masks shape: {masks.shape}, dtype: {masks.dtype}")
+    #print(f"DEBUG: Found {len(unique_cells)} unique mask values: {unique_cells}")
+    #print(f"DEBUG: Image shape: {image_np.shape}, dtype: {image_np.dtype}")
+    #print(f"DEBUG: Masks shape: {masks.shape}, dtype: {masks.dtype}")
     
     for cell_id in unique_cells:
         if cell_id == 0:  # Skip background
@@ -128,8 +130,8 @@ def calculate_blue_intensity(image_np, masks):
             # Calculate mean blue intensity (blue channel is index 2)
             blue_intensity = np.mean(cell_pixels[:, 2])  # Blue channel
             cell_blue_intensities[cell_id] = blue_intensity
-            print(f"DEBUG: Cell {cell_id}: {len(cell_pixels)} pixels, blue intensity: {blue_intensity:.2f}") # Too verbose, uncomment if needed
-    print(f"DEBUG: Total cells with blue intensity: {len(cell_blue_intensities)}")
+            #print(f"DEBUG: Cell {cell_id}: {len(cell_pixels)} pixels, blue intensity: {blue_intensity:.2f}") # Too verbose, uncomment if needed
+    #print(f"DEBUG: Total cells with blue intensity: {len(cell_blue_intensities)}")
     return cell_blue_intensities
 
 def create_viability_overlay(image_np, masks, blue_threshold):
@@ -139,8 +141,8 @@ def create_viability_overlay(image_np, masks, blue_threshold):
         print("DEBUG: create_viability_overlay - masks or image_np is None, returning None.")
         return None, 0, 0
     
-    print(f"DEBUG: create_viability_overlay called with threshold: {blue_threshold}")
-    print(f"DEBUG: Image shape: {image_np.shape}, Masks shape: {masks.shape}, Masks max: {masks.max()}")
+    #print(f"DEBUG: create_viability_overlay called with threshold: {blue_threshold}")
+    #print(f"DEBUG: Image shape: {image_np.shape}, Masks shape: {masks.shape}, Masks max: {masks.max()}")
     
     # Ensure image is RGB
     if len(image_np.shape) == 2:
@@ -151,7 +153,7 @@ def create_viability_overlay(image_np, masks, blue_threshold):
     # Calculate blue intensities
     cell_blue_intensities = calculate_blue_intensity(image_np, masks)
     
-    print(f"DEBUG: Got {len(cell_blue_intensities)} cells with blue intensities")
+    #print(f"DEBUG: Got {len(cell_blue_intensities)} cells with blue intensities")
     
     # Create overlay - start with original image
     overlay = image_np.copy().astype(np.float32)
@@ -163,19 +165,19 @@ def create_viability_overlay(image_np, masks, blue_threshold):
     for cell_id, blue_intensity in cell_blue_intensities.items():
         cell_mask = masks == cell_id
         
-        print(f"DEBUG: Processing cell {cell_id}, blue intensity: {blue_intensity:.2f}, threshold: {blue_threshold}") # Too verbose
+        #print(f"DEBUG: Processing cell {cell_id}, blue intensity: {blue_intensity:.2f}, threshold: {blue_threshold}") # Too verbose
         
         if blue_intensity > blue_threshold:
             # Dead cell - color in red
             overlay[cell_mask] = [255, 0, 0]  # Red
             dead_count += 1
-            print(f"DEBUG: Cell {cell_id} classified as DEAD") # Too verbose
+            #print(f"DEBUG: Cell {cell_id} classified as DEAD") # Too verbose
         else:
             # Live cell - color in green
             overlay[cell_mask] = [0, 255, 0]  # Green
             live_count += 1
-            print(f"DEBUG: Cell {cell_id} classified as LIVE") # Too verbose
-    print(f"DEBUG: Final counts - Live: {live_count}, Dead: {dead_count}")
+            #print(f"DEBUG: Cell {cell_id} classified as LIVE") # Too verbose
+    #print(f"DEBUG: Final counts - Live: {live_count}, Dead: {dead_count}")
     
     # Blend with original image
     alpha = 0.6  # Increased alpha for better visibility
@@ -192,9 +194,9 @@ def segment_cells(editor_data, model_choice): # crop_coords removed from here, h
     global current_region_coords # Keep global for info display if needed later
     
     try:
-        print("DEBUG: --- Starting segment_cells ---")
+        #print("DEBUG: --- Starting segment_cells ---")
         debug_info = debug_editor_data(editor_data)
-        print(f"DEBUG: Editor data info:\n{debug_info}")
+        #print(f"DEBUG: Editor data info:\n{debug_info}")
         
         # Load the model
         model_filename = MODEL_OPTIONS[model_choice]
@@ -210,12 +212,12 @@ def segment_cells(editor_data, model_choice): # crop_coords removed from here, h
         region_np, region_coords = extract_region_from_editor(editor_data)
         
         if region_np is None:
-            print("DEBUG: region_np is None, returning error and hiding viability section.")
+            #print("DEBUG: region_np is None, returning error and hiding viability section.")
             current_region_coords = None
             # Also return None for masks and image for the gr.State components
             return 0, None, f"No image provided. Debug info:\n{debug_info}", gr.update(visible=False), None, None
         
-        print(f"DEBUG: Image to segment shape (after extraction/cropping): {region_np.shape}, dtype: {region_np.dtype}")
+        #print(f"DEBUG: Image to segment shape (after extraction/cropping): {region_np.shape}, dtype: {region_np.dtype}")
         
         # Process image format
         if len(region_np.shape) == 2:
@@ -225,18 +227,18 @@ def segment_cells(editor_data, model_choice): # crop_coords removed from here, h
         else:
             region_np_processed = region_np # Already RGB or suitable
 
-        print(f"DEBUG: Image before model.eval shape: {region_np_processed.shape}, dtype: {region_np_processed.dtype}")
+        #print(f"DEBUG: Image before model.eval shape: {region_np_processed.shape}, dtype: {region_np_processed.dtype}")
         
         # Run Cellpose segmentation
         masks, flows, styles = model.eval(region_np_processed, diameter=None, channels=[0, 0])
-        print(f"DEBUG: After model.eval: masks type: {type(masks)}, shape: {masks.shape if hasattr(masks, 'shape') else 'N/A'}")
+        #print(f"DEBUG: After model.eval: masks type: {type(masks)}, shape: {masks.shape if hasattr(masks, 'shape') else 'N/A'}")
         
         # Update global region coords for info display
         current_region_coords = region_coords
         
         # Count unique cells
         cell_count = len(np.unique(masks)) - 1
-        print(f"DEBUG: Cell count: {cell_count}")
+        #print(f"DEBUG: Cell count: {cell_count}")
         
         # Create basic segmentation overlay
         overlay = region_np_processed.copy().astype(np.float32)
@@ -260,7 +262,7 @@ def segment_cells(editor_data, model_choice): # crop_coords removed from here, h
                 
         # Make viability section visible
         viability_section_update = gr.update(visible=True)
-        print("DEBUG: segment_cells returning successfully, viability section visible.")
+        #print("DEBUG: segment_cells returning successfully, viability section visible.")
         
         # Return masks and original processed image for state components
         return cell_count, overlay_image, info_msg, viability_section_update, masks, region_np_processed
@@ -276,22 +278,23 @@ def update_viability_assessment(blue_threshold, stored_masks, stored_image):
     Real-time viability assessment based on blue threshold
     """
     
-    print("DEBUG: --- Starting update_viability_assessment ---")
-    print(f"DEBUG: At start of update_viability_assessment: stored_masks is None? {stored_masks is None}, stored_image is None? {stored_image is None}")
+    #print("DEBUG: --- Starting update_viability_assessment ---")
+    #print(f"DEBUG: At start of update_viability_assessment: stored_masks is None? {stored_masks is None}, stored_image is None? {stored_image is None}")
     
     if stored_masks is None or stored_image is None:
-        print("DEBUG: Passed-in stored_masks or stored_image is None, returning 'Please run segmentation first'.")
+        #print("DEBUG: Passed-in stored_masks or stored_image is None, returning 'Please run segmentation first'.")
         return None, 0, 0, "Please run segmentation first"
     
     try:
         # Debug information
-        unique_cells = np.unique(stored_masks)
+        '''unique_cells = np.unique(stored_masks)
         total_cells = len(unique_cells) - 1  # Subtract background
                 
         debug_info = f"Debug - Total cells found: {total_cells}\n"
         debug_info += f"Image shape: {stored_image.shape}\n"
         debug_info += f"Masks shape: {stored_masks.shape}\n"
         debug_info += f"Unique mask values (first 10): {unique_cells[:10]}...\n"
+        '''
                 
         # Create viability overlay
         viability_overlay, live_count, dead_count = create_viability_overlay(
@@ -306,8 +309,8 @@ def update_viability_assessment(blue_threshold, stored_masks, stored_image):
             viability_percentage = (live_count / total_count) * 100
             viability_info += f"Viability: {viability_percentage:.1f}%\n"
                 
-        viability_info += f"\n{debug_info}"
-        print("DEBUG: update_viability_assessment returning successfully.")
+        #viability_info += f"\n{debug_info}"
+        #print("DEBUG: update_viability_assessment returning successfully.")
                 
         return viability_overlay, live_count, dead_count, viability_info
             
@@ -320,9 +323,9 @@ def segment_with_coords(image, model_choice, crop_coords):
     """Alternative function for manual coordinates input"""
     global current_region_coords
         
-    print("DEBUG: --- Starting segment_with_coords ---")
+    #print("DEBUG: --- Starting segment_with_coords ---")
     if image is None:
-        print("DEBUG: No image provided for segment_with_coords, returning error.")
+        #print("DEBUG: No image provided for segment_with_coords, returning error.")
         current_region_coords = None
         return 0, None, "No image provided", gr.update(visible=False), None, None
         
@@ -339,7 +342,7 @@ def segment_with_coords(image, model_choice, crop_coords):
                 
         # Convert PIL Image to numpy array
         image_np = np.array(image)
-        print(f"DEBUG: image_np from PIL: shape={image_np.shape}, dtype={image_np.dtype}")
+        #print(f"DEBUG: image_np from PIL: shape={image_np.shape}, dtype={image_np.dtype}")
                 
         # Apply crop if coordinates are provided
         if crop_coords and crop_coords.strip():
@@ -355,11 +358,11 @@ def segment_with_coords(image, model_choice, crop_coords):
                                         
                     image_np_processed = image_np[y_min:y_max, x_min:x_max]
                     current_region_coords = (x_min, y_min, x_max, y_max)
-                    print(f"DEBUG: Applied manual crop in segment_with_coords: {current_region_coords}, new image_np_processed shape: {image_np_processed.shape}")
+                    #print(f"DEBUG: Applied manual crop in segment_with_coords: {current_region_coords}, new image_np_processed shape: {image_np_processed.shape}")
                 else:
                     image_np_processed = image_np # No valid crop, use original
             except ValueError:
-                print(f"DEBUG: Invalid crop coordinates format in segment_with_coords: {crop_coords}")
+                #print(f"DEBUG: Invalid crop coordinates format in segment_with_coords: {crop_coords}")
                 image_np_processed = image_np # Invalid crop, use original
         else:
             image_np_processed = image_np # No crop coords, use original
@@ -372,10 +375,10 @@ def segment_with_coords(image, model_choice, crop_coords):
         else:
             image_np_final = image_np_processed
         
-        print(f"DEBUG: Image before model.eval (segment_with_coords) shape: {image_np_final.shape}, dtype: {image_np_final.dtype}")
+        #print(f"DEBUG: Image before model.eval (segment_with_coords) shape: {image_np_final.shape}, dtype: {image_np_final.dtype}")
         # Run Cellpose
         masks, flows, styles = model.eval(image_np_final, diameter=None, channels=[0, 0])
-        print(f"DEBUG: After model.eval (segment_with_coords): masks type: {type(masks)}, shape: {masks.shape if hasattr(masks, 'shape') else 'N/A'}")
+        #print(f"DEBUG: After model.eval (segment_with_coords): masks type: {type(masks)}, shape: {masks.shape if hasattr(masks, 'shape') else 'N/A'}")
         
         # Count unique cells
         cell_count = len(np.unique(masks)) - 1
@@ -398,7 +401,7 @@ def segment_with_coords(image, model_choice, crop_coords):
         if current_region_coords: # Use global if set by crop
             info_msg += f"Region: {current_region_coords}\n"
         info_msg += f"Now use the blue threshold slider below for viability assessment."
-        print("DEBUG: segment_with_coords returning successfully, viability section visible.")
+        #print("DEBUG: segment_with_coords returning successfully, viability section visible.")
                 
         return cell_count, overlay_image, info_msg, gr.update(visible=True), masks, image_np_final