update

SSL_greenhouse_tip_detection.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ada9393d2ee2ad99651f0b26f1cef8ac43aa2ce2b470eacd80af9d8f585d2207
+size 42273811

app.py

@@ -39,11 +39,17 @@ def process(file_path):
         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'))
         size_img = load_pil(str(Path(tmpdir) / 'results/size.size_analysis.png'))
+        yolo_img = load_pil(str(Path(tmpdir) / 'results/yolo_tips.png'))
 
-        # Texture LBP green path
+        # 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']
@@ -51,7 +57,7 @@ def process(file_path):
 
         stats_text = outputs.get('StatsText', '')
 
-        return size_img, composite, mask, overlay, texture_img, gallery_items, stats_text
+        return size_img, composite, mask, overlay, input_img, yolo_img, texture_img, hog_img, lac1_img, gallery_items, stats_text
 
 
 with gr.Blocks() as demo:
@@ -73,9 +79,13 @@ with gr.Blocks() as demo:
         composite_img = gr.Image(type="pil", label="Composite (Segmentation Input)", interactive=False)
         mask_img = gr.Image(type="pil", label="Mask", interactive=False)
         overlay_img = gr.Image(type="pil", label="Segmentation Overlay", interactive=False)
+        input_img = gr.Image(type="pil", label="Input Image", interactive=False)
 
     with gr.Row():
+        yolo_img = gr.Image(type="pil", label="YOLO Tips", interactive=False)
         texture_img = gr.Image(type="pil", label="Texture LBP (Green Band)", interactive=False)
+        hog_img = gr.Image(type="pil", label="Texture HOG (Green Band)", interactive=False)
+        lac1_img = gr.Image(type="pil", label="Texture Lac1 (Green Band)", interactive=False)
 
     gallery = gr.Gallery(label="Vegetation Indices", columns=3, height="auto")
     stats = gr.Textbox(label="Statistics", lines=4)
@@ -83,7 +93,7 @@ with gr.Blocks() as demo:
     run.click(
         process,
         inputs=inp,
-        outputs=[size_img, composite_img, mask_img, overlay_img, texture_img, gallery, stats]
+        outputs=[size_img, composite_img, mask_img, overlay_img, input_img, yolo_img, texture_img, hog_img, lac1_img, gallery, stats]
     )
 
 if __name__ == "__main__":

sorghum_pipeline/features/morphology.py

@@ -19,12 +19,14 @@ logger = logging.getLogger(__name__)
 
 
 class MorphologyExtractor:
-    """Minimal morphology extraction (PlantCV size analysis)."""
+    """Morphology extraction: size analysis image + simple traits + YOLO tips overlay."""
     
-    def __init__(self, pixel_to_cm: float = 0.1099609375, prune_sizes: List[int] = None):
+    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"):
         """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
         
         if PLANT_CV_AVAILABLE:
             pcv.params.debug = None
@@ -34,29 +36,49 @@ class MorphologyExtractor:
             pcv.params.dpi = 100
     
     def extract_morphology_features(self, image: np.ndarray, mask: np.ndarray) -> Dict[str, Any]:
-        """Extract only PlantCV size analysis image."""
-        features = {'traits': {}, 'images': {}, 'success': False}
-        
-        if not PLANT_CV_AVAILABLE:
-            logger.warning("PlantCV not available")
-            return features
+        """Return images {'size_analysis', 'yolo_tips'} and traits including 'plant_height_cm' and 'num_yolo_tips'."""
+        features: Dict[str, Any] = {'traits': {}, 'images': {}, 'success': False}
         
         try:
             clean_mask = self._preprocess_mask(mask)
             if clean_mask is None:
                 return features
-            
-            # Size analysis only
-            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)
-                    size_analysis = pcv.analyze.size(image, labeled_mask, n_labels, label="default")
-                    features['images']['size_analysis'] = size_analysis
-                    features['success'] = True
-                except Exception as e:
-                    logger.warning(f"Size analysis failed: {e}")
-            
+
+            rgb = self._sanitize_image_for_pcv(image)
+            if rgb is None:
+                return features
+
+            # 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)
+                        size_analysis = pcv.analyze.size(rgb, labeled_mask, n_labels, label="default")
+                        features['images']['size_analysis'] = size_analysis
+                        features['success'] = True
+                    except Exception as e:
+                        logger.warning(f"Size analysis failed: {e}")
+            else:
+                # Fallback: make a simple contour visualization
+                vis = self._simple_size_visual(rgb, clean_mask)
+                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)
+            else:
+                features['traits']['plant_height_cm'] = 0.0
+
+            # YOLO tips overlay (optional)
+            yolo_img, tips = self._detect_yolo_tips(rgb, clean_mask)
+            if yolo_img is not None:
+                features['images']['yolo_tips'] = yolo_img
+            features['traits']['num_yolo_tips'] = int(len(tips) if tips is not None else 0)
+
         except Exception as e:
             logger.error(f"Morphology extraction failed: {e}")
         
@@ -79,6 +101,89 @@ class MorphologyExtractor:
         
         return clean_mask
     
+    def _sanitize_image_for_pcv(self, img: np.ndarray) -> np.ndarray:
+        """Ensure 3-channel uint8 RGB for PlantCV and drawing (accepts BGR)."""
+        if img is None:
+            return None
+        arr = img
+        if arr.ndim == 2:
+            arr = cv2.cvtColor(arr, cv2.COLOR_GRAY2RGB)
+        elif arr.ndim == 3 and arr.shape[2] == 4:
+            arr = cv2.cvtColor(arr, cv2.COLOR_BGRA2RGB)
+        elif arr.ndim == 3 and arr.shape[2] == 3:
+            # Assume BGR from OpenCV pipeline → convert to RGB
+            arr = cv2.cvtColor(arr, cv2.COLOR_BGR2RGB)
+        else:
+            return None
+        if arr.dtype != np.uint8:
+            a = arr.astype(np.float32)
+            mn, mx = np.nanmin(a), np.nanmax(a)
+            if mx > mn:
+                a = (a - mn) / (mx - mn)
+            a = np.clip(a * 255.0, 0, 255).astype(np.uint8)
+            arr = a
+        return arr
+    
+    def _simple_size_visual(self, rgb: np.ndarray, mask: np.ndarray) -> np.ndarray:
+        """Draw contours, bbox, and area 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)
+        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."""
+        img_no_bg = rgb.copy()
+        img_no_bg[mask == 0] = 0
+        overlay = np.full_like(rgb, 255, dtype=np.uint8)
+        overlay[mask > 0] = img_no_bg[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:
+            return None, []
+
+        try:
+            model = YOLO(self.yolo_weights_path)
+        except Exception:
+            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
+                                if conf >= 0.5:
+                                    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:
+            return None, []
+    
     class _FilteredStream:
         """Filter PlantCV output."""
         def __init__(self, stream):

sorghum_pipeline/output/manager.py

@@ -87,6 +87,30 @@ class OutputManager:
         except Exception as e:
             logger.error(f"Failed to save composite: {e}")
 
+        # 2c. Normalized input image visualization
+        try:
+            norm_input = plant_data.get('normalized_input')
+            if isinstance(norm_input, np.ndarray):
+                vis = norm_input
+                if vis.ndim == 2:
+                    vis_u8 = self._normalize_to_uint8(vis.astype(np.float64))
+                    vis_rgb = cv2.cvtColor(vis_u8, cv2.COLOR_GRAY2RGB)
+                elif vis.ndim == 3 and vis.shape[2] == 3:
+                    if vis.dtype != np.uint8:
+                        vis_u8 = self._normalize_to_uint8(vis.astype(np.float64))
+                    else:
+                        vis_u8 = vis
+                    # Assume BGR
+                    vis_rgb = cv2.cvtColor(vis_u8, cv2.COLOR_BGR2RGB)
+                else:
+                    vis_u8 = self._normalize_to_uint8(vis.astype(np.float64))
+                    vis_rgb = cv2.cvtColor(vis_u8, cv2.COLOR_GRAY2RGB)
+
+                titled = self._add_title_banner(vis_rgb, 'Input Image')
+                cv2.imwrite(str(results_dir / 'input_image.png'), titled)
+        except Exception as e:
+            logger.error(f"Failed to save normalized input image: {e}")
+
         # 3-5. Vegetation indices (NDVI, GNDVI, SAVI)
         try:
             veg = plant_data.get('vegetation_indices', {})
@@ -142,6 +166,42 @@ class OutputManager:
                     plt.close(fig)
                 except Exception as e:
                     logger.error(f"Failed to save LBP with colorbar: {e}")
+
+            # HOG visualization
+            hog = feats.get('hog')
+            if isinstance(hog, np.ndarray) and hog.size > 0:
+                try:
+                    img = hog.astype(np.float64)
+                    fig, ax = plt.subplots(figsize=(5, 5))
+                    ax.set_axis_off()
+                    ax.set_facecolor('white')
+                    im = ax.imshow(img, cmap='inferno', vmin=0, vmax=255)
+                    ax.set_title('Texture: HOG (Green Band)', fontsize=12, fontweight='bold', pad=8)
+                    cbar = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+                    cbar.ax.tick_params(labelsize=8)
+                    plt.tight_layout()
+                    plt.savefig(tex_dir / 'hog_green.png', dpi=120, bbox_inches='tight')
+                    plt.close(fig)
+                except Exception as e:
+                    logger.error(f"Failed to save HOG with colorbar: {e}")
+
+            # Lacunarity L1 visualization
+            lac1 = feats.get('lac1')
+            if isinstance(lac1, np.ndarray) and lac1.size > 0:
+                try:
+                    img = lac1.astype(np.float64)
+                    fig, ax = plt.subplots(figsize=(5, 5))
+                    ax.set_axis_off()
+                    ax.set_facecolor('white')
+                    im = ax.imshow(img, cmap='plasma', vmin=0, vmax=255)
+                    ax.set_title('Texture: Lacunarity L1 (Green Band)', fontsize=12, fontweight='bold', pad=8)
+                    cbar = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+                    cbar.ax.tick_params(labelsize=8)
+                    plt.tight_layout()
+                    plt.savefig(tex_dir / 'lac1_green.png', dpi=120, bbox_inches='tight')
+                    plt.close(fig)
+                except Exception as e:
+                    logger.error(f"Failed to save Lacunarity L1 with colorbar: {e}")
         except Exception as e:
             logger.error(f"Failed to save texture: {e}")
 
@@ -161,6 +221,12 @@ class OutputManager:
                     synthesized = self._create_size_analysis_from_mask(mask_for_size, base_img_for_size)
                     titled = self._add_title_banner(synthesized, 'Morphology Size')
                     cv2.imwrite(str(results_dir / 'size.size_analysis.png'), titled)
+
+            # Also save YOLO tips visualization if present
+            yolo_img = images.get('yolo_tips')
+            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)
         except Exception as e:
             logger.error(f"Failed to save size analysis: {e}")
     

sorghum_pipeline/pipeline.py

@@ -86,6 +86,8 @@ class SorghumPipeline:
             "demo": {
                 "raw_image": (img, Path(single_image_path).name),
                 "plant_name": "demo",
+                # Keep original normalized array for visualization
+                "normalized_input": arr,
             }
         }
 
@@ -116,12 +118,12 @@ class SorghumPipeline:
         return plants
     
     def _extract_features(self, plants: Dict[str, Any]) -> Dict[str, Any]:
-        """Extract features: texture + vegetation indices."""
+        """Extract features: texture + vegetation indices + morphology."""
         for key, pdata in plants.items():
             composite = pdata['composite']
             mask = pdata.get('mask')
 
-            # --- Texture: LBP on green band ---
+            # --- Texture: LBP/HOG/Lacunarity on green band ---
             pdata['texture_features'] = {}
             spectral = pdata.get('spectral_stack', {})
             if 'green' in spectral:
@@ -140,7 +142,9 @@ class SorghumPipeline:
                 gray8 = ((v - m) / denom * 255.0).astype(np.uint8)
 
                 lbp_map = self.texture_extractor.extract_lbp(gray8)
-                pdata['texture_features'] = {'green': {'features': {'lbp': lbp_map}}}
+                hog_map = self.texture_extractor.extract_hog(gray8)
+                lac1_map = self.texture_extractor.compute_local_lacunarity(gray8)
+                pdata['texture_features'] = {'green': {'features': {'lbp': lbp_map, 'hog': hog_map, 'lac1': lac1_map}}}
 
             # --- Vegetation indices ---
             if spectral and mask is not None:
@@ -148,8 +152,15 @@ class SorghumPipeline:
             else:
                 pdata['vegetation_indices'] = {}
 
-            # --- Morphology (currently empty) ---
-            pdata['morphology_features'] = {}
+            # --- Morphology ---
+            try:
+                if mask is not None and isinstance(composite, np.ndarray):
+                    morph = self.morphology_extractor.extract_morphology_features(composite, mask)
+                    pdata['morphology_features'] = morph
+                else:
+                    pdata['morphology_features'] = {}
+            except Exception:
+                pdata['morphology_features'] = {}
         
         return plants
     

wrapper.py

@@ -66,12 +66,18 @@ 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)
     if mask_path.exists():
         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:
@@ -85,6 +91,15 @@ 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)
+            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)):
+                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)}")
             if stats_lines:
                 outputs['StatsText'] = "\n".join(stats_lines)
     except Exception: