.

app.py

@@ -2,16 +2,14 @@ import gradio as gr
 import tempfile
 from pathlib import Path
 from wrapper import run_pipeline_on_image
-import numpy as np
 from PIL import Image
-from itertools import product
 
-def process(image_path):
-    if not image_path:
+def process(file_obj):
+    if not file_obj:
         return None, None, None, None, [], ""
     with tempfile.TemporaryDirectory() as tmpdir:
-        # Copy uploaded file as-is to preserve format/bit-depth
-        src = Path(image_path)
+        # file_obj is a dict when using gr.File(type="file")
+        src = Path(file_obj.name)
         ext = src.suffix.lstrip('.') or 'tif'
         img_path = Path(tmpdir) / f"input.{ext}"
         try:
@@ -20,6 +18,7 @@ def process(image_path):
         except Exception:
             # Fallback: save via PIL if direct copy fails
             Image.open(src).save(img_path)
+
         outputs = run_pipeline_on_image(str(img_path), tmpdir, save_artifacts=True)
 
         def load_pil(path_str):
@@ -27,7 +26,6 @@ def process(image_path):
                 if not path_str:
                     return None
                 im = Image.open(path_str)
-              #  im = im.convert('RGB')
                 copied = im.copy()
                 im.close()
                 return copied
@@ -52,7 +50,8 @@ with gr.Blocks() as demo:
 
     with gr.Row():
         with gr.Column():
-            inp = gr.Image(type="filepath", label="Upload Image")
+            # Use gr.File instead of gr.Image so TIFF is preserved
+            inp = gr.File(type="file", file_types=[".tif", ".tiff", ".png", ".jpg"], label="Upload Image")
             run = gr.Button("Run Pipeline", variant="primary")
 
     with gr.Row():
@@ -70,4 +69,4 @@ with gr.Blocks() as demo:
     run.click(process, inputs=inp, outputs=[size_img, composite_img, mask_img, overlay_img, texture_img, gallery, stats])
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

sorghum_pipeline/pipeline.py

@@ -46,46 +46,61 @@ class SorghumPipeline:
     def run(self, single_image_path: str) -> Dict[str, Any]:
         """Run pipeline on single image."""
         logger.info("Processing single image...")
-        
-        import time
-        
-        start = time.perf_counter()
-        import imghdr
-        import tifffile
-        import cv2
+
+        import time, imghdr, tifffile
         from PIL import Image
 
+        start = time.perf_counter()
+
+        # --- Load image with TIFF preference ---
         kind = imghdr.what(single_image_path)
+        suffix = Path(single_image_path).suffix.lower()
 
-        if kind == "tiff":
-            arr = tifffile.imread(single_image_path)
-            print("DEBUG loaded TIFF:", arr.shape, arr.dtype)
-            img = Image.fromarray(arr)  # keep pipeline compatibility
+        arr = None
+        if kind == "tiff" or suffix in [".tif", ".tiff"]:
+            try:
+                arr = tifffile.imread(single_image_path)
+                logger.info(f"Loaded TIFF: shape={arr.shape}, dtype={arr.dtype}")
+            except Exception as e:
+                logger.warning(f"tifffile failed ({e}), falling back to cv2")
+                arr = cv2.imread(single_image_path, cv2.IMREAD_UNCHANGED)
+                logger.info(f"Fallback read: shape={arr.shape}, dtype={arr.dtype}")
         else:
             arr = cv2.imread(single_image_path, cv2.IMREAD_UNCHANGED)
-            print("DEBUG loaded non-TIFF:", arr.shape, arr.dtype)
-            img = Image.fromarray(arr)
-                
-        print("Debug: Uploaded image shape: ", arr.shape)
+            logger.info(f"Loaded non-TIFF: shape={arr.shape}, dtype={arr.dtype}")
+
+        # --- Normalize array shape ---
+        if arr is None:
+            raise ValueError(f"Could not read image: {single_image_path}")
+        if arr.ndim > 3:
+            arr = arr[..., 0]  # drop extra dimension
+        if arr.ndim == 3 and arr.shape[-1] == 1:
+            arr = arr[..., 0]  # squeeze singleton
+
+        logger.info(f"DEBUG normalized input: shape={arr.shape}, dtype={arr.dtype}")
+
+        # Wrap into PIL image for downstream pipeline
+        img = Image.fromarray(arr)
+
         plants = {
             "demo": {
                 "raw_image": (img, Path(single_image_path).name),
                 "plant_name": "demo",
             }
         }
-        
+
         # Process: composite → segment → features → save
         plants = self.preprocessor.create_composites(plants)
         plants = self._segment(plants)
         plants = self._extract_features(plants)
         self.output_manager.create_output_directories()
-        
+
         for key, pdata in plants.items():
             self.output_manager.save_plant_results(key, pdata)
-        
+
         elapsed = time.perf_counter() - start
         logger.info(f"Completed in {elapsed:.2f}s")
-        
+
         return {"plants": plants, "timing": elapsed}
 
     def _segment(self, plants: Dict[str, Any]) -> Dict[str, Any]:
@@ -101,60 +116,66 @@ class SorghumPipeline:
         return plants
     
     def _extract_features(self, plants: Dict[str, Any]) -> Dict[str, Any]:
-        """Extract features (NDVI only for now)."""
+        """Extract features: texture + vegetation indices."""
         for key, pdata in plants.items():
             composite = pdata['composite']
             mask = pdata.get('mask')
 
-            # Texture: ONLY LBP on green band within mask
+            # --- Texture: LBP on green band ---
             pdata['texture_features'] = {}
-            green_band = None
             spectral = pdata.get('spectral_stack', {})
             if 'green' in spectral:
-                green_band = spectral['green'].squeeze(-1).astype(np.float64)
+                green_band = np.asarray(spectral['green'], dtype=np.float64)
+                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)
                 else:
                     valid = green_band
-                # normalize to uint8 for LBP
-                v = valid.copy()
-                v = np.nan_to_num(v, nan=np.nanmin(v))
+
+                v = np.nan_to_num(valid, nan=np.nanmin(valid))
                 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', {})
+            # --- Vegetation indices ---
             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)
+
+            # --- Morphology (currently empty) ---
             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."""
+        """Compute NDVI, GNDVI, SAVI."""
         out = {}
         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
-            
-            arrays = [np.asarray(spectral[b].squeeze(-1), dtype=np.float64) for b in bands]
+
+            arrays = []
+            for b in bands:
+                arr = np.asarray(spectral[b], dtype=np.float64)
+                if arr.ndim == 3 and arr.shape[-1] == 1:
+                    arr = arr[..., 0]
+                arrays.append(arr)
+
             values = self.vegetation_extractor.index_formulas[name](*arrays).astype(np.float64)
             binary_mask = (mask > 0)
             masked_values = np.where(binary_mask, values, np.nan)
             valid = masked_values[~np.isnan(masked_values)]
-            
+
             stats = {
                 'mean': float(np.mean(valid)) if valid.size else 0.0,
                 'std': float(np.std(valid)) if valid.size else 0.0,
             }
             out[name] = {'values': masked_values, 'statistics': stats}
-        return out
+        return out