Update main.py

main.py

@@ -160,13 +160,15 @@ class WatermelonProcessor:
     @staticmethod
     def contour_centroid(contour):
         M = cv2.moments(contour)
-        if M["m00"] == 0: return None
+        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
+        if M["m00"] == 0:
+            return None
         return np.array([M["m10"] / M["m00"], M["m01"] / M["m00"]], dtype=np.float32)
 
     @staticmethod
@@ -178,7 +180,8 @@ class WatermelonProcessor:
     @staticmethod
     def flesh_envelope_mask(flesh_combined):
         ys, xs = np.where(flesh_combined > 0)
-        if len(xs) < MIN_FLESH_PIXELS_FOR_FALLBACK: return None
+        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))
@@ -196,7 +199,7 @@ class WatermelonProcessor:
 
     @staticmethod
     def choose_target_rind_mask(rind_mask, flesh_combined):
-        warnings =[]
+        warnings = []
         flesh_area = cv2.countNonZero(flesh_combined)
         cnts, _ = cv2.findContours(rind_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
 
@@ -206,7 +209,7 @@ class WatermelonProcessor:
                 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 =[]
+        scored = []
         for cnt in cnts:
             temp = WatermelonProcessor.draw_single_contour(rind_mask.shape, cnt)
             overlap = cv2.countNonZero(cv2.bitwise_and(temp, flesh_combined))
@@ -272,23 +275,32 @@ class WatermelonProcessor:
 
     @staticmethod
     def split_asymmetry(region_mask, midline, thickness=5):
-        if midline is None or len(midline) < 2 or cv2.countNonZero(region_mask) == 0: return None
+        if midline is None or len(midline) < 2 or cv2.countNonZero(region_mask) == 0:
+            return None
+
         split_mask = region_mask.copy()
         cv2.polylines(split_mask, [midline.astype(np.int32)], False, 0, thickness)
         n_labels, _, stats, _ = cv2.connectedComponentsWithStats((split_mask > 0).astype(np.uint8), connectivity=8)
-        if n_labels <= 2: return None
+        if n_labels <= 2:
+            return None
 
         areas = sorted([int(stats[i, cv2.CC_STAT_AREA]) for i in range(1, n_labels)], reverse=True)
-        if len(areas) < 2 or areas[0] + areas[1] == 0: return None
+        if len(areas) < 2 or areas[0] + areas[1] == 0:
+            return None
+
         return float(abs(areas[0] - areas[1]) / (areas[0] + areas[1]))
 
     @staticmethod
     def midline_curvature_score(midline):
-        if midline is None or len(midline) < 3: return None
+        if midline is None or len(midline) < 3:
+            return None
+
         diffs = np.diff(midline.astype(np.float32), axis=0)
         path_len = float(np.sum(np.linalg.norm(diffs, axis=1)))
         chord_len = float(np.linalg.norm(midline[-1] - midline[0]))
-        if chord_len <= 1e-6: return None
+        if chord_len <= 1e-6:
+            return None
+
         return float(max(0.0, (path_len / chord_len) - 1.0))
 
     @staticmethod
@@ -325,61 +337,56 @@ class WatermelonProcessor:
         return (bins[:-1] + bins[1:])/2.0, median_filter(raw_r, size=7, mode="wrap"), (cx, cy), best_cnt
 
     @staticmethod
-    def get_ray_scan_midline(flesh_mask, rind_cnt, predicted_cnt, cx, cy):
-        h, w = flesh_mask.shape
-        if len(rind_cnt) > 5:
-            _, (ma, Ma), angle = cv2.fitEllipse(rind_cnt)
-            rot_angle = angle if ma < Ma else angle + 90
-        else: rot_angle = 0
+    def get_dual_mask_midline(f_left, f_right, rind_cnt, pred_cnt, cx, cy):
+        h, w = f_left.shape
+        _, (ma, Ma), angle = cv2.fitEllipse(rind_cnt) if len(rind_cnt) > 5 else (None, (0,0), 0)
+        rot_angle = angle if ma < Ma else angle + 90
 
         m_rot = cv2.getRotationMatrix2D((cx, cy), rot_angle, 1.0)
         m_inv = cv2.getRotationMatrix2D((cx, cy), -rot_angle, 1.0)
-        f_rot = cv2.warpAffine(flesh_mask, m_rot, (w, h))
+        l_rot, r_rot = cv2.warpAffine(f_left, m_rot, (w, h)), cv2.warpAffine(f_right, m_rot, (w, h))
+
+        l_idx, r_idx = np.where(l_rot > 0)[1], np.where(r_rot > 0)[1]
+        if len(l_idx) > 0 and len(r_idx) > 0:
+            if np.mean(l_idx) > np.mean(r_idx):
+                l_rot, r_rot = r_rot, l_rot 
 
         gap_points =[]
-        y_indices, _ = np.where(f_rot > 0)
-        if len(y_indices) > 0:
-            y_min, y_max = np.min(y_indices), np.max(y_indices)
-            for y in range(y_min, y_max):
-                row = f_rot[y, :]
-                white_px = np.where(row > 0)[0]
-                if len(white_px) >= 2:
-                    first, last = white_px[0], white_px[-1]
-                    blanks_in_between = np.where(row[first:last] == 0)[0] + first
-                    if len(blanks_in_between) > 0:
-                        gap_points.append([y, np.median(blanks_in_between)])
+        y_l, y_r = np.where(l_rot > 0)[0], np.where(r_rot > 0)[0]
+        if len(y_l) > 0 and len(y_r) > 0:
+            for y in range(max(np.min(y_l), np.min(y_r)), min(np.max(y_l), np.max(y_r))):
+                row_l, row_r = np.where(l_rot[y, :] > 0)[0], np.where(r_rot[y, :] > 0)[0]
+                if len(row_l) > 0 and len(row_r) > 0:
+                    gap_points.append([y, (row_l[-1] + row_r[0]) / 2.0])
 
         gap_points = np.array(gap_points)
         if len(gap_points) > 10:
-            y_min, y_max = np.min(gap_points[:, 0]), np.max(gap_points[:, 0])
-            y_span, y_mean = max(y_max - y_min, 1), (y_max + y_min) / 2.0
-            y_norm, x_data = (gap_points[:, 0] - y_mean) / y_span, gap_points[:, 1]
-
-            def parabola(y_n, a, b, c): return a * (y_n**2) + b * y_n + c
-
+            y_min_g, y_max_g = np.min(gap_points[:, 0]), np.max(gap_points[:, 0])
+            y_span, y_mean = max(y_max_g - y_min_g, 1), (y_max_g + y_min_g) / 2.0
+            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, y_norm, x_data, bounds=([-max_bend, -np.inf, -np.inf], [max_bend, np.inf, np.inf]))
-            except Exception:
-                popt_mid = [0.0, 0.0, cx]
-
+                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)
-            xs_extrap = parabola((ys_extrap - y_mean) / y_span, *popt_mid)
-            pts_rot = np.vstack([xs_extrap, ys_extrap, np.ones_like(xs_extrap)])
+            xs_extrap = parabola((ys_extrap - y_mean)/y_span, *popt_mid)
+            pts_rot = np.vstack([xs_extrap, ys_extrap, np.ones_like(ys_extrap)])
         else:
             ys_extrap = np.linspace(0, h, 500)
-            xs_extrap = np.full_like(ys_extrap, cx)
-            pts_rot = np.vstack([xs_extrap, ys_extrap, np.ones_like(xs_extrap)])
+            pts_rot = np.vstack([np.full_like(ys_extrap, cx), ys_extrap, np.ones_like(ys_extrap)])
 
         pts_orig = (m_inv @ pts_rot).T
-        pred_cnt_cv = predicted_cnt.reshape(-1, 1, 2).astype(np.int32)
-        final_line =[]
-        for pt in pts_orig:
-            if cv2.pointPolygonTest(pred_cnt_cv, (float(pt[0]), float(pt[1])), False) >= 0:
-                final_line.append(pt)
-        return np.array(final_line)
-
-    def process_image(self, image: np.ndarray, source_name: str, scale_ratio: float, apply_smoothing: bool = True) -> ProcessResult:
+        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, include_image: bool = True, apply_smoothing: bool = True) -> ProcessResult:
         timings = {}
         stage_t = time.perf_counter()
 
@@ -399,8 +406,10 @@ class WatermelonProcessor:
                 **extra,
             )
 
-        warnings =[]
-        if image is None: return ProcessResult(success=False, message="Could not decode image.", filename=source_name)
+        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 ---
@@ -422,12 +431,14 @@ class WatermelonProcessor:
                 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.")
+            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 ---
+        # --- 2. YOLO INFERENCE (STRICTLY PARSING ALL 3 CLASSES) ---
         results = self.model(image, conf=0.25, retina_masks=True, verbose=False)
         mark("yolo_inference")
 
@@ -436,29 +447,38 @@ class WatermelonProcessor:
         flesh_r_contours = []
 
         if results[0].masks is None:
-            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)
+            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: cv2.drawContours(rind_mask, [contour], -1, 255, -1)
-            elif c_id == 1: flesh_l_contours.append(contour)
-            elif c_id == 2: flesh_r_contours.append(contour)
-
+            if c_id == 0:
+                cv2.drawContours(rind_mask, [contour], -1, 255, -1)
+            elif c_id == 1:
+                flesh_l_contours.append(contour)
+            elif c_id == 2:
+                flesh_r_contours.append(contour)
+
+        # 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_r_contours.append(flesh_l_contours.pop())
-            warnings.append("Only flesh_left detected; split by x-position.")
+            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_l_contours.append(flesh_r_contours.pop(0))
-            warnings.append("Only flesh_right detected; split by x-position.")
+            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)
@@ -468,16 +488,21 @@ class WatermelonProcessor:
         # --- 3. FIT & EXTRACTION ---
         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)
+            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
-        
-        # SMOOTHING TOGGLE LOGIC
+        scale = np.mean(r_raw)
+        if scale <= 0:
+            return fail("Invalid perimeter scale.", rind_source=rind_source, rind_overlap_ratio=rind_overlap_ratio)
+
         if apply_smoothing:
-            scale = np.mean(r_raw)
-            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,
@@ -489,15 +514,13 @@ class WatermelonProcessor:
                 mark("fit")
                 return fail(f"Fit failed: {exc}", rind_source=rind_source, rind_overlap_ratio=rind_overlap_ratio)
 
-            denom = np.sum((r_raw / scale - 1) ** 2)
-            r2 = 1 - (np.sum((r_raw / scale - self.watermelon_model(t_data, *popt)) ** 2) / denom) if denom != 0 else None
-            
+            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)], dtype=np.float32)
+            fit_pts = np.array([[r * np.cos(t) + cx, cy - r * np.sin(t)] for t, r in zip(t_fit, r_fit)])
         else:
-            # If Smoothing is OFF, bypass math and use the raw OpenCV contour
             r2 = None
+            # If smoothing is off, use the raw OpenCV contour for the perimeter
             fit_pts = rind_cnt.reshape(-1, 2).astype(np.float32)
 
         width_px = float(np.max(fit_pts[:, 0]) - np.min(fit_pts[:, 0]))
@@ -508,79 +531,85 @@ class WatermelonProcessor:
         flesh_area_ratio = float(flesh_area_px / total_area_px) if total_area_px > 0 else None
         elongation_factor = self.elongation_from_points(fit_pts)
         circularity = float((4.0 * np.pi * total_area_px) / (perimeter_px ** 2)) if perimeter_px > 0 and total_area_px > 0 else None
-        
-        midline = self.get_ray_scan_midline(flesh_combined, rind_cnt, fit_pts, cx, cy)
-        
+        midline = self.get_dual_mask_midline(flesh_l_m, flesh_r_m, rind_cnt, fit_pts, cx, cy)
         asymmetry_score = self.split_asymmetry(target_rind_mask, midline)
         flesh_asymmetry_score = self.split_asymmetry(flesh_combined, midline, thickness=3)
         midline_curvature = self.midline_curvature_score(midline)
 
         if cm_per_px is not None:
-            measurement_unit, area_unit, scale_source = "cm", "cm2", "color_checker"
+            measurement_unit = "cm"
+            area_unit = "cm2"
+            scale_source = "color_checker"
             area_scale = cm_per_px ** 2
-            width_val, height_val, perimeter_val = float(width_px * cm_per_px), float(height_px * cm_per_px), float(perimeter_px * cm_per_px)
+            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:
-            measurement_unit, area_unit, scale_source = "px", "px2", "original_pixels"
+            measurement_unit = "px"
+            area_unit = "px2"
+            scale_source = "original_pixels"
             orig_scale = 1.0 / scale_ratio
             area_scale = orig_scale ** 2
-            width_val, height_val, perimeter_val = float(width_px * orig_scale), float(height_px * orig_scale), float(perimeter_px * orig_scale)
-            
-        total_area, flesh_area = float(total_area_px * area_scale), float(flesh_area_px * area_scale)
+            width_val = float(width_px * orig_scale)
+            height_val = float(height_px * orig_scale)
+            perimeter_val = float(perimeter_px * orig_scale)
+        total_area = float(total_area_px * area_scale)
+        flesh_area = float(flesh_area_px * area_scale)
         mark("fit")
 
         # --- 4. DRAWING ---
         img_base64 = None
-        
-        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)
-
-        cv2.polylines(output, [fit_pts.astype(np.int32)], True, (0, 255, 0), 3)
-
-        stem = stem_tip_tangent_deg(rind_cnt, (cx, cy))
-        if stem is not None:
-            tx, ty, tdeg = stem
-            L = min(w, h) * 0.08
-            p1 = (int(round(tx)), int(round(ty)))
-            p2 = (int(round(tx + L * np.cos(np.deg2rad(tdeg)))), int(round(ty + L * np.sin(np.deg2rad(tdeg)))))
-            cv2.circle(output, p1, 6, (255, 0, 255), -1)
-            cv2.line(output, p1, p2, (255, 0, 255), 2)
-
-        _, buffer = cv2.imencode(".jpg", output, [cv2.IMWRITE_JPEG_QUALITY, 85])
-        img_base64 = base64.b64encode(buffer).decode("utf-8")
+        if include_image:
+            # 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=r2,
+            success=True, message="Success", r2_score=float(r2),
             width_val=width_val, height_val=height_val, perimeter_val=perimeter_val,
             total_area=total_area, flesh_area=flesh_area, flesh_area_ratio=flesh_area_ratio,
             elongation_factor=elongation_factor, circularity=circularity,
             asymmetry_score=asymmetry_score, flesh_asymmetry_score=flesh_asymmetry_score,
-            midline_curvature=midline_curvature, delta_e_initial=dE_initial, delta_e_final=dE_final,
-            image_base64=img_base64, filename=source_name, measurement_unit=measurement_unit, area_unit=area_unit, 
-            scale_source=scale_source, color_checker_found=checker_corners is not None,
+            midline_curvature=midline_curvature,
+            delta_e_initial=dE_initial, delta_e_final=dE_final,
+            image_base64=img_base64, filename=source_name,
+            measurement_unit=measurement_unit, area_unit=area_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
         )
 
+
 app = FastAPI()
 
 app.add_middleware(
@@ -595,16 +624,21 @@ def read_root(): return {"status": "Watermelon API is awake and running!"}
 @app.post("/process_single")
 async def process_single(file: UploadFile = File(...), include_image: bool = Query(True), apply_smoothing: bool = Query(True)):
     request_t = time.perf_counter()
-    contents, img = None, None
+    contents = None
+    img = None
 
     try:
         contents = await file.read()
         if not contents:
-            return ProcessResult(success=False, message="Empty upload.", filename=file.filename, processing_ms=int(round((time.perf_counter() - request_t) * 1000))).__dict__
+            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:
-            return ProcessResult(success=False, message="Could not decode image.", filename=file.filename, processing_ms=int(round((time.perf_counter() - request_t) * 1000))).__dict__
+            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]
@@ -612,14 +646,19 @@ async def process_single(file: UploadFile = File(...), include_image: bool = Que
             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)
 
-        # PASS THE TOGGLE INTO THE PROCESSOR
-        res = processor.process_image(img, file.filename, scale_ratio, apply_smoothing=apply_smoothing)
+        res = processor.process_image(img, file.filename, scale_ratio, include_image=include_image, apply_smoothing=apply_smoothing)
         res.processing_ms = int(round((time.perf_counter() - request_t) * 1000))
         return res.__dict__
 
     except Exception as exc:
         traceback.print_exc()
-        return ProcessResult(success=False, message=f"Server error: {type(exc).__name__}: {exc}", filename=file.filename, processing_ms=int(round((time.perf_counter() - request_t) * 1000))).__dict__
+        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