update the morphology, remove yolo, and correct the display

app.py

@@ -40,14 +40,41 @@ def process(file_path, preset_choice):
             # Fallback: save via PIL if direct copy fails
             Image.open(src).save(img_path)
 
-        # Show input image immediately
+        # Show input image immediately (read exactly like pipeline for correctness)
         try:
-            preview_im = Image.open(img_path)
-            input_preview = preview_im.copy()
-            preview_im.close()
+            import imghdr
+            import tifffile  # type: ignore
+            import cv2  # type: ignore
+
+            kind = imghdr.what(str(img_path))
+            suffix = img_path.suffix.lower()
+
+            arr = None
+            if kind == "tiff" or suffix in [".tif", ".tiff"]:
+                try:
+                    arr = tifffile.imread(str(img_path))
+                except Exception:
+                    arr = cv2.imread(str(img_path), cv2.IMREAD_UNCHANGED)
+            else:
+                arr = cv2.imread(str(img_path), cv2.IMREAD_UNCHANGED)
+
+            if arr is None:
+                raise ValueError("Could not read image for preview")
+            if arr.ndim > 3:
+                arr = arr[..., 0]
+            if arr.ndim == 3 and arr.shape[-1] == 1:
+                arr = arr[..., 0]
+
+            input_preview = Image.fromarray(arr)
         except Exception:
-            input_preview = None
+            try:
+                preview_im = Image.open(img_path)
+                input_preview = preview_im.copy()
+                preview_im.close()
+            except Exception:
+                input_preview = None
 
+        # Initial yield showing input preview
         yield (
             input_preview,  # input image shown immediately
             None,  # composite
@@ -61,9 +88,7 @@ def process(file_path, preset_choice):
             "",   # stats
         )
 
-        # Run the pipeline
-        outputs = run_pipeline_on_image(str(img_path), tmpdir, save_artifacts=True)
-
+        # Helper to load PIL images
         def load_pil(path_str):
             try:
                 if not path_str:
@@ -75,39 +100,42 @@ def process(file_path, preset_choice):
             except Exception:
                 return None
 
-        composite = load_pil(outputs.get('Composite'))
-        overlay = load_pil(outputs.get('Overlay'))
-        mask = load_pil(outputs.get('Mask'))
-        input_img = load_pil(outputs.get('InputImage')) or input_preview
-        size_img = load_pil(str(Path(tmpdir) / 'results/size.size_analysis.png'))
-
-        # Texture images (green band)
-        lbp_path = Path(tmpdir) / 'texture_output/lbp_green.png'
-        hog_path = Path(tmpdir) / 'texture_output/hog_green.png'
-        lac1_path = Path(tmpdir) / 'texture_output/lac1_green.png'
-        texture_img = load_pil(str(lbp_path)) if lbp_path.exists() else None
-        hog_img = load_pil(str(hog_path)) if hog_path.exists() else None
-        lac1_img = load_pil(str(lac1_path)) if lac1_path.exists() else None
-
-        # Vegetation indices
-        order = ['NDVI', 'GNDVI', 'SAVI']
-        gallery_items = [load_pil(outputs[k]) for k in order if k in outputs]
-
-        stats_text = outputs.get('StatsText', '')
-
-        # Final yield with all results (10 outputs, no YOLO)
-        yield (
-            input_img,
-            composite,
-            mask,
-            overlay,
-            texture_img,
-            hog_img,
-            lac1_img,
-            gallery_items,
-            size_img,
-            stats_text,
-        )
+        # Run the pipeline progressively (generator)
+        for outputs in run_pipeline_on_image(str(img_path), tmpdir, save_artifacts=True):
+            # Load all available outputs progressively
+            composite = load_pil(outputs.get('Composite'))
+            overlay = load_pil(outputs.get('Overlay'))
+            mask = load_pil(outputs.get('Mask'))
+            input_img = load_pil(outputs.get('InputImage')) or input_preview
+            size_img = load_pil(str(Path(tmpdir) / 'results/size.size_analysis.png'))
+
+            # Texture images (green band)
+            lbp_path = Path(tmpdir) / 'texture_output/lbp_green.png'
+            hog_path = Path(tmpdir) / 'texture_output/hog_green.png'
+            lac1_path = Path(tmpdir) / 'texture_output/lac1_green.png'
+            texture_img = load_pil(str(lbp_path)) if lbp_path.exists() else None
+            hog_img = load_pil(str(hog_path)) if hog_path.exists() else None
+            lac1_img = load_pil(str(lac1_path)) if lac1_path.exists() else None
+
+            # Vegetation indices
+            order = ['NDVI', 'GNDVI', 'SAVI']
+            gallery_items = [load_pil(outputs[k]) for k in order if k in outputs]
+
+            stats_text = outputs.get('StatsText', '')
+
+            # Yield intermediate/final results as they become available
+            yield (
+                input_img,
+                composite,
+                mask,
+                overlay,
+                texture_img,
+                hog_img,
+                lac1_img,
+                gallery_items,
+                size_img,
+                stats_text,
+            )
 
 
 with gr.Blocks() as demo:

sorghum_pipeline/features/morphology.py

@@ -19,16 +19,14 @@ logger = logging.getLogger(__name__)
 
 
 class MorphologyExtractor:
-    """Morphology extraction: size analysis image + simple traits + YOLO tips overlay."""
+    """Morphology extraction: size analysis image + simple traits."""
     
     def __init__(self, pixel_to_cm: float = 0.1099609375, prune_sizes: List[int] = None,
-                 yolo_weights_path: str = "/home/grads/f/fahimehorvatinia/plant-analysis-demo/SSL_greenhouse_tip_detection.pt",
                  min_component_area_for_size: int = 3000):
         """Initialize."""
         self.pixel_to_cm = pixel_to_cm
         self.prune_sizes = prune_sizes or [200, 100, 50, 30, 10]
-        self.yolo_weights_path = yolo_weights_path
-        # Used only for the Morphology Size visualization (not for height or YOLO)
+        # Used only for the Morphology Size visualization (not for height)
         self.min_component_area_for_size = int(min_component_area_for_size)
         
         if PLANT_CV_AVAILABLE:
@@ -39,7 +37,7 @@ class MorphologyExtractor:
             pcv.params.dpi = 100
     
     def extract_morphology_features(self, image: np.ndarray, mask: np.ndarray) -> Dict[str, Any]:
-        """Fast size visualization (YOLO disabled for speed). Simplified for performance."""
+        """Fast size visualization with multi-plant support. Simplified for performance."""
         features: Dict[str, Any] = {'traits': {}, 'images': {}, 'success': False}
         
         try:
@@ -52,21 +50,43 @@ class MorphologyExtractor:
             if rgb is None:
                 return features
 
-            # Simple size visualization without PlantCV for speed
-            vis = self._simple_size_visual(rgb, ((clean_mask > 0).astype(np.uint8) * 255))
-            features['images']['size_analysis'] = vis
-            features['success'] = True
-
-            # Compute simple plant height from mask (px → cm)
-            rows = np.where(clean_mask > 0)[0]
-            if rows.size:
-                height_px = int(rows.max() - rows.min() + 1)
-                features['traits']['plant_height_cm'] = float(height_px * self.pixel_to_cm)
+            # Detect multiple plants using connected components
+            binary_mask = ((clean_mask > 0).astype(np.uint8) * 255)
+            num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(binary_mask, connectivity=8)
+            
+            # Calculate height for each plant (skip background label 0)
+            plant_heights = {}
+            for plant_idx in range(1, num_labels):
+                area = stats[plant_idx, cv2.CC_STAT_AREA]
+                # Filter out very small components (noise)
+                if area < 100:
+                    continue
+                
+                # Get rows for this plant
+                plant_mask = (labels == plant_idx)
+                rows = np.where(plant_mask)[0]
+                if rows.size:
+                    height_px = int(rows.max() - rows.min() + 1)
+                    height_cm = float(height_px * self.pixel_to_cm)
+                    plant_heights[f'plant_{plant_idx}'] = height_cm
+            
+            # Store individual plant heights
+            features['traits']['plant_heights'] = plant_heights
+            features['traits']['num_plants'] = len(plant_heights)
+            
+            # For backward compatibility, store total height if single plant
+            if len(plant_heights) == 1:
+                features['traits']['plant_height_cm'] = list(plant_heights.values())[0]
+            elif len(plant_heights) > 1:
+                # Store max height as overall height
+                features['traits']['plant_height_cm'] = max(plant_heights.values())
             else:
                 features['traits']['plant_height_cm'] = 0.0
 
-            # YOLO disabled for speed
-            features['traits']['num_yolo_tips'] = 0
+            # Simple size visualization without PlantCV for speed
+            vis = self._simple_size_visual(rgb, binary_mask)
+            features['images']['size_analysis'] = vis
+            features['success'] = True
 
         except Exception as e:
             logger.error(f"Morphology extraction failed: {e}")
@@ -140,103 +160,47 @@ class MorphologyExtractor:
         return arr
     
     def _simple_size_visual(self, rgb: np.ndarray, mask: np.ndarray) -> np.ndarray:
-        """Draw contours, bbox, and area on RGB image."""
+        """Draw contours and bbox for each plant on RGB image."""
         vis = rgb.copy()
-        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        cv2.drawContours(vis, contours, -1, (255, 0, 0), 2)
-        if contours:
-            largest = max(contours, key=cv2.contourArea)
-            x, y, w, h = cv2.boundingRect(largest)
-            cv2.rectangle(vis, (x, y), (x + w, y + h), (0, 255, 0), 2)
-            area_px = int(cv2.countNonZero(mask))
-            cv2.putText(vis, f"Area: {area_px} px", (10, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2, cv2.LINE_AA)
+        
+        # Find connected components to identify individual plants
+        num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(mask, connectivity=8)
+        
+        # Use different colors for different plants
+        colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (255, 0, 255), (0, 255, 255)]
+        
+        plant_count = 0
+        for plant_idx in range(1, num_labels):  # Skip background (0)
+            area = stats[plant_idx, cv2.CC_STAT_AREA]
+            # Filter out very small components (noise)
+            if area < 100:
+                continue
+            
+            # Get individual plant mask
+            plant_mask = ((labels == plant_idx).astype(np.uint8) * 255)
+            
+            # Find contours for this plant
+            contours, _ = cv2.findContours(plant_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            
+            # Pick color for this plant
+            color = colors[plant_count % len(colors)]
+            
+            # Draw contours
+            cv2.drawContours(vis, contours, -1, color, 2)
+            
+            # Draw bounding box
+            if contours:
+                x, y, w, h = cv2.boundingRect(contours[0])
+                cv2.rectangle(vis, (x, y), (x + w, y + h), color, 2)
+                
+                # Add plant number label
+                cv2.putText(vis, f"P{plant_idx}", (x, y - 5), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2, cv2.LINE_AA)
+            
+            plant_count += 1
+        
         return vis
     
-    def _create_white_background_overlay(self, rgb: np.ndarray, mask: np.ndarray) -> np.ndarray:
-        """Return white background with plant pixels in original colors.
-        The mask here is normalized to a single-channel binary mask so it matches the frontend mask behavior.
-        """
-        img_no_bg = rgb.copy()
-        # Normalize mask to single-channel binary
-        if mask is None:
-            bin_mask = None
-        else:
-            m = mask
-            if m.ndim == 3:
-                m = cv2.cvtColor(m, cv2.COLOR_BGR2GRAY)
-            m = m.astype(np.uint8)
-            _, bin_mask = cv2.threshold(m, 0, 255, cv2.THRESH_BINARY)
-        if bin_mask is None:
-            return np.full_like(rgb, 255, dtype=np.uint8)
-        img_no_bg[bin_mask == 0] = 0
-        overlay = np.full_like(rgb, 255, dtype=np.uint8)
-        overlay[bin_mask > 0] = img_no_bg[bin_mask > 0]
-        return overlay
-    
-    def _detect_yolo_tips(self, rgb: np.ndarray, mask: np.ndarray):
-        """Detect tips using a YOLO model if available. Returns (overlay_img, tips_list)."""
-        try:
-            from ultralytics import YOLO  # type: ignore
-        except Exception as e:
-            logger.warning(f"Ultralytics not available: {e}")
-            return None, []
-
-        try:
-            # Resolve weights path robustly
-            weights_path = self.yolo_weights_path
-            if not isinstance(weights_path, str) or not weights_path:
-                weights_path = "SSL_greenhouse_tip_detection.pt"
-            # Try absolute, then repo root, then cwd
-            candidates = [
-                weights_path,
-                "/home/grads/f/fahimehorvatinia/plant-analysis-demo/SSL_greenhouse_tip_detection.pt",
-                "./SSL_greenhouse_tip_detection.pt",
-            ]
-            chosen = None
-            for p in candidates:
-                try:
-                    import os
-                    if os.path.exists(p):
-                        chosen = p
-                        break
-                except Exception:
-                    pass
-            if chosen is None:
-                logger.warning("YOLO weights not found; skipping YOLO tips")
-                return None, []
-            model = YOLO(chosen)
-        except Exception as e:
-            logger.warning(f"Failed to load YOLO model: {e}")
-            return None, []
-
-        try:
-            overlay_img = self._create_white_background_overlay(rgb, mask)
-            # Run inference; allow low conf to let thresholding below handle
-            results = model(overlay_img, conf=0.01, imgsz=640)
-            tips = []
-            for r in results:
-                if getattr(r, 'keypoints', None) is not None and getattr(r.keypoints, 'xy', None) is not None:
-                    kps_xy = r.keypoints.xy.cpu().numpy()
-                    kps_conf = None
-                    if getattr(r.keypoints, 'conf', None) is not None:
-                        kps_conf = r.keypoints.conf.cpu().numpy()
-                    for i, det_xy in enumerate(kps_xy):
-                        for j, pt in enumerate(det_xy):
-                            x, y = float(pt[0]), float(pt[1])
-                            if not np.isnan(x) and not np.isnan(y):
-                                conf = float(kps_conf[i][j]) if kps_conf is not None else 1.0
-                                # Slightly relax threshold to 0.4 to improve recall
-                                if conf >= 0.4:
-                                    tips.append((int(x), int(y), conf))
-
-            # Draw tips
-            vis = overlay_img.copy()
-            for (x, y, _c) in tips:
-                cv2.circle(vis, (int(x), int(y)), 8, (255, 0, 0), -1)
-            return vis, tips
-        except Exception as e:
-            logger.warning(f"YOLO detection failed: {e}")
-            return None, []
     
     class _FilteredStream:
         """Filter PlantCV output."""

sorghum_pipeline/pipeline.py

@@ -4,7 +4,7 @@ Minimal single-image pipeline for Hugging Face demo.
 
 import logging
 from pathlib import Path
-from typing import Dict, Any
+from typing import Dict, Any, Callable, Optional, Generator
 import numpy as np
 import cv2
 
@@ -105,6 +105,90 @@ class SorghumPipeline:
 
         return {"plants": plants, "timing": elapsed}
 
+    def run_with_progress(self, single_image_path: str, progress_callback: Optional[Callable[[str, Dict[str, Any]], None]] = None) -> Generator[Dict[str, Any], None, None]:
+        """Run pipeline on single image, yielding intermediate results progressively."""
+        logger.info("Processing single image with progress...")
+
+        import time, imghdr, tifffile
+        from PIL import Image
+
+        start = time.perf_counter()
+
+        # --- Load image with TIFF preference ---
+        kind = imghdr.what(single_image_path)
+        suffix = Path(single_image_path).suffix.lower()
+
+        arr = None
+        if kind == "tiff" or suffix in [".tif", ".tiff"]:
+            try:
+                arr = tifffile.imread(single_image_path)
+                logger.info(f"Loaded TIFF: shape={arr.shape}, dtype={arr.dtype}")
+            except Exception as e:
+                logger.warning(f"tifffile failed ({e}), falling back to cv2")
+                arr = cv2.imread(single_image_path, cv2.IMREAD_UNCHANGED)
+                logger.info(f"Fallback read: shape={arr.shape}, dtype={arr.dtype}")
+        else:
+            arr = cv2.imread(single_image_path, cv2.IMREAD_UNCHANGED)
+            logger.info(f"Loaded non-TIFF: shape={arr.shape}, dtype={arr.dtype}")
+
+        # --- Normalize array shape ---
+        if arr is None:
+            raise ValueError(f"Could not read image: {single_image_path}")
+        if arr.ndim > 3:
+            arr = arr[..., 0]  # drop extra dimension
+        if arr.ndim == 3 and arr.shape[-1] == 1:
+            arr = arr[..., 0]  # squeeze singleton
+
+        logger.info(f"DEBUG normalized input: shape={arr.shape}, dtype={arr.dtype}")
+
+        # Wrap into PIL image for downstream pipeline
+        img = Image.fromarray(arr)
+
+        plants = {
+            "demo": {
+                "raw_image": (img, Path(single_image_path).name),
+                "plant_name": "demo",
+                "normalized_input": arr,
+            }
+        }
+
+        # Create output directories early
+        self.output_manager.create_output_directories()
+
+        # Stage 1: Create composite
+        logger.info("Stage 1: Creating composite...")
+        plants = self.preprocessor.create_composites(plants)
+        if progress_callback:
+            progress_callback("composite", plants)
+        # Save composite immediately for display
+        for key, pdata in plants.items():
+            self.output_manager.save_plant_results(key, pdata)
+        yield {"plants": plants, "stage": "composite"}
+
+        # Stage 2: Segmentation
+        logger.info("Stage 2: Segmentation...")
+        plants = self._segment(plants)
+        if progress_callback:
+            progress_callback("segmentation", plants)
+        # Save mask and overlay
+        for key, pdata in plants.items():
+            self.output_manager.save_plant_results(key, pdata)
+        yield {"plants": plants, "stage": "segmentation"}
+
+        # Stage 3: Extract features (texture, vegetation, morphology)
+        logger.info("Stage 3: Extracting features...")
+        plants = self._extract_features(plants)
+        if progress_callback:
+            progress_callback("features", plants)
+        # Save all final outputs
+        for key, pdata in plants.items():
+            self.output_manager.save_plant_results(key, pdata)
+        
+        elapsed = time.perf_counter() - start
+        logger.info(f"Completed in {elapsed:.2f}s")
+
+        yield {"plants": plants, "timing": elapsed, "stage": "complete"}
+
     def _segment(self, plants: Dict[str, Any]) -> Dict[str, Any]:
         """Segment using BRIA."""
         for key, pdata in plants.items():

wrapper.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Dict
+from typing import Dict, Callable, Optional, Generator, Any
 import shutil
 from PIL import Image
 import glob
@@ -9,10 +9,20 @@ from sorghum_pipeline.pipeline import SorghumPipeline
 from sorghum_pipeline.config import Config, Paths
 
 
-def run_pipeline_on_image(input_image_path: str, work_dir: str, save_artifacts: bool = True) -> Dict[str, str]:
+def run_pipeline_on_image(input_image_path: str, work_dir: str, save_artifacts: bool = True, 
+                          progress_callback: Optional[Callable[[str, Dict[str, Any]], None]] = None) -> Generator[Dict[str, str], None, None]:
     """
     Run sorghum pipeline on a single image (no instance segmentation).
-    Returns dict[label -> image_path] for gallery display.
+    Yields dict[label -> image_path] progressively for gallery display.
+    
+    Args:
+        input_image_path: Path to input image
+        work_dir: Working directory for outputs
+        save_artifacts: Whether to save artifacts
+        progress_callback: Optional callback(stage_name, data) called after each pipeline stage
+    
+    Yields:
+        Dictionary of output paths progressively as they become available
     """
 
     work = Path(work_dir)
@@ -34,11 +44,20 @@ def run_pipeline_on_image(input_image_path: str, work_dir: str, save_artifacts:
     )
     pipeline = SorghumPipeline(config=cfg)
 
-    # Run the pipeline (single image minimal demo)
-    results = pipeline.run(single_image_path=str(input_path))
+    # Run the pipeline with progress callback (generator)
+    for stage_result in pipeline.run_with_progress(single_image_path=str(input_path), progress_callback=progress_callback):
+        # Yield intermediate outputs as they become available
+        outputs = _collect_outputs(work, stage_result.get('plants', {}))
+        yield outputs
+    
+    # Final results
+    results = stage_result
 
-    # Collect outputs
+
+def _collect_outputs(work: Path, plants: Dict[str, Any]) -> Dict[str, str]:
+    """Collect all available outputs from work directory and plants data."""
     outputs: Dict[str, str] = {}
+    
     try:
         # Log immediate output directory contents for debugging
         for sub in ['results', 'Vegetation_indices_images', 'texture_output']:
@@ -66,7 +85,6 @@ def run_pipeline_on_image(input_image_path: str, work_dir: str, save_artifacts:
     overlay_path = work / 'results/overlay.png'
     mask_path = work / 'results/mask.png'
     composite_path = work / 'results/composite.png'
-    yolo_tips_path = work / 'results/yolo_tips.png'
     input_img_path = work / 'results/input_image.png'
     if overlay_path.exists():
         outputs['Overlay'] = str(overlay_path)
@@ -74,14 +92,11 @@ def run_pipeline_on_image(input_image_path: str, work_dir: str, save_artifacts:
         outputs['Mask'] = str(mask_path)
     if composite_path.exists():
         outputs['Composite'] = str(composite_path)
-    if yolo_tips_path.exists():
-        outputs['YOLOTips'] = str(yolo_tips_path)
     if input_img_path.exists():
         outputs['InputImage'] = str(input_img_path)
 
     # Extract simple stats for display if present in pipeline results
     try:
-        plants = results.get('plants', {}) if isinstance(results, dict) else {}
         if plants:
             _, pdata = next(iter(plants.items()))
             veg = pdata.get('vegetation_indices', {})
@@ -91,15 +106,31 @@ def run_pipeline_on_image(input_image_path: str, work_dir: str, save_artifacts:
                 st = entry.get('statistics', {}) if isinstance(entry, dict) else {}
                 if st:
                     stats_lines.append(f"{name}: mean={st.get('mean', 0):.3f}, std={st.get('std', 0):.3f}")
-            # Morphology stats (height, yolo tips)
+            # Morphology stats (height for multiple plants)
             morph = pdata.get('morphology_features', {}) if isinstance(pdata, dict) else {}
             traits = morph.get('traits', {}) if isinstance(morph, dict) else {}
-            height_cm = traits.get('plant_height_cm')
-            if isinstance(height_cm, (int, float)):
+            
+            # Check if we have multiple plants
+            plant_heights = traits.get('plant_heights', {})
+            num_plants = traits.get('num_plants', 0)
+            
+            if isinstance(plant_heights, dict) and len(plant_heights) > 1:
+                # Multiple plants detected
+                stats_lines.append(f"Number of plants: {num_plants}")
+                # Sort by plant index for consistent display
+                sorted_plants = sorted(plant_heights.items(), key=lambda x: int(x[0].split('_')[1]))
+                for plant_name, height_cm in sorted_plants:
+                    plant_num = plant_name.split('_')[1]
+                    stats_lines.append(f"  Plant {plant_num}: {height_cm:.2f} cm")
+            elif isinstance(plant_heights, dict) and len(plant_heights) == 1:
+                # Single plant
+                height_cm = list(plant_heights.values())[0]
                 stats_lines.append(f"Plant height: {height_cm:.2f} cm")
-            num_tips = traits.get('num_yolo_tips')
-            if isinstance(num_tips, (int, float)):
-                stats_lines.append(f"YOLO tips: {int(num_tips)}")
+            else:
+                # Fallback to old single height field
+                height_cm = traits.get('plant_height_cm')
+                if isinstance(height_cm, (int, float)) and height_cm > 0:
+                    stats_lines.append(f"Plant height: {height_cm:.2f} cm")
             if stats_lines:
                 outputs['StatsText'] = "\n".join(stats_lines)
     except Exception: