make the process faster

app.py

@@ -46,53 +46,8 @@ def process(file_path, preset_choice):
             # Fallback: save via PIL if direct copy fails
             Image.open(src).save(img_path)
 
-        # Show input image immediately (read exactly like pipeline for correctness)
-        try:
-            import imghdr
-            import tifffile  # type: ignore
-            import cv2  # type: ignore
-
-            kind = imghdr.what(str(img_path))
-            suffix = img_path.suffix.lower()
-
-            arr = None
-            if kind == "tiff" or suffix in [".tif", ".tiff"]:
-                try:
-                    arr = tifffile.imread(str(img_path))
-                except Exception:
-                    arr = cv2.imread(str(img_path), cv2.IMREAD_UNCHANGED)
-            else:
-                arr = cv2.imread(str(img_path), cv2.IMREAD_UNCHANGED)
-
-            if arr is None:
-                raise ValueError("Could not read image for preview")
-            if arr.ndim > 3:
-                arr = arr[..., 0]
-            if arr.ndim == 3 and arr.shape[-1] == 1:
-                arr = arr[..., 0]
-
-            input_preview = Image.fromarray(arr)
-        except Exception:
-            try:
-                preview_im = Image.open(img_path)
-                input_preview = preview_im.copy()
-                preview_im.close()
-            except Exception:
-                input_preview = None
-
-        # Initial yield showing input preview
-        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
-        )
+        # Don't show immediate preview - wait for pipeline's InputImage for correctness
+        input_preview = None
 
         # Helper to load PIL images
         def load_pil(path_str):

sorghum_pipeline/pipeline.py

@@ -155,28 +155,19 @@ class SorghumPipeline:
         # Create output directories early
         self.output_manager.create_output_directories()
 
-        # Stage 1: Create composite
-        logger.info("Stage 1: Creating composite...")
+        # Stage 1: Create composite + Segmentation (combined for speed)
+        logger.info("Stage 1: Creating composite and segmenting...")
         plants = self.preprocessor.create_composites(plants)
-        if progress_callback:
-            progress_callback("composite", plants)
-        # Save composite immediately for display
-        for key, pdata in plants.items():
-            self.output_manager.save_plant_results(key, pdata)
-        yield {"plants": plants, "stage": "composite"}
-
-        # Stage 2: Segmentation
-        logger.info("Stage 2: Segmentation...")
         plants = self._segment(plants)
         if progress_callback:
             progress_callback("segmentation", plants)
-        # Save mask and overlay
+        # Save composite, mask, overlay, and input image
         for key, pdata in plants.items():
             self.output_manager.save_plant_results(key, pdata)
         yield {"plants": plants, "stage": "segmentation"}
 
-        # Stage 3: Extract features (texture, vegetation, morphology)
-        logger.info("Stage 3: Extracting features...")
+        # Stage 2: Extract features (texture, vegetation, morphology)
+        logger.info("Stage 2: Extracting features...")
         plants = self._extract_features(plants)
         if progress_callback:
             progress_callback("features", plants)
@@ -215,10 +206,10 @@ class SorghumPipeline:
                 if green_band.ndim == 3 and green_band.shape[-1] == 1:
                     green_band = green_band[..., 0]
 
-                # Downsample to 256x256 max for faster texture computation
+                # Downsample to 128x128 max for faster texture computation (2x speedup)
                 h, w = green_band.shape[:2]
-                if h > 256 or w > 256:
-                    scale = 256 / max(h, w)
+                if h > 128 or w > 128:
+                    scale = 128 / 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)