update the latest

SSL_greenhouse_tip_detection.pt

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

app.py

@@ -4,13 +4,28 @@ from pathlib import Path
 from wrapper import run_pipeline_on_image
 from PIL import Image
 
-# Precomputed demo outputs inside the repo (placed by you once)
-PRECOMPUTED_DIR = (Path(__file__).resolve().parent / "precomputed_demo")
+# Base directory for preset images
+BASE_DIR = Path(__file__).resolve().parent
+
+# Preset images available for selection
+PRESET_IMAGES = {
+    "Sorghum": str(BASE_DIR / "Sorghum.tif"),
+    "Corn": str(BASE_DIR / "Corn.tif"),
+    "Cotton": str(BASE_DIR / "Cotton.tif"),
+}
+
+
+def process(file_path, preset_choice):
+    """Process image and yield results progressively for immediate display."""
+    # If a preset is chosen, override the uploaded file path
+    if preset_choice:
+        chosen = PRESET_IMAGES.get(preset_choice)
+        if chosen:
+            file_path = chosen
 
-##add the process function
-def process(file_path):
     if not file_path:
-        return None, None, None, None, None, [], ""
+        # Return 10 outputs (removed YOLO tips)
+        return None, None, None, None, None, None, None, [], None, ""
 
     with tempfile.TemporaryDirectory() as tmpdir:
         src = Path(file_path)
@@ -25,7 +40,28 @@ def process(file_path):
             # Fallback: save via PIL if direct copy fails
             Image.open(src).save(img_path)
 
-        # Run the full sorghum pipeline
+        # Show input image immediately
+        try:
+            preview_im = Image.open(img_path)
+            input_preview = preview_im.copy()
+            preview_im.close()
+        except Exception:
+            input_preview = None
+
+        yield (
+            input_preview,  # input image shown immediately
+            None,  # composite
+            None,  # mask
+            None,  # overlay
+            None,  # texture_img
+            None,  # hog_img
+            None,  # lac1_img
+            [],    # gallery_items
+            None,  # size_img
+            "",   # stats
+        )
+
+        # Run the pipeline
         outputs = run_pipeline_on_image(str(img_path), tmpdir, save_artifacts=True)
 
         def load_pil(path_str):
@@ -42,9 +78,8 @@ 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'))
+        input_img = load_pil(outputs.get('InputImage')) or input_preview
         size_img = load_pil(str(Path(tmpdir) / 'results/size.size_analysis.png'))
-        yolo_img = load_pil(str(Path(tmpdir) / 'results/yolo_tips.png'))
 
         # Texture images (green band)
         lbp_path = Path(tmpdir) / 'texture_output/lbp_green.png'
@@ -60,14 +95,8 @@ def process(file_path):
 
         stats_text = outputs.get('StatsText', '')
 
-        # Output order matches UI components defined below
-        # Row 1: Input image (slightly larger)
-        # Row 2: Composite, Mask, Overlay
-        # Row 3: Texture images (LBP, HOG, Lac1)
-        # Row 4: Vegetation indices (gallery)
-        # Row 5: Morphology Size and YOLO Tips
-        # Final: Stats table
-        return (
+        # Final yield with all results (10 outputs, no YOLO)
+        yield (
             input_img,
             composite,
             mask,
@@ -77,102 +106,13 @@ def process(file_path):
             lac1_img,
             gallery_items,
             size_img,
-            yolo_img,
             stats_text,
         )
 
-def _load_pil(path: Path):
-    try:
-        if not path or not path.exists():
-            return None
-        im = Image.open(path)
-        out = im.copy()
-        im.close()
-        return out
-    except Exception:
-        return None
-
-def _first_existing(paths):
-    for p in paths:
-        if p and p.exists():
-            return p
-    return None
-
-def load_precomputed():
-    base = PRECOMPUTED_DIR
-    if not base.exists():
-        return None, None, None, None, None, None, None, [], None, None, ""
-
-    # Common subdirs
-    results = base / "results"
-    veg = base / "Vegetation_indices_images"
-    tex = base / "texture_output"
-
-    input_img = _load_pil(_first_existing([
-        base / "input_image.png",
-        base / "input_image.tif",
-        base / "input.png",
-    ]))
-    composite = _load_pil(_first_existing([
-        results / "composite.png",
-    ]))
-    mask = _load_pil(results / "mask.png")
-    overlay = _load_pil(results / "overlay.png")
-
-    texture_img = _load_pil(_first_existing([
-        tex / "lbp_green.png",
-        tex / "lbp.png",
-    ]))
-    hog_img = _load_pil(_first_existing([
-        tex / "hog_green.png",
-        tex / "hog.png",
-    ]))
-    lac1_img = _load_pil(_first_existing([
-        tex / "lac1_green.png",
-        tex / "lacunarity.png",
-    ]))
-
-    # Vegetation gallery in order
-    veg_order = ["ndvi.png", "gndvi.png", "savi.png"]
-    gallery_items = []
-    for fname in veg_order:
-        p = veg / fname
-        img = _load_pil(p)
-        if img is not None:
-            gallery_items.append(img)
-
-    size_img = _load_pil(results / "size.size_analysis.png")
-    yolo_img = _load_pil(results / "yolo_tips.png")
-
-    stats_txt_path = _first_existing([
-        base / "stats.txt",
-        results / "stats.txt",
-    ])
-    stats_text = ""
-    if stats_txt_path and stats_txt_path.exists():
-        try:
-            stats_text = stats_txt_path.read_text()
-        except Exception:
-            stats_text = ""
-
-    return (
-        input_img,
-        composite,
-        mask,
-        overlay,
-        texture_img,
-        hog_img,
-        lac1_img,
-        gallery_items,
-        size_img,
-        yolo_img,
-        stats_text,
-    )
-
 
 with gr.Blocks() as demo:
     gr.Markdown("# 🌿 Automated Plant Analysis Demo")
-    gr.Markdown("Upload a sorghum plant image (TIFF preferred) to compute and visualize composite, mask, overlay, texture (LBP), vegetation indices, and statistics.")
+    gr.Markdown("Upload a plant image (TIFF preferred) to compute and visualize composite, mask, overlay, texture, vegetation indices, and statistics.")
 
     with gr.Row():
         with gr.Column():
@@ -182,11 +122,17 @@ with gr.Blocks() as demo:
                 file_types=[".tif", ".tiff", ".png", ".jpg"],
                 label="Upload Image"
             )
+            preset = gr.Radio(
+                choices=list(PRESET_IMAGES.keys()),
+                label="Or choose a preset image",
+                value=None
+            )
             run = gr.Button("Run Pipeline", variant="primary")
 
-    # Row 1: input image, slightly larger
+    # Row 1: input image
     with gr.Row():
         input_img = gr.Image(type="pil", label="Input Image", interactive=False, height=380)
+    
     # Row 2: composite, mask, overlay
     with gr.Row():
         composite_img = gr.Image(type="pil", label="Composite (Segmentation Input)", interactive=False)
@@ -200,20 +146,18 @@ with gr.Blocks() as demo:
         lac1_img = gr.Image(type="pil", label="Texture Lac1 (Green Band)", interactive=False)
     
     # Row 4: vegetation indices
-
     gallery = gr.Gallery(label="Vegetation Indices", columns=3, height="auto")
 
-    # Row 5: morphology and YOLO tips
+    # Row 5: morphology size (YOLO removed)
     with gr.Row():
         size_img = gr.Image(type="pil", label="Morphology Size", interactive=False)
-        yolo_img = gr.Image(type="pil", label="YOLO Tips", interactive=False)
 
     # Final: statistics table
     stats = gr.Textbox(label="Statistics", lines=4)
 
     run.click(
         process,
-        inputs=inp,
+        inputs=[inp, preset],
         outputs=[
             input_img,
             composite_img,
@@ -224,12 +168,9 @@ with gr.Blocks() as demo:
             lac1_img,
             gallery,
             size_img,
-            yolo_img,
             stats,
         ]
     )
 
-    # No preloading: start with empty UI until the user runs the pipeline
-
 if __name__ == "__main__":
     demo.launch()

sorghum_pipeline/data/preprocessor.py

@@ -23,6 +23,12 @@ class ImagePreprocessor:
     
     def process_raw_image(self, pil_img: Image.Image) -> Tuple[np.ndarray, Dict[str, np.ndarray]]:
         """Split the 4-band RAW into tiles and build composite + spectral stack."""
+        # Downsample for 2x speed
+        w, h = pil_img.size
+        if w > 768 or h > 768:
+            scale = 768 / max(w, h)
+            pil_img = pil_img.resize((int(w * scale), int(h * scale)), Image.BILINEAR)
+        
         d = pil_img.size[0] // 2
         boxes = [(j, i, j + d, i + d)
                  for i, j in product(range(0, pil_img.height, d),

sorghum_pipeline/features/morphology.py

@@ -39,11 +39,12 @@ class MorphologyExtractor:
             pcv.params.dpi = 100
     
     def extract_morphology_features(self, image: np.ndarray, mask: np.ndarray) -> Dict[str, Any]:
-        """Return images {'size_analysis', 'yolo_tips'} and traits including 'plant_height_cm' and 'num_yolo_tips'."""
+        """Fast size visualization (YOLO disabled for speed). Simplified for performance."""
         features: Dict[str, Any] = {'traits': {}, 'images': {}, 'success': False}
         
         try:
-            clean_mask = self._preprocess_mask(mask)
+            # Use raw mask (no preprocessing for speed)
+            clean_mask = mask
             if clean_mask is None:
                 return features
 
@@ -51,25 +52,10 @@ 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(size_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, size_mask)
-                features['images']['size_analysis'] = vis
-                features['success'] = True
+            # 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]
@@ -79,11 +65,8 @@ class MorphologyExtractor:
             else:
                 features['traits']['plant_height_cm'] = 0.0
 
-            # YOLO tips overlay (optional) — use the original mask (same as frontend)
-            yolo_img, tips = self._detect_yolo_tips(rgb, 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)
+            # YOLO disabled for speed
+            features['traits']['num_yolo_tips'] = 0
 
         except Exception as e:
             logger.error(f"Morphology extraction failed: {e}")

sorghum_pipeline/output/manager.py

@@ -222,26 +222,7 @@ class OutputManager:
                     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)
-            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}")
+            # YOLO disabled for speed - skip saving yolo_tips.png
         except Exception as e:
             logger.error(f"Failed to save size analysis: {e}")
     

sorghum_pipeline/pipeline.py

@@ -123,7 +123,7 @@ class SorghumPipeline:
             composite = pdata['composite']
             mask = pdata.get('mask')
 
-            # --- Texture: LBP/HOG/Lacunarity on green band ---
+            # --- Texture: LBP/HOG/Lacunarity on green band (downsample for speed) ---
             pdata['texture_features'] = {}
             spectral = pdata.get('spectral_stack', {})
             if 'green' in spectral:
@@ -131,8 +131,20 @@ class SorghumPipeline:
                 if green_band.ndim == 3 and green_band.shape[-1] == 1:
                     green_band = green_band[..., 0]
 
-                if mask is not None:
-                    valid = np.where(mask > 0, green_band, np.nan)
+                # Downsample to 256x256 max for faster texture computation
+                h, w = green_band.shape[:2]
+                if h > 256 or w > 256:
+                    scale = 256 / max(h, w)
+                    green_band = cv2.resize(green_band, None, fx=scale, fy=scale, interpolation=cv2.INTER_LINEAR)
+                    if mask is not None:
+                        mask_resized = cv2.resize(mask, (green_band.shape[1], green_band.shape[0]), interpolation=cv2.INTER_NEAREST)
+                    else:
+                        mask_resized = None
+                else:
+                    mask_resized = mask
+
+                if mask_resized is not None:
+                    valid = np.where(mask_resized > 0, green_band, np.nan)
                 else:
                     valid = green_band
 

sorghum_pipeline/segmentation/manager.py

@@ -38,8 +38,9 @@ class SegmentationManager:
             token=hf_token,
         ).eval().to(self.device)
         
+        # Use 512x512 for 4x speed improvement
         self.transform = transforms.Compose([
-            transforms.Resize((1024, 1024)),
+            transforms.Resize((512, 512)),
             transforms.ToTensor(),
             transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
         ])