Update main.py

main.py

@@ -4,12 +4,14 @@ import numpy as np
 import base64
 import gc
 import torch
+import time
+import traceback
 from dataclasses import dataclass
 from typing import Optional
 from scipy.ndimage import median_filter
 from scipy.optimize import curve_fit, minimize
 from ultralytics import YOLO
-from fastapi import FastAPI, UploadFile, File
+from fastapi import FastAPI, UploadFile, File, Query
 from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
 from skimage import color
@@ -21,6 +23,10 @@ torch.set_num_threads(1)
 MODEL_PATH = "best.pt"
 MAX_IMAGE_SIZE = 2048  
 CHECKER_WIDTH_CM = 6.3 
+MIN_RIND_FLESH_OVERLAP_RATIO = 0.10
+MIN_FLESH_PIXELS_FOR_FALLBACK = 100
+MAX_RIND_TO_FLESH_AREA_RATIO = 3.5
+MAX_RIND_CENTER_OFFSET_RATIO = 0.60
 
 # ==============================================================================
 # --- COLOR CALIBRATION LOGIC ---
@@ -84,7 +90,12 @@ def apply_color_pipeline(target_bgr, ref24, tgt24):
         
     X, Y = tgt24_wb, ref24
     W_init = np.linalg.inv(X.T @ X + 0.05 * np.eye(3)) @ X.T @ Y
-    res = minimize(objective, W_init.flatten(), method='Powell')
+    res = minimize(
+        objective,
+        W_init.flatten(),
+        method='Powell',
+        options={"maxiter": 150, "xtol": 1e-4, "ftol": 1e-4},
+    )
     W_opt = res.x.reshape(3, 3)
 
     corrected_lin = (tgt_lin_wb.reshape(-1, 3) @ W_opt).reshape(tgt_lin_wb.shape)
@@ -106,6 +117,14 @@ class ProcessResult:
     delta_e_final: Optional[float] = None
     image_base64: Optional[str] = None
     filename: Optional[str] = None
+    measurement_unit: Optional[str] = None
+    scale_source: Optional[str] = None
+    color_checker_found: bool = False
+    rind_source: Optional[str] = None
+    rind_overlap_ratio: Optional[float] = None
+    warnings: Optional[list] = None
+    timings_ms: Optional[dict] = None
+    processing_ms: Optional[int] = None
 
 class WatermelonProcessor:
     def __init__(self, model_path: str):
@@ -129,6 +148,106 @@ class WatermelonProcessor:
         divot_bot = d_bot * np.exp(w_bot * (-np.sin(t) - 1))
         return (ellipse * asymmetry) - divot_top - divot_bot + c_skew * np.sin(t) + c_bend * np.cos(t) * (np.sin(t) ** 2)
 
+    @staticmethod
+    def contour_centroid(contour):
+        M = cv2.moments(contour)
+        if M["m00"] == 0:
+            return None
+        return np.array([M["m10"] / M["m00"], M["m01"] / M["m00"]], dtype=np.float32)
+
+    @staticmethod
+    def mask_centroid(mask):
+        M = cv2.moments(mask)
+        if M["m00"] == 0:
+            return None
+        return np.array([M["m10"] / M["m00"], M["m01"] / M["m00"]], dtype=np.float32)
+
+    @staticmethod
+    def draw_single_contour(shape, contour):
+        mask = np.zeros(shape, dtype=np.uint8)
+        cv2.drawContours(mask, [contour.astype(np.int32)], -1, 255, -1)
+        return mask
+
+    @staticmethod
+    def flesh_envelope_mask(flesh_combined):
+        ys, xs = np.where(flesh_combined > 0)
+        if len(xs) < MIN_FLESH_PIXELS_FOR_FALLBACK:
+            return None
+
+        pts = np.column_stack([xs, ys]).astype(np.int32)
+        hull = cv2.convexHull(pts.reshape(-1, 1, 2))
+        envelope = np.zeros_like(flesh_combined)
+        cv2.drawContours(envelope, [hull], -1, 255, -1)
+
+        _, _, bw, bh = cv2.boundingRect(hull)
+        pad = int(max(12, min(80, round(max(bw, bh) * 0.035))))
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (pad * 2 + 1, pad * 2 + 1))
+        envelope = cv2.dilate(envelope, kernel, iterations=1)
+
+        close_size = max(5, (pad // 2) * 2 + 1)
+        close_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (close_size, close_size))
+        return cv2.morphologyEx(envelope, cv2.MORPH_CLOSE, close_kernel)
+
+    @staticmethod
+    def choose_target_rind_mask(rind_mask, flesh_combined):
+        warnings = []
+        flesh_area = cv2.countNonZero(flesh_combined)
+        cnts, _ = cv2.findContours(rind_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+
+        if not cnts:
+            envelope = WatermelonProcessor.flesh_envelope_mask(flesh_combined)
+            if envelope is None:
+                return rind_mask, "missing", None, ["No whole-watermelon mask and not enough flesh mask for fallback."]
+            return envelope, "flesh_envelope", 1.0, ["No whole-watermelon mask; estimated perimeter from flesh masks."]
+
+        scored = []
+        for cnt in cnts:
+            temp = WatermelonProcessor.draw_single_contour(rind_mask.shape, cnt)
+            overlap = cv2.countNonZero(cv2.bitwise_and(temp, flesh_combined))
+            ratio = overlap / max(flesh_area, 1)
+            scored.append((ratio, cv2.contourArea(cnt), cnt, temp))
+
+        scored.sort(key=lambda item: (item[0], item[1]), reverse=True)
+        best_ratio, best_area, best_cnt, best_mask = scored[0]
+
+        if flesh_area == 0:
+            warnings.append("No flesh masks detected; using largest whole-watermelon mask.")
+            largest = max(cnts, key=cv2.contourArea)
+            return WatermelonProcessor.draw_single_contour(rind_mask.shape, largest), "whole_mask_no_flesh", None, warnings
+
+        flesh_center = WatermelonProcessor.mask_centroid(flesh_combined)
+        rind_center = WatermelonProcessor.contour_centroid(best_cnt)
+        ys, xs = np.where(flesh_combined > 0)
+        flesh_extent = max(float(np.ptp(xs)) if len(xs) else 1.0, float(np.ptp(ys)) if len(ys) else 1.0, 1.0)
+        center_offset_ratio = 0.0
+        if flesh_center is not None and rind_center is not None:
+            center_offset_ratio = float(np.linalg.norm(flesh_center - rind_center) / flesh_extent)
+        area_ratio = float(best_area / max(flesh_area, 1))
+
+        if best_ratio >= MIN_RIND_FLESH_OVERLAP_RATIO:
+            if area_ratio <= MAX_RIND_TO_FLESH_AREA_RATIO and center_offset_ratio <= MAX_RIND_CENTER_OFFSET_RATIO:
+                return best_mask, "whole_mask_overlap", float(best_ratio), warnings
+            warnings.append("Whole-watermelon mask overlapped flesh but looked too large or off-center; using fallback.")
+
+        if flesh_center is not None and rind_center is not None:
+            shifted_cnt = best_cnt.astype(np.float32) + (flesh_center - rind_center).reshape(1, 1, 2)
+            shifted_mask = WatermelonProcessor.draw_single_contour(rind_mask.shape, shifted_cnt)
+            shifted_ratio = cv2.countNonZero(cv2.bitwise_and(shifted_mask, flesh_combined)) / max(flesh_area, 1)
+            if shifted_ratio >= MIN_RIND_FLESH_OVERLAP_RATIO and area_ratio <= MAX_RIND_TO_FLESH_AREA_RATIO:
+                if best_ratio >= MIN_RIND_FLESH_OVERLAP_RATIO:
+                    warnings.append("Whole-watermelon mask was suspicious; translated it to the flesh-mask centroid.")
+                else:
+                    warnings.append("Whole-watermelon mask did not overlap flesh; translated it to the flesh-mask centroid.")
+                return shifted_mask, "translated_whole_mask", float(shifted_ratio), warnings
+
+        envelope = WatermelonProcessor.flesh_envelope_mask(flesh_combined)
+        if envelope is not None:
+            warnings.append("Whole-watermelon mask did not overlap flesh; estimated perimeter from flesh masks.")
+            return envelope, "flesh_envelope", float(best_ratio), warnings
+
+        warnings.append("Whole-watermelon mask did not overlap flesh and fallback was unavailable.")
+        return best_mask, "low_overlap_whole_mask", float(best_ratio), warnings
+
     @staticmethod
     def get_stable_perimeter_data(rind_mask, flesh_combined):
         cnts, _ = cv2.findContours(rind_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
@@ -192,7 +311,13 @@ class WatermelonProcessor:
             def parabola(y_n, a, b, c): return a*(y_n**2) + b*y_n + c
             max_bend = w * 0.08
             try:
-                popt_mid, _ = curve_fit(parabola, (gap_points[:,0]-y_mean)/y_span, gap_points[:,1], bounds=([-max_bend, -np.inf, -np.inf],[max_bend, np.inf, np.inf]))
+                popt_mid, _ = curve_fit(
+                    parabola,
+                    (gap_points[:,0]-y_mean)/y_span,
+                    gap_points[:,1],
+                    bounds=([-max_bend, -np.inf, -np.inf],[max_bend, np.inf, np.inf]),
+                    max_nfev=1500,
+                )
             except: popt_mid = [0.0, 0.0, cx]
             
             ys_extrap = np.linspace(0, h, 500)
@@ -206,8 +331,30 @@ class WatermelonProcessor:
         pred_cnt_cv = pred_cnt.reshape(-1, 1, 2).astype(np.int32)
         return np.array([pt for pt in pts_orig if cv2.pointPolygonTest(pred_cnt_cv, (float(pt[0]), float(pt[1])), False) >= 0])
 
-    def process_image(self, image: np.ndarray, source_name: str, scale_ratio: float) -> ProcessResult:
-        if image is None: return ProcessResult(success=False, message="Could not decode image.")
+    def process_image(self, image: np.ndarray, source_name: str, scale_ratio: float, include_image: bool = True) -> ProcessResult:
+        timings = {}
+        stage_t = time.perf_counter()
+
+        def mark(stage_name):
+            nonlocal stage_t
+            now = time.perf_counter()
+            timings[stage_name] = int(round((now - stage_t) * 1000))
+            stage_t = now
+
+        def fail(message, **extra):
+            return ProcessResult(
+                success=False,
+                message=message,
+                filename=source_name,
+                warnings=warnings or None,
+                timings_ms=timings,
+                **extra,
+            )
+
+        warnings = []
+        if image is None:
+            return ProcessResult(success=False, message="Could not decode image.", filename=source_name)
+
         h, w = image.shape[:2]
 
         # --- 1. CALIBRATION & SCALING ---
@@ -222,135 +369,167 @@ class WatermelonProcessor:
                 tgt_warped = warp_checker(image, checker_corners)
                 tgt24 = sample_24_patches(tgt_warped)
                 dE_initial = float(np.mean(compute_deltaE_00(tgt24, self.ref24)))
-                
+
                 image = apply_color_pipeline(image, self.ref24, tgt24)
-                
+
                 tgt_warped_corr = warp_checker(image, checker_corners)
                 tgt24_corr = sample_24_patches(tgt_warped_corr)
                 dE_final = float(np.mean(compute_deltaE_00(tgt24_corr, self.ref24)))
         except Exception as e:
+            if cm_per_px is None:
+                warnings.append("ColorChecker not found; dimensions are returned in original-image pixels.")
+            else:
+                warnings.append("Color correction skipped after ColorChecker detection; dimensions are still in centimeters.")
             print(f"Calibration skipped for {source_name}: {e}")
-        
+        mark("calibration")
+
         # --- 2. YOLO INFERENCE (STRICTLY PARSING ALL 3 CLASSES) ---
         results = self.model(image, conf=0.25, retina_masks=True, verbose=False)
+        mark("yolo_inference")
+
         rind_mask = np.zeros((h, w), dtype=np.uint8)
-        flesh_l_contours =[]
+        flesh_l_contours = []
         flesh_r_contours = []
 
         if results[0].masks is None:
-            return ProcessResult(success=False, message="No masks detected.")
+            return fail(
+                "No masks detected.",
+                measurement_unit="cm" if cm_per_px is not None else "px",
+                scale_source="color_checker" if cm_per_px is not None else "original_pixels",
+                color_checker_found=checker_corners is not None,
+            )
 
         for mask_data, cls in zip(results[0].masks.xy, results[0].boxes.cls):
             contour = np.array(mask_data, dtype=np.int32)
             c_id = int(cls)
-            if c_id == 0: 
+            if c_id == 0:
                 cv2.drawContours(rind_mask, [contour], -1, 255, -1)
-            elif c_id == 1: 
+            elif c_id == 1:
                 flesh_l_contours.append(contour)
-            elif c_id == 2: 
+            elif c_id == 2:
                 flesh_r_contours.append(contour)
 
-        # Failsafe: if YOLO missed one side but predicted multiple of the other
+        # Failsafe: if YOLO missed one side but predicted multiple of the other.
         if len(flesh_l_contours) >= 2 and len(flesh_r_contours) == 0:
-            flesh_l_contours.sort(key=lambda cnt: cv2.moments(cnt)['m10'] / (cv2.moments(cnt)['m00'] + 1e-5))
+            flesh_l_contours.sort(key=lambda cnt: cv2.moments(cnt)["m10"] / (cv2.moments(cnt)["m00"] + 1e-5))
             flesh_r_contours.append(flesh_l_contours.pop())
+            warnings.append("Only flesh_left was detected; split the two left detections into left/right by x-position.")
         elif len(flesh_r_contours) >= 2 and len(flesh_l_contours) == 0:
-            flesh_r_contours.sort(key=lambda cnt: cv2.moments(cnt)['m10'] / (cv2.moments(cnt)['m00'] + 1e-5))
+            flesh_r_contours.sort(key=lambda cnt: cv2.moments(cnt)["m10"] / (cv2.moments(cnt)["m00"] + 1e-5))
             flesh_l_contours.append(flesh_r_contours.pop(0))
+            warnings.append("Only flesh_right was detected; split the two right detections into left/right by x-position.")
 
         flesh_l_m, flesh_r_m = np.zeros((h, w), dtype=np.uint8), np.zeros((h, w), dtype=np.uint8)
-        for cnt in flesh_l_contours: cv2.drawContours(flesh_l_m, [cnt], -1, 255, -1)
-        for cnt in flesh_r_contours: cv2.drawContours(flesh_r_m, [cnt], -1, 255, -1)
+        for cnt in flesh_l_contours:
+            cv2.drawContours(flesh_l_m, [cnt], -1, 255, -1)
+        for cnt in flesh_r_contours:
+            cv2.drawContours(flesh_r_m, [cnt], -1, 255, -1)
 
         flesh_combined = cv2.bitwise_or(flesh_l_m, flesh_r_m)
+        target_rind_mask, rind_source, rind_overlap_ratio, rind_warnings = self.choose_target_rind_mask(rind_mask, flesh_combined)
+        warnings.extend(rind_warnings)
+        mark("mask_parse")
 
         # --- 3. FIT & EXTRACTION ---
-        perimeter_data = self.get_stable_perimeter_data(rind_mask, flesh_combined)
-        if perimeter_data is None: return ProcessResult(success=False, message="No stable perimeter.")
+        perimeter_data = self.get_stable_perimeter_data(target_rind_mask, flesh_combined)
+        if perimeter_data is None:
+            return fail(
+                "No stable perimeter.",
+                measurement_unit="cm" if cm_per_px is not None else "px",
+                scale_source="color_checker" if cm_per_px is not None else "original_pixels",
+                color_checker_found=checker_corners is not None,
+                rind_source=rind_source,
+                rind_overlap_ratio=rind_overlap_ratio,
+            )
 
         t_data, r_raw, (cx, cy), rind_cnt = perimeter_data
         scale = np.mean(r_raw)
-        if scale <= 0: return ProcessResult(success=False, message="Invalid perimeter scale.")
-        
+        if scale <= 0:
+            return fail("Invalid perimeter scale.", rind_source=rind_source, rind_overlap_ratio=rind_overlap_ratio)
+
         try:
             popt, _ = curve_fit(
                 self.watermelon_model, t_data, r_raw / scale,
                 p0=[1.0, 1.1, 0.0, 0.05, 3.0, 0.05, 3.0, 0.0, 0.0, 0.0],
-                bounds=([0.5, 0.5, -0.4, 0.0, 0.1, 0.0, 0.1, -1.5, -0.2, -0.2],[2.0, 2.0, 0.4, 0.5, 50.0, 0.5, 50.0, 1.5, 0.2, 0.2]),
+                bounds=([0.5, 0.5, -0.4, 0.0, 0.1, 0.0, 0.1, -1.5, -0.2, -0.2], [2.0, 2.0, 0.4, 0.5, 50.0, 0.5, 50.0, 1.5, 0.2, 0.2]),
+                max_nfev=3000,
             )
-        except Exception as exc: return ProcessResult(success=False, message=f"Fit failed: {exc}")
+        except Exception as exc:
+            mark("fit")
+            return fail(f"Fit failed: {exc}", rind_source=rind_source, rind_overlap_ratio=rind_overlap_ratio)
 
         r2 = 1 - (np.sum((r_raw / scale - self.watermelon_model(t_data, *popt)) ** 2) / np.sum((r_raw / scale - 1) ** 2))
         t_fit = np.linspace(-np.pi, np.pi, 500)
         r_fit = self.watermelon_model(t_fit, *popt) * scale
         fit_pts = np.array([[r * np.cos(t) + cx, cy - r * np.sin(t)] for t, r in zip(t_fit, r_fit)])
-        
-        orig_scale = 1.0 / scale_ratio
-        if cm_per_px is None: cm_per_px = 1.0 
-        
+
         width_px = float(np.max(fit_pts[:, 0]) - np.min(fit_pts[:, 0]))
         height_px = float(np.max(fit_pts[:, 1]) - np.min(fit_pts[:, 1]))
         perimeter_px = float(np.sum(np.linalg.norm(np.diff(fit_pts, axis=0), axis=1)) + np.linalg.norm(fit_pts[-1] - fit_pts[0]))
 
         if cm_per_px is not None:
-            # Both checker and watermelon were measured on the scaled image.
-            # cm_per_px natively accounts for the scaling, no orig_scale needed!
+            measurement_unit = "cm"
+            scale_source = "color_checker"
             width_val = float(width_px * cm_per_px)
             height_val = float(height_px * cm_per_px)
             perimeter_val = float(perimeter_px * cm_per_px)
         else:
-            # Fallback to true original pixels
+            measurement_unit = "px"
+            scale_source = "original_pixels"
             orig_scale = 1.0 / scale_ratio
             width_val = float(width_px * orig_scale)
             height_val = float(height_px * orig_scale)
             perimeter_val = float(perimeter_px * orig_scale)
+        mark("fit")
 
         # --- 4. DRAWING ---
-        midline = self.get_dual_mask_midline(flesh_l_m, flesh_r_m, rind_cnt, fit_pts, cx, cy)
-        
-        # Color coding: Green=Rind, Blue=Left Flesh, Red=Right Flesh
-        output = image.copy().astype(np.float32)
-        alpha = 0.42
-        output[..., 0] = np.where(rind_mask > 0, output[..., 0] * (1 - alpha) + 0.0 * alpha, output[..., 0])
-        output[..., 1] = np.where(rind_mask > 0, output[..., 1] * (1 - alpha) + 170.0 * alpha, output[..., 1])
-        output[..., 2] = np.where(rind_mask > 0, output[..., 2] * (1 - alpha) + 0.0 * alpha, output[..., 2])
-        
-        output[..., 0] = np.where(flesh_l_m > 0, output[..., 0] * (1 - alpha) + 255.0 * alpha, output[..., 0])
-        output[..., 1] = np.where(flesh_l_m > 0, output[..., 1] * (1 - alpha) + 0.0 * alpha, output[..., 1])
-        output[..., 2] = np.where(flesh_l_m > 0, output[..., 2] * (1 - alpha) + 0.0 * alpha, output[..., 2])
-
-        output[..., 0] = np.where(flesh_r_m > 0, output[..., 0] * (1 - alpha) + 0.0 * alpha, output[..., 0])
-        output[..., 1] = np.where(flesh_r_m > 0, output[..., 1] * (1 - alpha) + 0.0 * alpha, output[..., 1])
-        output[..., 2] = np.where(flesh_r_m > 0, output[..., 2] * (1 - alpha) + 255.0 * alpha, output[..., 2])
-        
-        output = np.clip(output, 0, 255).astype(np.uint8)
-        
-        # Draw Color Checker Box
-        if checker_corners is not None:
-            cv2.polylines(output, [np.int32(checker_corners)], True, (0, 165, 255), 4)
-
-        # Draw Midline and Midline Intersections
-        if len(midline) > 1: 
-            cv2.polylines(output, [midline.astype(np.int32)], False, (0, 255, 255), 3)
-            # Add intersection dots (White inner, Black outer)
-            pt_top = (int(midline[0][0]), int(midline[0][1]))
-            pt_bot = (int(midline[-1][0]), int(midline[-1][1]))
-            cv2.circle(output, pt_top, 10, (0, 0, 0), 2)
-            cv2.circle(output, pt_top, 8, (255, 255, 255), -1)
-            cv2.circle(output, pt_bot, 10, (0, 0, 0), 2)
-            cv2.circle(output, pt_bot, 8, (255, 255, 255), -1)
-
-        # Draw Predicted Perimeter Boundary
-        cv2.polylines(output, [fit_pts.astype(np.int32)], True, (0, 255, 0), 3)
-
-        _, buffer = cv2.imencode('.jpg', output,[cv2.IMWRITE_JPEG_QUALITY, 85])
-        img_base64 = base64.b64encode(buffer).decode('utf-8')
+        img_base64 = None
+        if include_image:
+            midline = self.get_dual_mask_midline(flesh_l_m, flesh_r_m, rind_cnt, fit_pts, cx, cy)
+
+            # Color coding: Green=chosen rind, Blue=Left Flesh, Red=Right Flesh.
+            output = image.copy().astype(np.float32)
+            alpha = 0.42
+            output[..., 0] = np.where(target_rind_mask > 0, output[..., 0] * (1 - alpha) + 0.0 * alpha, output[..., 0])
+            output[..., 1] = np.where(target_rind_mask > 0, output[..., 1] * (1 - alpha) + 170.0 * alpha, output[..., 1])
+            output[..., 2] = np.where(target_rind_mask > 0, output[..., 2] * (1 - alpha) + 0.0 * alpha, output[..., 2])
+
+            output[..., 0] = np.where(flesh_l_m > 0, output[..., 0] * (1 - alpha) + 255.0 * alpha, output[..., 0])
+            output[..., 1] = np.where(flesh_l_m > 0, output[..., 1] * (1 - alpha) + 0.0 * alpha, output[..., 1])
+            output[..., 2] = np.where(flesh_l_m > 0, output[..., 2] * (1 - alpha) + 0.0 * alpha, output[..., 2])
+
+            output[..., 0] = np.where(flesh_r_m > 0, output[..., 0] * (1 - alpha) + 0.0 * alpha, output[..., 0])
+            output[..., 1] = np.where(flesh_r_m > 0, output[..., 1] * (1 - alpha) + 0.0 * alpha, output[..., 1])
+            output[..., 2] = np.where(flesh_r_m > 0, output[..., 2] * (1 - alpha) + 255.0 * alpha, output[..., 2])
+
+            output = np.clip(output, 0, 255).astype(np.uint8)
+
+            if checker_corners is not None:
+                cv2.polylines(output, [np.int32(checker_corners)], True, (0, 165, 255), 4)
+
+            if len(midline) > 1:
+                cv2.polylines(output, [midline.astype(np.int32)], False, (0, 255, 255), 3)
+                pt_top = (int(midline[0][0]), int(midline[0][1]))
+                pt_bot = (int(midline[-1][0]), int(midline[-1][1]))
+                cv2.circle(output, pt_top, 10, (0, 0, 0), 2)
+                cv2.circle(output, pt_top, 8, (255, 255, 255), -1)
+                cv2.circle(output, pt_bot, 10, (0, 0, 0), 2)
+                cv2.circle(output, pt_bot, 8, (255, 255, 255), -1)
+
+            cv2.polylines(output, [fit_pts.astype(np.int32)], True, (0, 255, 0), 3)
+            _, buffer = cv2.imencode(".jpg", output, [cv2.IMWRITE_JPEG_QUALITY, 85])
+            img_base64 = base64.b64encode(buffer).decode("utf-8")
+        mark("render")
 
         return ProcessResult(
             success=True, message="Success", r2_score=float(r2),
             width_val=width_val, height_val=height_val, perimeter_val=perimeter_val,
             delta_e_initial=dE_initial, delta_e_final=dE_final,
-            image_base64=img_base64, filename=source_name
+            image_base64=img_base64, filename=source_name,
+            measurement_unit=measurement_unit, scale_source=scale_source,
+            color_checker_found=checker_corners is not None,
+            rind_source=rind_source, rind_overlap_ratio=rind_overlap_ratio,
+            warnings=warnings or None, timings_ms=timings
         )
 
 
@@ -366,19 +545,44 @@ processor = WatermelonProcessor(MODEL_PATH)
 def read_root(): return {"status": "Watermelon API is awake and running!"}
 
 @app.post("/process_single")
-async def process_single(file: UploadFile = File(...)):
-    contents = await file.read()
-    img = cv2.imdecode(np.frombuffer(contents, np.uint8), cv2.IMREAD_COLOR)
-    
-    scale_ratio = 1.0
-    h, w = img.shape[:2]
-    if max(h, w) > MAX_IMAGE_SIZE:
-        scale_ratio = MAX_IMAGE_SIZE / float(max(h, w))
-        img = cv2.resize(img, (int(w * scale_ratio), int(h * scale_ratio)), interpolation=cv2.INTER_AREA)
-
-    res = processor.process_image(img, file.filename, scale_ratio)
-    
-    del img, contents
-    gc.collect()
-
-    return res.__dict__
+async def process_single(file: UploadFile = File(...), include_image: bool = Query(True)):
+    request_t = time.perf_counter()
+    contents = None
+    img = None
+
+    try:
+        contents = await file.read()
+        if not contents:
+            res = ProcessResult(success=False, message="Empty upload.", filename=file.filename)
+            res.processing_ms = int(round((time.perf_counter() - request_t) * 1000))
+            return res.__dict__
+
+        img = cv2.imdecode(np.frombuffer(contents, np.uint8), cv2.IMREAD_COLOR)
+        if img is None:
+            res = ProcessResult(success=False, message="Could not decode image.", filename=file.filename)
+            res.processing_ms = int(round((time.perf_counter() - request_t) * 1000))
+            return res.__dict__
+
+        scale_ratio = 1.0
+        h, w = img.shape[:2]
+        if max(h, w) > MAX_IMAGE_SIZE:
+            scale_ratio = MAX_IMAGE_SIZE / float(max(h, w))
+            img = cv2.resize(img, (int(w * scale_ratio), int(h * scale_ratio)), interpolation=cv2.INTER_AREA)
+
+        res = processor.process_image(img, file.filename, scale_ratio, include_image=include_image)
+        res.processing_ms = int(round((time.perf_counter() - request_t) * 1000))
+        return res.__dict__
+
+    except Exception as exc:
+        traceback.print_exc()
+        res = ProcessResult(
+            success=False,
+            message=f"Server error: {type(exc).__name__}: {exc}",
+            filename=file.filename,
+            processing_ms=int(round((time.perf_counter() - request_t) * 1000)),
+        )
+        return res.__dict__
+
+    finally:
+        del img, contents
+        gc.collect()