update

app.py

@@ -6,108 +6,61 @@ import numpy as np
 from PIL import Image
 from itertools import product
 
-def show_preview(image):
-    """Render uploaded image faithfully, including 16-bit/single-channel inputs.
-
-    - RGB/RGBA: show as-is (strip alpha)
-    - 16-bit or single-channel: min-max (or 1-99%ile) normalize to 8-bit for display
-    """
-    if image is None:
-        return None
-    try:
-        arr = np.array(image)
-        # RGBA → RGB
-        if arr.ndim == 3 and arr.shape[2] == 4:
-            image = image.convert("RGB")
-            arr = np.array(image)
-        # RGB
-        if arr.ndim == 3 and arr.shape[2] == 3:
-            # If high bit-depth or non-uint8, normalize per-channel for visualization
-            if arr.dtype != np.uint8 or np.max(arr) > 255:
-                a = np.nan_to_num(arr.astype(np.float64), nan=0.0, posinf=0.0, neginf=0.0)
-                vis = np.empty_like(a, dtype=np.float64)
-                for c in range(3):
-                    vmin = np.percentile(a[..., c], 1.0)
-                    vmax = np.percentile(a[..., c], 99.0)
-                    if not np.isfinite(vmin) or not np.isfinite(vmax) or vmax <= vmin:
-                        vmin, vmax = float(np.min(a[..., c])), float(np.max(a[..., c]))
-                    denom = max(vmax - vmin, 1e-6)
-                    vis[..., c] = np.clip((a[..., c] - vmin) / denom, 0.0, 1.0) * 255.0
-                return Image.fromarray(vis.astype(np.uint8), mode='RGB')
-            return image
-        # Single-channel or higher bit-depth
-        if arr.ndim == 2 or (arr.ndim == 3 and arr.shape[2] == 1):
-            if arr.ndim == 3:
-                arr = arr[..., 0]
-            a = np.nan_to_num(arr.astype(np.float64), nan=0.0, posinf=0.0, neginf=0.0)
-            # Robust contrast stretch
-            vmin = np.percentile(a, 1.0)
-            vmax = np.percentile(a, 99.0)
-            if not np.isfinite(vmin) or not np.isfinite(vmax) or vmax <= vmin:
-                vmin, vmax = float(np.min(a)), float(np.max(a))
-            denom = max(vmax - vmin, 1e-6)
-            vis = np.clip((a - vmin) / denom, 0.0, 1.0) * 255.0
-            vis8 = vis.astype(np.uint8)
-            return Image.fromarray(vis8, mode='L')
-        # Fallback
-        return image.convert("RGB")
-    except Exception:
-        return image
-
 def process(image):
     if image is None:
-        return None, None, [], ""
+        return None, None, None, None, [], ""
     with tempfile.TemporaryDirectory() as tmpdir:
-        # Save PIL image preserving original format
         ext = image.format.lower() if image.format else 'png'
         img_path = Path(tmpdir) / f"input.{ext}"
         image.save(img_path)
         outputs = run_pipeline_on_image(str(img_path), tmpdir, save_artifacts=True)
 
-        # Assemble displays
         def load_pil(path_str):
             try:
                 if not path_str:
                     return None
                 im = Image.open(path_str)
                 im = im.convert('RGB')
-                # Copy to memory so it survives after tmpdir is removed
                 copied = im.copy()
                 im.close()
                 return copied
             except Exception:
                 return None
 
+        composite = load_pil(outputs.get('Composite'))
         overlay = load_pil(outputs.get('Overlay'))
         mask = load_pil(outputs.get('Mask'))
-        composite = load_pil(outputs.get('Composite'))
-        order = ['NDVI', 'ARI', 'GNDVI']
+        size_img = load_pil(str(Path(tmpdir) / 'results/size.size_analysis.png'))
+        # Texture LBP green path
+        lbp_path = Path(tmpdir) / 'texture_output/lbp_green.png'
+        texture_img = load_pil(str(lbp_path)) if lbp_path.exists() else None
+        order = ['NDVI', 'GNDVI', 'SAVI']
         gallery_items = [load_pil(outputs[k]) for k in order if k in outputs]
         stats_text = outputs.get('StatsText', '')
-        return composite, overlay, mask, gallery_items, stats_text
+        return size_img, composite, mask, overlay, texture_img, gallery_items, stats_text
 
 with gr.Blocks() as demo:
     gr.Markdown("# 🌿 Sorghum Plant Analysis Demo")
-    gr.Markdown("Upload a sorghum plant image to analyze vegetation indices, segmentation overlay, and stats.")
+    gr.Markdown("Upload a sorghum plant image to compute and visualize composite, mask, overlay, texture (LBP), vegetation indices, and statistics.")
 
     with gr.Row():
         with gr.Column():
             inp = gr.Image(type="pil", label="Upload Image")
             run = gr.Button("Run Pipeline", variant="primary")
-        with gr.Column():
-            preview = gr.Image(type="pil", label="Uploaded Image Preview", interactive=False)
 
     with gr.Row():
+        size_img = gr.Image(type="pil", label="Morphology Size", interactive=False)
         composite_img = gr.Image(type="pil", label="Composite (Segmentation Input)", interactive=False)
-        overlay_img = gr.Image(type="pil", label="Segmentation Overlay", interactive=False)
         mask_img = gr.Image(type="pil", label="Mask", interactive=False)
+        overlay_img = gr.Image(type="pil", label="Segmentation Overlay", interactive=False)
+
+    with gr.Row():
+        texture_img = gr.Image(type="pil", label="Texture LBP (Green Band)", interactive=False)
 
     gallery = gr.Gallery(label="Vegetation Indices", columns=3, height="auto")
     stats = gr.Textbox(label="Statistics", lines=4)
 
-    # Update preview when image is uploaded
-    inp.change(fn=show_preview, inputs=inp, outputs=preview)
-    run.click(process, inputs=inp, outputs=[composite_img, overlay_img, mask_img, gallery, stats])
+    run.click(process, inputs=inp, outputs=[size_img, composite_img, mask_img, overlay_img, texture_img, gallery, stats])
 
 if __name__ == "__main__":
     demo.launch()

sorghum_pipeline/data/preprocessor.py

@@ -1,9 +1,14 @@
-"""Minimal image preprocessing following the requested composite/spectral logic."""
+"""Minimal image preprocessing following the requested composite/spectral logic.
+
+This now delegates composite building to `src.composite.process_raw_image`
+so results match the verified src pipeline exactly.
+"""
 
 import numpy as np
 from PIL import Image
 from typing import Dict, Tuple, Any
 from itertools import product
+from src.composite import process_raw_image as src_process_raw_image
 
 
 class ImagePreprocessor:
@@ -22,25 +27,9 @@ class ImagePreprocessor:
         return norm.astype(np.uint8)
     
     def process_raw_image(self, pil_img: Image.Image) -> Tuple[np.ndarray, Dict[str, np.ndarray]]:
-        """
-        Split a 4-band RAW mosaic image into tiles and build:
-        - composite: 8-bit BGR array arranged as (green, red_edge, red)
-        - spectral stack: dict with keys green, red, red_edge, nir (each HxWx1)
-        """
-        d = pil_img.size[0] // 2
-        boxes = [(j, i, j + d, i + d)
-                 for i, j in product(range(0, pil_img.height, d),
-                                    range(0, pil_img.width,  d))]
-        # Ensure each quadrant is single-channel (grayscale) so bands are 2D
-        stack = np.stack([np.array(pil_img.crop(b).convert('L'), float) for b in boxes], axis=-1)
-        green, red, red_edge, nir = np.split(stack, 4, axis=-1)
-
-        # Build BGR composite so that displayed RGB = (red, red_edge, green)
-        comp = np.concatenate([green, red_edge, red], axis=-1)
-        comp_uint8 = self.convert_to_uint8(comp)
-
-        spectral_bands = {"green": green, "red": red, "red_edge": red_edge, "nir": nir}
-        return comp_uint8, spectral_bands
+        """Use src.composite.process_raw_image for parity with src flow."""
+        comp_uint8_bgr, spectral_bands = src_process_raw_image(pil_img)
+        return comp_uint8_bgr, spectral_bands
     
     def create_composites(self, plants: Dict[str, Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
         """

sorghum_pipeline/features/vegetation.py

@@ -12,21 +12,21 @@ logger = logging.getLogger(__name__)
 class VegetationIndexExtractor:
     """Minimal vegetation index extraction."""
     
-    def __init__(self, epsilon: float = 1e-10, soil_factor: float = 0.16):
+    def __init__(self, epsilon: float = 1e-10, soil_factor: float = 0.5):
         """Initialize with defaults."""
         self.epsilon = epsilon
         self.soil_factor = soil_factor
         
         self.index_formulas = {
             "NDVI": lambda nir, red: (nir - red) / (nir + red + self.epsilon),
-            "ARI": lambda green, red_edge: (1.0 / (green + self.epsilon)) - (1.0 / (red_edge + self.epsilon)),
             "GNDVI": lambda nir, green: (nir - green) / (nir + green + self.epsilon),
+            "SAVI": lambda nir, red: ((nir - red) / (nir + red + self.soil_factor)) * (1.0 + self.soil_factor),
         }
         
         self.index_bands = {
             "NDVI": ["nir", "red"],
-            "ARI": ["green", "red_edge"],
             "GNDVI": ["nir", "green"],
+            "SAVI": ["nir", "red"],
         }
     
     def compute_vegetation_indices(self, spectral_stack: Dict[str, np.ndarray], 

sorghum_pipeline/output/manager.py

@@ -65,7 +65,9 @@ class OutputManager:
             mask = plant_data.get('mask')
             if isinstance(base_image, np.ndarray) and isinstance(mask, np.ndarray):
                 overlay = self._create_overlay(base_image, mask)
-                cv2.imwrite(str(results_dir / 'overlay.png'), overlay)
+                # Convert BGR→RGB for correct viewing in standard image viewers
+                overlay_rgb = cv2.cvtColor(overlay, cv2.COLOR_BGR2RGB)
+                cv2.imwrite(str(results_dir / 'overlay.png'), overlay_rgb)
         except Exception as e:
             logger.error(f"Failed to save overlay: {e}")
 
@@ -76,51 +78,65 @@ class OutputManager:
                 # Ensure uint8
                 if base_image.dtype != np.uint8:
                     base_image = self._normalize_to_uint8(base_image.astype(np.float64))
-                cv2.imwrite(str(results_dir / 'composite.png'), base_image)
+                # Convert BGR→RGB for human viewing
+                comp_rgb = cv2.cvtColor(base_image, cv2.COLOR_BGR2RGB)
+                cv2.imwrite(str(results_dir / 'composite.png'), comp_rgb)
         except Exception as e:
             logger.error(f"Failed to save composite: {e}")
 
-        # 3-5. Vegetation indices (NDVI, ARI, GNDVI)
+        # 3-5. Vegetation indices (NDVI, GNDVI, SAVI)
         try:
             veg = plant_data.get('vegetation_indices', {})
-            for name in ['NDVI', 'ARI', 'GNDVI']:
+            for name in ['NDVI', 'GNDVI', 'SAVI']:
                 data = veg.get(name, {})
                 values = data.get('values') if isinstance(data, dict) else None
                 if isinstance(values, np.ndarray) and values.size > 0:
                     try:
-                        cmap = cm.RdYlGn if name in ['NDVI', 'GNDVI'] else cm.magma
-                        vmin, vmax = (-1, 1) if name in ['NDVI', 'GNDVI'] else (0, 1)
-                        
+                        # Colormap with colorbar similar to src: use matplotlib savefig
+                        cmap = cm.RdYlGn
+                        # Value ranges
+                        if name in ['NDVI', 'GNDVI']:
+                            vmin, vmax = (-1, 1)
+                        else:
+                            vmin, vmax = (0, 1)
+
                         masked = np.ma.masked_invalid(values.astype(np.float64))
                         fig, ax = plt.subplots(figsize=(5, 5))
                         ax.set_axis_off()
                         ax.set_facecolor('white')
-                        ax.imshow(masked, cmap=cmap, vmin=vmin, vmax=vmax)
+                        im = ax.imshow(masked, cmap=cmap, vmin=vmin, vmax=vmax)
+                        # add colorbar
+                        cbar = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+                        cbar.ax.tick_params(labelsize=8)
                         plt.tight_layout()
-                        plt.savefig(veg_dir / f"{name.lower()}.png", dpi=100, bbox_inches='tight')
+                        plt.savefig(veg_dir / f"{name.lower()}.png", dpi=120, bbox_inches='tight')
                         plt.close(fig)
                     except Exception as e:
                         logger.error(f"Failed to save {name}: {e}")
         except Exception as e:
             logger.error(f"Failed to save vegetation indices: {e}")
 
-        # 6-8. Texture features (LBP, HOG, Lacunarity)
+        # 6. Texture features: ONLY LBP on green band
         try:
             tex = plant_data.get('texture_features', {})
-            color_band = tex.get('color', {})
-            feats = color_band.get('features', {})
-            
-            if isinstance(feats.get('lbp'), np.ndarray) and feats['lbp'].size > 0:
-                cv2.imwrite(str(tex_dir / 'lbp.png'), feats['lbp'].astype(np.uint8))
-            
-            if isinstance(feats.get('hog'), np.ndarray) and feats['hog'].size > 0:
-                cv2.imwrite(str(tex_dir / 'hog.png'), feats['hog'].astype(np.uint8))
-            
-            lac = feats.get('lac2')
-            if isinstance(lac, np.ndarray) and lac.size > 0:
-                if lac.dtype != np.uint8:
-                    lac = self._normalize_to_uint8(lac.astype(np.float64))
-                cv2.imwrite(str(tex_dir / 'lacunarity.png'), lac)
+            green_band = tex.get('green', {})
+            feats = green_band.get('features', {})
+
+            lbp = feats.get('lbp')
+            if isinstance(lbp, np.ndarray) and lbp.size > 0:
+                try:
+                    img = lbp.astype(np.float64)
+                    fig, ax = plt.subplots(figsize=(5, 5))
+                    ax.set_axis_off()
+                    ax.set_facecolor('white')
+                    im = ax.imshow(img, cmap='gray', vmin=0, vmax=255)
+                    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 / 'lbp_green.png', dpi=120, bbox_inches='tight')
+                    plt.close(fig)
+                except Exception as e:
+                    logger.error(f"Failed to save LBP with colorbar: {e}")
         except Exception as e:
             logger.error(f"Failed to save texture: {e}")
 
@@ -135,14 +151,21 @@ class OutputManager:
             logger.error(f"Failed to save size analysis: {e}")
     
     def _create_overlay(self, image: np.ndarray, mask: np.ndarray) -> np.ndarray:
-        """Create overlay (masked pixels only)."""
+        """Create green overlay on brightened composite, following src pipeline style."""
         if mask is None:
             return image
         if mask.shape[:2] != image.shape[:2]:
-            mask = cv2.resize(mask.astype(np.uint8), (image.shape[1], image.shape[0]), 
-                            interpolation=cv2.INTER_NEAREST)
+            mask = cv2.resize(mask.astype(np.uint8), (image.shape[1], image.shape[0]),
+                              interpolation=cv2.INTER_NEAREST)
         binary = (mask.astype(np.int32) > 0).astype(np.uint8) * 255
-        return cv2.bitwise_and(image, image, mask=binary)
+        base = image
+        if base.dtype != np.uint8:
+            base = self._normalize_to_uint8(base.astype(np.float64))
+        bright = cv2.convertScaleAbs(base, alpha=1.2, beta=15)
+        green_overlay = bright.copy()
+        green_overlay[binary == 255] = (0, 255, 0)
+        blended = cv2.addWeighted(bright, 1.0, green_overlay, 0.5, 0)
+        return blended
     
     def _normalize_to_uint8(self, arr: np.ndarray) -> np.ndarray:
         """Normalize to uint8."""

sorghum_pipeline/pipeline.py

@@ -13,6 +13,7 @@ from .data import ImagePreprocessor, MaskHandler
 from .features import TextureExtractor, VegetationIndexExtractor, MorphologyExtractor
 from .output import OutputManager
 from .segmentation import SegmentationManager
+from .features.morphology import MorphologyExtractor
 
 logger = logging.getLogger(__name__)
 
@@ -92,32 +93,47 @@ class SorghumPipeline:
         for key, pdata in plants.items():
             composite = pdata['composite']
             mask = pdata.get('mask')
-            
-            # # Texture: LBP, HOG, Lacunarity from pseudo-color (COMMENTED OUT)
-            # masked = self.mask_handler.apply_mask_to_image(composite, mask) if mask is not None else composite
-            # gray = cv2.cvtColor(masked, cv2.COLOR_BGR2GRAY)
-            # feats = self.texture_extractor.extract_all_texture_features(gray)
-            # stats = self.texture_extractor.compute_texture_statistics(feats, mask)
-            # pdata['texture_features'] = {'color': {'features': feats, 'statistics': stats}}
+
+            # Texture: ONLY LBP on green band within mask
             pdata['texture_features'] = {}
-            
-            # Vegetation: NDVI, ARI, GNDVI
+            green_band = None
+            spectral = pdata.get('spectral_stack', {})
+            if 'green' in spectral:
+                green_band = spectral['green'].squeeze(-1).astype(np.float64)
+                if mask is not None:
+                    valid = np.where(mask > 0, green_band, np.nan)
+                else:
+                    valid = green_band
+                # normalize to uint8 for LBP
+                v = valid.copy()
+                v = np.nan_to_num(v, nan=np.nanmin(v))
+                m, M = np.min(v), np.max(v)
+                denom = (M - m) if (M - m) > 1e-6 else 1.0
+                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}}}
+
+            # Vegetation: NDVI, GNDVI, SAVI
             spectral = pdata.get('spectral_stack', {})
             if spectral and mask is not None:
                 pdata['vegetation_indices'] = self._compute_vegetation(spectral, mask)
             else:
                 pdata['vegetation_indices'] = {}
             
-            # # Morphology: PlantCV size analysis (COMMENTED OUT)
-            # pdata['morphology_features'] = self.morphology_extractor.extract_morphology_features(composite, mask)
-            pdata['morphology_features'] = {}
+            # Morphology: compute size analysis image via internal extractor
+            try:
+                pdata['morphology_features'] = self.morphology_extractor.extract_morphology_features(
+                    cv2.cvtColor(composite, cv2.COLOR_BGR2RGB), mask
+                )
+            except Exception:
+                pdata['morphology_features'] = {}
         
         return plants
     
     def _compute_vegetation(self, spectral: Dict[str, np.ndarray], mask: np.ndarray) -> Dict[str, Any]:
         """Compute NDVI, ARI, GNDVI only."""
         out = {}
-        for name in ("NDVI", "ARI", "GNDVI"):
+        for name in ("NDVI", "GNDVI", "SAVI"):
             bands = self.vegetation_extractor.index_bands.get(name, [])
             if not all(b in spectral for b in bands):
                 continue

wrapper.py

@@ -40,18 +40,14 @@ def run_pipeline_on_image(input_image_path: str, work_dir: str, save_artifacts:
     # Collect outputs
     outputs: Dict[str, str] = {}
 
-    # Return only NDVI for now (others commented out for debugging)
+    # Collect desired vegetation indices (replace ARI with SAVI)
     wanted = [
         work / 'Vegetation_indices_images/ndvi.png',
-        work / 'Vegetation_indices_images/ari.png',
         work / 'Vegetation_indices_images/gndvi.png',
-        # work / 'texture_output/lbp.png',
-        # work / 'texture_output/hog.png',
-        # work / 'texture_output/lacunarity.png',
-        # work / 'results/size.size_analysis.png',
+        work / 'Vegetation_indices_images/savi.png',
     ]
     labels = [
-        'NDVI', 'ARI', 'GNDVI',  # 'LBP', 'HOG', 'Lacunarity', 'SizeAnalysis'
+        'NDVI', 'GNDVI', 'SAVI',
     ]
     for label, path in zip(labels, wanted):
         if path.exists():
@@ -75,7 +71,7 @@ def run_pipeline_on_image(input_image_path: str, work_dir: str, save_artifacts:
             _, pdata = next(iter(plants.items()))
             veg = pdata.get('vegetation_indices', {})
             stats_lines = []
-            for name in ['NDVI', 'ARI', 'GNDVI']:
+            for name in ['NDVI', 'GNDVI', 'SAVI']:
                 entry = veg.get(name, {})
                 st = entry.get('statistics', {}) if isinstance(entry, dict) else {}
                 if st: