update

app.py

@@ -41,10 +41,11 @@ def process(image):
 
         overlay = load_pil(outputs.get('Overlay'))
         mask = load_pil(outputs.get('Mask'))
+        composite = load_pil(outputs.get('Composite'))
         order = ['NDVI', 'ARI', 'GNDVI']
         gallery_items = [load_pil(outputs[k]) for k in order if k in outputs]
         stats_text = outputs.get('StatsText', '')
-        return overlay, mask, gallery_items, stats_text
+        return composite, overlay, mask, gallery_items, stats_text
 
 with gr.Blocks() as demo:
     gr.Markdown("# 🌿 Sorghum Plant Analysis Demo")
@@ -58,6 +59,7 @@ with gr.Blocks() as demo:
             preview = gr.Image(type="pil", label="Uploaded Image Preview", interactive=False)
 
     with gr.Row():
+        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)
 
@@ -66,7 +68,7 @@ with gr.Blocks() as demo:
 
     # Update preview when image is uploaded
     inp.change(fn=show_preview, inputs=inp, outputs=preview)
-    run.click(process, inputs=inp, outputs=[overlay_img, mask_img, gallery, stats])
+    run.click(process, inputs=inp, outputs=[composite_img, overlay_img, mask_img, gallery, stats])
 
 if __name__ == "__main__":
     demo.launch()

sorghum_pipeline/data/preprocessor.py

@@ -1,4 +1,4 @@
-"""Minimal image preprocessing."""
+"""Minimal image preprocessing following the requested composite/spectral logic."""
 
 import numpy as np
 from PIL import Image
@@ -13,47 +13,49 @@ class ImagePreprocessor:
         self.target_size = target_size
     
     def convert_to_uint8(self, arr: np.ndarray) -> np.ndarray:
-        """Convert to uint8."""
-        arr = np.nan_to_num(arr, nan=0.0, posinf=0.0, neginf=0.0)
-        ptp = np.ptp(arr)
-        if ptp > 0:
-            normalized = (arr - arr.min()) / (ptp + 1e-6) * 255
-        else:
-            normalized = np.zeros_like(arr)
-        return np.clip(normalized, 0, 255).astype(np.uint8)
+        """Normalize any array to 8-bit uint8 in the range [0, 255]."""
+        a = np.nan_to_num(arr, nan=0.0, posinf=0.0, neginf=0.0)
+        ptp = np.ptp(a)
+        if ptp == 0:
+            return np.zeros_like(a, dtype=np.uint8)
+        norm = (a - a.min()) / (ptp + 1e-6) * 255
+        return norm.astype(np.uint8)
     
     def process_raw_image(self, pil_img: Image.Image) -> Tuple[np.ndarray, Dict[str, np.ndarray]]:
-        """Process 4-band to composite + spectral."""
+        """
+        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))]
-        # Convert each quadrant crop to grayscale to ensure 2D per band
-        stack = np.stack([
-            np.array(pil_img.crop(box).convert('L'), dtype=float)
-            for box in boxes
-        ], axis=-1)
-        
-        # Split into 4 bands and squeeze the extra dimension
-        green, red, red_edge, nir = [band.squeeze(-1) for band in np.split(stack, 4, axis=-1)]
-        
-        # Stack into (H, W, 3) composite: green, red_edge, red
-        composite = np.stack([green, red_edge, red], axis=-1)
-        composite_uint8 = self.convert_to_uint8(composite)
-        
-        # Keep spectral bands with single channel dimension for consistency
-        spectral_bands = {
-            "green": green[..., np.newaxis], 
-            "red": red[..., np.newaxis], 
-            "red_edge": red_edge[..., np.newaxis], 
-            "nir": nir[..., np.newaxis]
-        }
-        return composite_uint8, spectral_bands
+        boxes = [(j, i, j + d, i + d)
+                 for i, j in product(range(0, pil_img.height, d),
+                                    range(0, pil_img.width,  d))]
+        stack = np.stack([np.array(pil_img.crop(b), 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
     
     def create_composites(self, plants: Dict[str, Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
-        """Create composites."""
+        """
+        For each item in `plants`, grab one raw image and attach:
+          - pdata["composite"]: 8-bit BGR numpy array
+          - pdata["spectral_stack"]: dict of bands returned by process_raw_image
+        """
         for key, pdata in plants.items():
             if "raw_image" in pdata:
-                image, _ = pdata["raw_image"]
-                composite, spectral_stack = self.process_raw_image(image)
-                pdata["composite"] = composite
-                pdata["spectral_stack"] = spectral_stack
+                im, _ = pdata["raw_image"]
+            elif pdata.get("raw_images"):
+                im, _ = pdata["raw_images"][0]
+            else:
+                continue
+
+            comp, spec = self.process_raw_image(im)
+            pdata["composite"] = comp
+            pdata["spectral_stack"] = spec
         return plants

sorghum_pipeline/output/manager.py

@@ -69,6 +69,17 @@ class OutputManager:
         except Exception as e:
             logger.error(f"Failed to save overlay: {e}")
 
+        # 2b. Composite (input to segmentation)
+        try:
+            base_image = plant_data.get('composite')
+            if isinstance(base_image, np.ndarray):
+                # 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)
+        except Exception as e:
+            logger.error(f"Failed to save composite: {e}")
+
         # 3-5. Vegetation indices (NDVI, ARI, GNDVI)
         try:
             veg = plant_data.get('vegetation_indices', {})

wrapper.py

@@ -60,10 +60,13 @@ def run_pipeline_on_image(input_image_path: str, work_dir: str, save_artifacts:
     # Also include overlay and mask if present
     overlay_path = work / 'results/overlay.png'
     mask_path = work / 'results/mask.png'
+    composite_path = work / 'results/composite.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)
 
     # Extract simple stats for display if present in pipeline results
     try: