.

app.py

@@ -5,7 +5,6 @@ from wrapper import run_pipeline_on_image
 import numpy as np
 from PIL import Image
 from itertools import product
-import logging
 
 def process(image_path):
     if not image_path:
@@ -16,26 +15,8 @@ def process(image_path):
         ext = src.suffix.lstrip('.') or 'tif'
         img_path = Path(tmpdir) / f"input.{ext}"
         try:
-            try:
-                # Log original file stats
-                size_bytes = src.stat().st_size if src.exists() else 0
-                try:
-                    with Image.open(src) as im_src:
-                        frames = getattr(im_src, 'n_frames', 1)
-                        logging.info(f"Uploaded file: path={src}, size_bytes={size_bytes}, mode={im_src.mode}, size={im_src.size}, frames={frames}")
-                except Exception:
-                    logging.info(f"Uploaded file: path={src}, size_bytes={size_bytes} (PIL open failed)")
-            except Exception:
-                pass
             img_bytes = src.read_bytes()
             img_path.write_bytes(img_bytes)
-            # Log copied file as read by PIL
-            try:
-                with Image.open(img_path) as im_tmp:
-                    frames_tmp = getattr(im_tmp, 'n_frames', 1)
-                    logging.info(f"Temp input: path={img_path}, mode={im_tmp.mode}, size={im_tmp.size}, frames={frames_tmp}")
-            except Exception:
-                logging.info(f"Temp input: path={img_path} (PIL open failed)")
         except Exception:
             # Fallback: save via PIL if direct copy fails
             Image.open(src).save(img_path)
@@ -46,7 +27,7 @@ def process(image_path):
                 if not path_str:
                     return None
                 im = Image.open(path_str)
-                im = im.convert('RGB')
+              #  im = im.convert('RGB')
                 copied = im.copy()
                 im.close()
                 return copied

sorghum_pipeline/data/preprocessor.py

@@ -27,10 +27,7 @@ class ImagePreprocessor:
         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 to grayscale so each band is single-channel
-        stack = np.stack([
-            np.array(pil_img.crop(b).convert('L'), dtype=float)
-        for b in boxes], axis=-1)
+        stack = np.stack([np.array(pil_img.crop(b), float) for b in boxes], axis=-1)
         # bands come in order: [green, red, red_edge, nir]
         green, red, red_edge, nir = np.split(stack, 4, axis=-1)
         # build composite using bands: Red, Red-Edge, Green

sorghum_pipeline/pipeline.py

@@ -13,7 +13,6 @@ 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__)
 
@@ -55,11 +54,6 @@ class SorghumPipeline:
         
         # Load image
         img = Image.open(single_image_path)
-        try:
-            frames = getattr(img, 'n_frames', 1)
-        except Exception:
-            frames = 1
-        logger.info(f"Loaded input: path={single_image_path}, mode={img.mode}, size={img.size}, frames={frames}")
         plants = {
             "demo": {
                 "raw_image": (img, Path(single_image_path).name),
@@ -104,14 +98,7 @@ class SorghumPipeline:
             green_band = None
             spectral = pdata.get('spectral_stack', {})
             if 'green' in spectral:
-                gb = spectral['green']
-                gb = np.asarray(gb)
-                # robustly collapse to 2D if it arrived as 3-channel
-                if gb.ndim == 3 and gb.shape[2] > 1:
-                    gb = gb[..., 0]
-                elif gb.ndim == 3 and gb.shape[2] == 1:
-                    gb = gb.squeeze(-1)
-                green_band = gb.astype(np.float64)
+                green_band = spectral['green'].squeeze(-1).astype(np.float64)
                 if mask is not None:
                     valid = np.where(mask > 0, green_band, np.nan)
                 else:
@@ -132,13 +119,9 @@ class SorghumPipeline:
             else:
                 pdata['vegetation_indices'] = {}
             
-            # 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'] = {}
+            # # Morphology: PlantCV size analysis (COMMENTED OUT)
+            # pdata['morphology_features'] = self.morphology_extractor.extract_morphology_features(composite, mask)
+            pdata['morphology_features'] = {}
         
         return plants
     
@@ -150,14 +133,7 @@ class SorghumPipeline:
             if not all(b in spectral for b in bands):
                 continue
             
-            arrays = []
-            for b in bands:
-                arr = np.asarray(spectral[b])
-                if arr.ndim == 3 and arr.shape[2] > 1:
-                    arr = arr[..., 0]
-                elif arr.ndim == 3 and arr.shape[2] == 1:
-                    arr = arr.squeeze(-1)
-                arrays.append(arr.astype(np.float64))
+            arrays = [np.asarray(spectral[b].squeeze(-1), dtype=np.float64) for b in bands]
             values = self.vegetation_extractor.index_formulas[name](*arrays).astype(np.float64)
             binary_mask = (mask > 0)
             masked_values = np.where(binary_mask, values, np.nan)

sorghum_pipeline/segmentation/manager.py

@@ -48,15 +48,22 @@ class SegmentationManager:
     def segment_image_soft(self, image: np.ndarray) -> np.ndarray:
         """Segment image and return soft mask [0,1]."""
         try:
+            logger.info(f"Segmentation: input image shape={image.shape}, dtype={image.dtype}")
             rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
             pil_image = Image.fromarray(rgb_image)
             input_tensor = self.transform(pil_image).unsqueeze(0).to(self.device)
+            try:
+                logger.info(f"Segmentation: tensor shape={input_tensor.shape}, device={self.device}")
+            except Exception:
+                pass
             
             with torch.no_grad():
                 preds = self.model(input_tensor)[-1].sigmoid().cpu()[0].squeeze(0).numpy()
+            logger.info(f"Segmentation: raw preds shape={preds.shape}, dtype={preds.dtype}")
             
             original_size = (image.shape[1], image.shape[0])
             soft_mask = cv2.resize(preds.astype(np.float32), original_size, interpolation=cv2.INTER_LINEAR)
+            logger.info(f"Segmentation: resized soft_mask shape={soft_mask.shape}, dtype={soft_mask.dtype}")
             return np.clip(soft_mask, 0.0, 1.0)
         except Exception as e:
             logger.error(f"Segmentation failed: {e}")

wrapper.py

@@ -39,6 +39,15 @@ def run_pipeline_on_image(input_image_path: str, work_dir: str, save_artifacts:
 
     # Collect outputs
     outputs: Dict[str, str] = {}
+    try:
+        # Log immediate output directory contents for debugging
+        for sub in ['results', 'Vegetation_indices_images', 'texture_output']:
+            p = work / sub
+            if p.exists():
+                files = sorted([str(x.name) for x in p.iterdir() if x.is_file()])
+                print(f"Artifacts in {sub}: {files}")
+    except Exception:
+        pass
 
     # Collect desired vegetation indices (replace ARI with SAVI)
     wanted = [