update

sorghum_pipeline/features/morphology.py

@@ -22,11 +22,14 @@ class MorphologyExtractor:
     """Morphology extraction: size analysis image + simple traits + YOLO tips overlay."""
     
     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"):
+                 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)
+        self.min_component_area_for_size = int(min_component_area_for_size)
         
         if PLANT_CV_AVAILABLE:
             pcv.params.debug = None
@@ -48,12 +51,15 @@ class MorphologyExtractor:
             if rgb is None:
                 return features
 
+            # For the size visualization only, remove small connected components
+            size_mask = self._filter_small_components(clean_mask, self.min_component_area_for_size)
+
             # Size analysis image via PlantCV if available
             if PLANT_CV_AVAILABLE:
                 with contextlib.redirect_stdout(self._FilteredStream(sys.stdout)), \
                      contextlib.redirect_stderr(self._FilteredStream(sys.stderr)):
                     try:
-                        labeled_mask, n_labels = pcv.create_labels(clean_mask)
+                        labeled_mask, n_labels = pcv.create_labels(size_mask)
                         size_analysis = pcv.analyze.size(rgb, labeled_mask, n_labels, label="default")
                         features['images']['size_analysis'] = size_analysis
                         features['success'] = True
@@ -61,7 +67,7 @@ class MorphologyExtractor:
                         logger.warning(f"Size analysis failed: {e}")
             else:
                 # Fallback: make a simple contour visualization
-                vis = self._simple_size_visual(rgb, clean_mask)
+                vis = self._simple_size_visual(rgb, size_mask)
                 features['images']['size_analysis'] = vis
                 features['success'] = True
 
@@ -83,6 +89,32 @@ class MorphologyExtractor:
             logger.error(f"Morphology extraction failed: {e}")
         
         return features
+
+    def _filter_small_components(self, mask: np.ndarray, min_area: int) -> np.ndarray:
+        """Remove connected components smaller than min_area from a binary mask (0/255)."""
+        if mask is None or mask.size == 0:
+            return mask
+        try:
+            m = mask
+            if m.ndim == 3:
+                m = cv2.cvtColor(m, cv2.COLOR_BGR2GRAY)
+            m = (m.astype(np.uint8) > 0).astype(np.uint8) * 255
+            num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(m, connectivity=8)
+            filtered = np.zeros_like(m)
+            kept = 0
+            for lbl in range(1, num_labels):
+                if stats[lbl, cv2.CC_STAT_AREA] >= max(0, int(min_area)):
+                    filtered[labels == lbl] = 255
+                    kept += 1
+            if kept == 0:
+                # If all removed, keep the largest to avoid empty visualization
+                if num_labels > 1:
+                    largest = 1 + int(np.argmax(stats[1:, cv2.CC_STAT_AREA]))
+                    filtered[labels == largest] = 255
+            return filtered
+        except Exception as e:
+            logger.warning(f"Component filtering failed, using original mask: {e}")
+            return mask
     
     def _preprocess_mask(self, mask: np.ndarray) -> np.ndarray:
         """Preprocess mask."""
@@ -149,12 +181,36 @@ class MorphologyExtractor:
         """Detect tips using a YOLO model if available. Returns (overlay_img, tips_list)."""
         try:
             from ultralytics import YOLO  # type: ignore
-        except Exception:
+        except Exception as e:
+            logger.warning(f"Ultralytics not available: {e}")
             return None, []
 
         try:
-            model = YOLO(self.yolo_weights_path)
-        except Exception:
+            # 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:
@@ -173,7 +229,8 @@ class MorphologyExtractor:
                             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
-                                if conf >= 0.5:
+                                # Slightly relax threshold to 0.4 to improve recall
+                                if conf >= 0.4:
                                     tips.append((int(x), int(y), conf))
 
             # Draw tips
@@ -181,7 +238,8 @@ class MorphologyExtractor:
             for (x, y, _c) in tips:
                 cv2.circle(vis, (int(x), int(y)), 8, (255, 0, 0), -1)
             return vis, tips
-        except Exception:
+        except Exception as e:
+            logger.warning(f"YOLO detection failed: {e}")
             return None, []
     
     class _FilteredStream:

sorghum_pipeline/output/manager.py

@@ -227,6 +227,21 @@ class OutputManager:
             if isinstance(yolo_img, np.ndarray) and yolo_img.size > 0:
                 titled = self._add_title_banner(yolo_img, 'YOLO Tips')
                 cv2.imwrite(str(results_dir / 'yolo_tips.png'), titled)
+            else:
+                # Fallback YOLO visualization: draw nothing but preserve panel, or overlay mask centroids
+                try:
+                    mask_for_tips = plant_data.get('mask')
+                    base_img_for_tips = plant_data.get('composite')
+                    if isinstance(base_img_for_tips, np.ndarray) and base_img_for_tips.size > 0:
+                        base = base_img_for_tips
+                    else:
+                        # If no composite, synthesize white background overlay from mask
+                        base = None
+                    fallback = self._create_fallback_yolo_panel(mask_for_tips, base)
+                    titled = self._add_title_banner(fallback, 'YOLO Tips (No Detections)')
+                    cv2.imwrite(str(results_dir / 'yolo_tips.png'), titled)
+                except Exception as e:
+                    logger.warning(f"Failed to create fallback YOLO tips image: {e}")
         except Exception as e:
             logger.error(f"Failed to save size analysis: {e}")
     
@@ -343,4 +358,48 @@ class OutputManager:
         # Put area text
         cv2.putText(base_bgr, f"Area: {area_px} px", (10, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2, cv2.LINE_AA)
 
-        return base_bgr
+        return base_bgr
+
+    def _create_fallback_yolo_panel(self, mask: Any, base_image: Any = None) -> np.ndarray:
+        """Create a fallback YOLO tips panel when detections are unavailable.
+        Uses the composite image if available; otherwise, creates a white canvas sized to mask.
+        """
+        try:
+            if isinstance(base_image, np.ndarray) and base_image.size > 0:
+                img = base_image
+                if img.dtype != np.uint8:
+                    img = self._normalize_to_uint8(img.astype(np.float64))
+                if img.ndim == 2:
+                    panel = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+                elif img.ndim == 3 and img.shape[2] == 3:
+                    panel = img.copy()
+                elif img.ndim == 3 and img.shape[2] == 4:
+                    panel = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+                else:
+                    norm = self._normalize_to_uint8(img.astype(np.float64))
+                    panel = cv2.cvtColor(norm, cv2.COLOR_GRAY2BGR)
+            else:
+                if isinstance(mask, np.ndarray) and mask.size > 0:
+                    h, w = mask.shape[:2]
+                else:
+                    h, w = 256, 256
+                panel = np.full((h, w, 3), 255, dtype=np.uint8)
+
+            # Optionally show mask centroid as hint
+            try:
+                if isinstance(mask, np.ndarray) and mask.size > 0:
+                    m = mask
+                    if m.ndim == 3:
+                        m = cv2.cvtColor(m, cv2.COLOR_BGR2GRAY)
+                    _, bin_m = cv2.threshold(m.astype(np.uint8), 0, 255, cv2.THRESH_BINARY)
+                    moments = cv2.moments(bin_m)
+                    if moments['m00'] != 0:
+                        cx = int(moments['m10'] / moments['m00'])
+                        cy = int(moments['m01'] / moments['m00'])
+                        cv2.drawMarker(panel, (cx, cy), (0, 0, 255), markerType=cv2.MARKER_TILTED_CROSS, markerSize=12, thickness=2)
+            except Exception:
+                pass
+
+            return panel
+        except Exception:
+            return np.full((256, 256, 3), 255, dtype=np.uint8)