Update main.py

main.py

@@ -115,23 +115,37 @@ def apply_color_pipeline(target_bgr, ref24, tgt24):
 class ProcessResult:
     success: bool
     message: str
-    r2_score: Optional[float] = None
-    width_val: Optional[float] = None
-    height_val: Optional[float] = None
-    perimeter_val: Optional[float] = None
-    rind_thickness_val: Optional[float] = None
-    rind_thickness_ratio: Optional[float] = None
-    total_area: Optional[float] = None
-    flesh_area: Optional[float] = None
-    flesh_area_ratio: Optional[float] = None
-    elongation_factor: Optional[float] = None
-    circularity: Optional[float] = None
-    asymmetry_score: Optional[float] = None
-    flesh_asymmetry_score: Optional[float] = None
+    r2_rind: Optional[float] = None
+    r2_flesh: Optional[float] = None
+    raw_width: Optional[float] = None
+    sm_width: Optional[float] = None
+    raw_height: Optional[float] = None
+    sm_height: Optional[float] = None
+    raw_perimeter: Optional[float] = None
+    sm_perimeter: Optional[float] = None
+    raw_rind_thick: Optional[float] = None
+    sm_rind_thick: Optional[float] = None
+    raw_rind_ratio: Optional[float] = None
+    sm_rind_ratio: Optional[float] = None
+    raw_total_area: Optional[float] = None
+    sm_total_area: Optional[float] = None
+    raw_flesh_area: Optional[float] = None
+    sm_flesh_area: Optional[float] = None
+    raw_flesh_ratio: Optional[float] = None
+    sm_flesh_ratio: Optional[float] = None
+    raw_elongation: Optional[float] = None
+    sm_elongation: Optional[float] = None
+    raw_asym: Optional[float] = None
+    sm_asym: Optional[float] = None
+    raw_flesh_asym: Optional[float] = None
+    sm_flesh_asym: Optional[float] = None
+    raw_circ: Optional[float] = None
+    sm_circ: Optional[float] = None
     midline_curvature: Optional[float] = None
     delta_e_initial: Optional[float] = None
     delta_e_final: Optional[float] = None
-    image_base64: Optional[str] = None
+    image_raw_base64: Optional[str] = None
+    image_sm_base64: Optional[str] = None
     filename: Optional[str] = None
     measurement_unit: Optional[str] = None
     area_unit: Optional[str] = None
@@ -358,23 +372,16 @@ class WatermelonProcessor:
         return float(max(0.0, (path_len / chord_len) - 1.0))
 
     @staticmethod
-    def get_stable_perimeter_data(rind_mask, flesh_combined):
-        cnts, _ = cv2.findContours(rind_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    def get_polar_data(mask):
+        """Universal polar extractor for either Rind or Flesh masks."""
+        cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
         if not cnts: return None
-        best_cnt, max_overlap = None, -1
-        for cnt in cnts:
-            temp = np.zeros_like(rind_mask)
-            cv2.drawContours(temp, [cnt], -1, 255, -1)
-            overlap = cv2.countNonZero(cv2.bitwise_and(temp, flesh_combined))
-            if overlap > max_overlap:
-                max_overlap, best_cnt = overlap, cnt
-                
-        if best_cnt is None: best_cnt = max(cnts, key=cv2.contourArea)
-        M = cv2.moments(best_cnt)
+        cnt = max(cnts, key=cv2.contourArea)
+        M = cv2.moments(cnt)
         if M["m00"] == 0: return None
 
         cx, cy = M["m10"]/M["m00"], M["m01"]/M["m00"]
-        pts = best_cnt.reshape(-1, 2)
+        pts = cnt.reshape(-1, 2)
         dx, dy = pts[:, 0] - cx, cy - pts[:, 1]
         r_vals, t_vals = np.sqrt(dx**2 + dy**2), np.arctan2(dy, dx)
         
@@ -382,13 +389,46 @@ class WatermelonProcessor:
         bins = np.linspace(-np.pi, np.pi, num_bins + 1)
         raw_r = np.full(num_bins, np.nan)
         for i in range(num_bins):
-            mask = (t_vals >= bins[i]) & (t_vals < bins[i + 1])
-            if np.any(mask): raw_r[i] = np.max(r_vals[mask])
+            b_mask = (t_vals >= bins[i]) & (t_vals < bins[i + 1])
+            if np.any(b_mask): raw_r[i] = np.max(r_vals[b_mask])
 
         valid_idx = np.where(~np.isnan(raw_r))[0]
         if len(valid_idx) == 0: return None
         raw_r[np.isnan(raw_r)] = np.interp(np.where(np.isnan(raw_r))[0], valid_idx, raw_r[valid_idx], period=360)
-        return (bins[:-1] + bins[1:])/2.0, median_filter(raw_r, size=7, mode="wrap"), (cx, cy), best_cnt
+        return (bins[:-1] + bins[1:])/2.0, median_filter(raw_r, size=7, mode="wrap"), (cx, cy), cnt
+
+    @staticmethod
+    def calculate_axis_metrics(cx, cy, phi, rind_mask, flesh_mask):
+        """Instantly finds axes and rind thickness using fast OpenCV bitwise operations."""
+        h, w = rind_mask.shape
+        def get_intersections(theta, mask):
+            temp = np.zeros((h, w), dtype=np.uint8)
+            L = max(h, w)
+            p1 = (int(cx + L * np.cos(theta)), int(cy - L * np.sin(theta)))
+            p2 = (int(cx - L * np.cos(theta)), int(cy + L * np.sin(theta)))
+            cv2.line(temp, p1, p2, 255, 1)
+            
+            overlap = cv2.bitwise_and(mask, temp)
+            y_pts, x_pts = np.where(overlap > 0)
+            if len(x_pts) == 0: return (int(cx), int(cy)), (int(cx), int(cy)), 0.0
+                
+            dx, dy = x_pts - cx, y_pts - cy
+            proj = dx * np.cos(theta) - dy * np.sin(theta)
+            idx_max, idx_min = np.argmax(proj), np.argmin(proj)
+            pt1 = (int(x_pts[idx_max]), int(y_pts[idx_max]))
+            pt2 = (int(x_pts[idx_min]), int(y_pts[idx_min]))
+            dist = float(np.hypot(pt1[0] - pt2[0], pt1[1] - pt2[1]))
+            return pt1, pt2, dist
+
+        pt_top, pt_bot, height_px = get_intersections(phi + np.pi/2, rind_mask)
+        pt_right, pt_left, width_px = get_intersections(phi, rind_mask)
+        _, _, flesh_width_px = get_intersections(phi, flesh_mask)
+        
+        rind_thick_px = None
+        if width_px > 0 and flesh_width_px > 0:
+            rind_thick_px = float(max(0.0, (width_px - flesh_width_px) / 2.0))
+
+        return height_px, width_px, rind_thick_px, (pt_top, pt_bot), (pt_left, pt_right)
 
     @staticmethod
     def get_dual_mask_midline(f_left, f_right, rind_cnt, pred_cnt, cx, cy):
@@ -440,7 +480,7 @@ 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, include_image: bool = True, apply_smoothing: bool = True) -> ProcessResult:
+    def process_image(self, image: np.ndarray, source_name: str, scale_ratio: float, include_image: bool = True) -> ProcessResult:
         timings = {}
         stage_t = time.perf_counter()
 
@@ -451,22 +491,14 @@ class WatermelonProcessor:
             stage_t = now
 
         def fail(message, **extra):
-            return ProcessResult(
-                success=False,
-                message=message,
-                filename=source_name,
-                warnings=warnings or None,
-                timings_ms=timings,
-                **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)
+        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 ---
+        # 1. CALIBRATION & SCALING
         dE_initial, dE_final, cm_per_px, checker_corners = None, None, None, None
         try:
             checker_corners = detect_checker_corners(image)
@@ -478,215 +510,223 @@ 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}")
+            if cm_per_px is None: warnings.append("ColorChecker not found; dimensions in original-image pixels.")
+            else: warnings.append("Color correction skipped after ColorChecker detection.")
         mark("calibration")
 
-        # --- 2. YOLO INFERENCE (STRICTLY PARSING ALL 3 CLASSES) ---
+        # 2. YOLO INFERENCE
         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_r_contours = []
-
+        f_l_cnts, f_r_cnts = [], []
         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)
-
-        # 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 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 was detected; split the two right detections into left/right by x-position.")
+            c = np.array(mask_data, dtype=np.int32)
+            if int(cls) == 0: cv2.drawContours(rind_mask, [c], -1, 255, -1)
+            elif int(cls) == 1: f_l_cnts.append(c)
+            elif int(cls) == 2: f_r_cnts.append(c)
+
+        if len(f_l_cnts) >= 2 and len(f_r_cnts) == 0:
+            f_l_cnts.sort(key=lambda cnt: cv2.moments(cnt)["m10"] / (cv2.moments(cnt)["m00"] + 1e-5))
+            f_r_cnts.append(f_l_cnts.pop())
+            warnings.append("Only flesh_left was detected; split by x-position.")
+        elif len(f_r_cnts) >= 2 and len(f_l_cnts) == 0:
+            f_r_cnts.sort(key=lambda cnt: cv2.moments(cnt)["m10"] / (cv2.moments(cnt)["m00"] + 1e-5))
+            f_l_cnts.append(f_r_cnts.pop(0))
+            warnings.append("Only flesh_right was detected; split 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 c in f_l_cnts: cv2.drawContours(flesh_l_m, [c], -1, 255, -1)
+        for c in f_r_cnts: cv2.drawContours(flesh_r_m, [c], -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)
+
+        target_rind_mask, rind_source, rind_overlap_ratio, r_warn = self.choose_target_rind_mask(rind_mask, flesh_combined)
+        warnings.extend(r_warn)
+        
+        # Bridge the gap for the unified flesh boundary (visuals and smoothed fit)
+        bridge_k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (45, 45))
+        flesh_closed = cv2.morphologyEx(flesh_combined, cv2.MORPH_CLOSE, bridge_k)
         mark("mask_parse")
 
-        # --- 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,
-            )
-
-        t_data, r_raw, (cx, cy), rind_cnt = perimeter_data
-        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:
-            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]),
-                    max_nfev=3000,
-                )
-            except Exception as exc:
-                mark("fit")
-                return fail(f"Fit failed: {exc}", rind_source=rind_source, rind_overlap_ratio=rind_overlap_ratio)
+        # 3. EXTRACTION
+        rind_data = self.get_polar_data(target_rind_mask)
+        flesh_data = self.get_polar_data(flesh_closed)
+        if rind_data is None:
+            return fail("No stable perimeter.", measurement_unit="cm" if cm_per_px else "px", scale_source="color_checker" if cm_per_px else "original_pixels", color_checker_found=checker_corners is not None, 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)])
-        else:
-            r2 = None
-            # If smoothing is off, use the raw OpenCV contour for the perimeter
-            fit_pts = rind_cnt.reshape(-1, 2).astype(np.float32)
-
-        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]))
+        t_r, raw_r_r, (cx, cy), raw_rind_cnt = rind_data
+        pts_r_raw = raw_rind_cnt.reshape(-1, 2).astype(np.float32)
 
-        # Calculate rotation angle for axes
-        if apply_smoothing:
-            phi = popt[7]
-        else:
-            _, _, angle = cv2.fitEllipse(rind_cnt)
-            phi = np.deg2rad(180 - angle) if angle > 90 else np.deg2rad(-angle)
+        # 4. RAW FEATURES
+        _, _, r_angle = cv2.fitEllipse(raw_rind_cnt)
+        raw_phi = np.deg2rad(180 - r_angle) if r_angle > 90 else np.deg2rad(-r_angle)
+        
+        raw_h, raw_w, raw_rt, raw_h_line, raw_w_line = self.calculate_axis_metrics(cx, cy, raw_phi, target_rind_mask, flesh_combined)
+        
+        # Midline is found using flesh_combined (with gap) and clipped to the raw rind contour
+        midline = self.get_ray_scan_midline(flesh_combined, raw_rind_cnt, pts_r_raw, cx, cy)
+        
+        raw_perim = float(cv2.arcLength(raw_rind_cnt, True))
+        raw_tot_a = self.contour_area_px(pts_r_raw)
+        raw_f_a = float(cv2.countNonZero(flesh_combined))
+        raw_f_rat = float(raw_f_a / raw_tot_a) if raw_tot_a > 0 else None
+        raw_elong = self.elongation_from_points(pts_r_raw)
+        raw_circ = float((4.0 * np.pi * raw_tot_a) / (raw_perim ** 2)) if raw_perim > 0 and raw_tot_a > 0 else None
+        raw_asym = self.split_asymmetry(target_rind_mask, midline)
+        raw_f_asym = self.split_asymmetry(flesh_combined, midline, thickness=3)
+        midline_curve = self.midline_curvature_score(midline)
+
+        # 5. SMOOTHED FEATURES
+        sm_w, sm_h, sm_perim, sm_rt, sm_tot_a, sm_f_a, sm_f_rat = None, None, None, None, None, None, None
+        sm_elong, sm_circ, sm_asym, sm_f_asym, r2_rind, r2_flesh = None, None, None, None, None, None, None
+        sm_rind_cnt, sm_flesh_cnt = None, None
+        sm_h_line, sm_w_line = None, None
+        
+        try:
+            # Fit Rind
+            scale_r = np.mean(raw_r_r)
+            popt_r, _ = curve_fit(self.watermelon_model, t_r, raw_r_r/scale_r, 
+                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]), max_nfev=3000)
+            d_r = np.sum((raw_r_r/scale_r - 1)**2)
+            r2_rind = 1 - (np.sum((raw_r_r/scale_r - self.watermelon_model(t_r, *popt_r))**2) / d_r) if d_r != 0 else None
+            
+            t_fit = np.linspace(-np.pi, np.pi, 500)
+            fit_r = self.watermelon_model(t_fit, *popt_r) * scale_r
+            sm_rind_pts = np.array([[r*np.cos(t)+cx, cy-r*np.sin(t)] for t, r in zip(t_fit, fit_r)], dtype=np.float32)
+            sm_rind_cnt = sm_rind_pts.reshape(-1, 1, 2).astype(np.int32)
+            
+            sm_rind_mask = np.zeros_like(target_rind_mask)
+            cv2.fillPoly(sm_rind_mask, [sm_rind_cnt], 255)
+            
+            sm_perim = float(np.sum(np.linalg.norm(np.diff(sm_rind_pts, axis=0), axis=1)) + np.linalg.norm(sm_rind_pts[-1]-sm_rind_pts[0]))
+            sm_tot_a = self.contour_area_px(sm_rind_pts)
+            sm_elong = self.elongation_from_points(sm_rind_pts)
+            sm_circ = float((4.0 * np.pi * sm_tot_a) / (sm_perim ** 2)) if sm_perim > 0 and sm_tot_a > 0 else None
+            sm_asym = self.split_asymmetry(sm_rind_mask, midline)
+            sm_phi = popt_r[7]
+
+            # Fit Flesh
+            if flesh_data:
+                t_f, raw_r_f, (fcx, fcy), _ = flesh_data
+                scale_f = np.mean(raw_r_f)
+                popt_f, _ = curve_fit(self.watermelon_model, t_f, raw_r_f/scale_f, 
+                    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]), max_nfev=3000)
+                d_f = np.sum((raw_r_f/scale_f - 1)**2)
+                r2_flesh = 1 - (np.sum((raw_r_f/scale_f - self.watermelon_model(t_f, *popt_f))**2) / d_f) if d_f != 0 else None
+                
+                fit_f = self.watermelon_model(t_fit, *popt_f) * scale_f
+                sm_flesh_pts = np.array([[r*np.cos(t)+fcx, fcy-r*np.sin(t)] for t, r in zip(t_fit, fit_f)], dtype=np.float32)
+                sm_flesh_cnt = sm_flesh_pts.reshape(-1, 1, 2).astype(np.int32)
+                
+                sm_flesh_mask = np.zeros_like(target_rind_mask)
+                cv2.fillPoly(sm_flesh_mask, [sm_flesh_cnt], 255)
+                
+                sm_f_a = self.contour_area_px(sm_flesh_pts)
+                sm_flesh_asym = self.split_asymmetry(sm_flesh_mask, midline, thickness=3)
+            else:
+                sm_flesh_mask = np.zeros_like(target_rind_mask)
 
-        # Call the new, faster axis calculator
-        height_px, width_px, rind_thick_px, h_line, w_line = self.calculate_axis_metrics(
-            cx, cy, phi, target_rind_mask, flesh_combined
-        )
+            # Smooth axes (using the filled smooth masks)
+            sm_h, sm_w, sm_rt, sm_h_line, sm_w_line = self.calculate_axis_metrics(cx, cy, sm_phi, sm_rind_mask, sm_flesh_mask)
+            if sm_tot_a > 0 and sm_f_a is not None:
+                sm_f_rat = float(sm_f_a / sm_tot_a)
 
-        total_area_px = self.contour_area_px(fit_pts)
-        flesh_area_px = float(cv2.countNonZero(flesh_combined))
-        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_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)
-
-        rind_thickness_val, rind_thickness_ratio = None, None
-
-        if cm_per_px is not None:
-            measurement_unit, area_unit, scale_source = "cm", "cm2", "color_checker"
-            area_scale = cm_per_px ** 2
-            width_val = float(width_px * cm_per_px)
-            height_val = float(height_px * cm_per_px)
-            perimeter_val = float(perimeter_px * cm_per_px)
-            if rind_thick_px is not None:
-                rind_thickness_val = float(rind_thick_px * cm_per_px)
-        else:
-            measurement_unit, area_unit, scale_source = "px", "px2", "original_pixels"
-            orig_scale = 1.0 / scale_ratio
-            area_scale = orig_scale ** 2
-            width_val = float(width_px * orig_scale)
-            height_val = float(height_px * orig_scale)
-            perimeter_val = float(perimeter_px * orig_scale)
-            if rind_thick_px is not None:
-                rind_thickness_val = float(rind_thick_px * orig_scale)
-
-        if rind_thick_px is not None and width_px > 0:
-            rind_thickness_ratio = float((rind_thick_px * 2.0) / width_px)
-
-        total_area = float(total_area_px * area_scale)
-        flesh_area = float(flesh_area_px * area_scale)
+        except Exception as exc:
+            warnings.append(f"Smoothing fit failed: {exc}")
         mark("fit")
 
-        # --- 4. DRAWING ---
-        img_base64 = None
-        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)
+        # 6. APPLY SCALES
+        sc_src = "color_checker" if cm_per_px else "original_pixels"
+        m_unit = "cm" if cm_per_px else "px"
+        a_unit = "cm2" if cm_per_px else "px2"
+        scaler = cm_per_px if cm_per_px else (1.0 / scale_ratio)
+        a_scaler = scaler ** 2
 
-            if checker_corners is not None:
-                cv2.polylines(output, [np.int32(checker_corners)], True, (0, 165, 255), 4)
+        def s(v): return float(v * scaler) if v is not None else None
+        def a(v): return float(v * a_scaler) if v is not None else None
+        def rt_rat(thick, w): return float((thick * 2.0) / w) if thick is not None and w and w > 0 else None
 
-            # Draw axis lines underneath the other features
-            cv2.line(output, h_line[0], h_line[1], (255, 100, 255), 2) # Height (Purple)
-            cv2.line(output, w_line[0], w_line[1], (255, 255, 100), 2) # Width (Cyan)
-            
-            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)
+        res = ProcessResult(
+            success=True, message="Success", filename=source_name, measurement_unit=m_unit, area_unit=a_unit,
+            scale_source=sc_src, color_checker_found=bool(cm_per_px),
+            rind_source=rind_source, rind_overlap_ratio=rind_overlap_ratio, warnings=warnings or None,
+            r2_rind=r2_rind, r2_flesh=r2_flesh, midline_curvature=midline_curve,
+            delta_e_initial=dE_initial, delta_e_final=dE_final, timings_ms=timings,
             
-            _, buffer = cv2.imencode(".jpg", output, [cv2.IMWRITE_JPEG_QUALITY, 80])
-            img_base64 = base64.b64encode(buffer).decode("utf-8")
-        mark("render")
-
-        return ProcessResult(
-            success=True, message="Success", r2_score=float(r2) if r2 is not None else None,
-            width_val=width_val, height_val=height_val, perimeter_val=perimeter_val,
-            rind_thickness_val=rind_thickness_val, rind_thickness_ratio=rind_thickness_ratio,
-            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,
-            rind_source=rind_source, rind_overlap_ratio=rind_overlap_ratio,
-            warnings=warnings or None, timings_ms=timings
+            raw_width=s(raw_w), sm_width=s(sm_w), raw_height=s(raw_h), sm_height=s(sm_h),
+            raw_perimeter=s(raw_perim), sm_perimeter=s(sm_perim),
+            raw_rind_thick=s(raw_rt), sm_rind_thick=s(sm_rt),
+            raw_rind_ratio=rt_rat(raw_rt, raw_w), sm_rind_ratio=rt_rat(sm_rt, sm_w),
+            raw_total_area=a(raw_tot_a), sm_total_area=a(sm_tot_a),
+            raw_flesh_area=a(raw_f_a), sm_flesh_area=a(sm_f_a),
+            raw_flesh_ratio=raw_f_rat, sm_flesh_ratio=sm_f_rat,
+            raw_elongation=raw_elong, sm_elongation=sm_elong,
+            raw_asym=raw_asym, sm_asym=sm_asym, raw_flesh_asym=raw_f_asym, sm_flesh_asym=sm_flesh_asym,
+            raw_circ=raw_circ, sm_circ=sm_circ
         )
 
-
+        # 7. DRAW PREVIEWS
+        if include_image:
+            def encode_img(canvas):
+                _, b = cv2.imencode(".jpg", canvas, [cv2.IMWRITE_JPEG_QUALITY, 85])
+                return base64.b64encode(b).decode("utf-8")
+                
+            def draw_base(r_m, f_m):
+                out = image.copy().astype(np.float32)
+                alpha = 0.42
+                # Green tint for rind
+                out[..., 0] = np.where(r_m > 0, out[..., 0]*(1-alpha) + 0, out[..., 0])
+                out[..., 1] = np.where(r_m > 0, out[..., 1]*(1-alpha) + 170, out[..., 1])
+                out[..., 2] = np.where(r_m > 0, out[..., 2]*(1-alpha) + 0, out[..., 2])
+                
+                # Orange/Flesh tint for the flesh
+                out[..., 0] = np.where(f_m > 0, out[..., 0]*(1-alpha) + 60, out[..., 0])
+                out[..., 1] = np.where(f_m > 0, out[..., 1]*(1-alpha) + 120, out[..., 1])
+                out[..., 2] = np.where(f_m > 0, out[..., 2]*(1-alpha) + 255, out[..., 2])
+                
+                out = np.clip(out, 0, 255).astype(np.uint8)
+                if checker_corners is not None: cv2.polylines(out, [np.int32(checker_corners)], True, (0, 165, 255), 4)
+                if len(midline) > 1: 
+                    cv2.polylines(out, [midline.astype(np.int32)], False, (0, 255, 255), 3)
+                    pt1, pt2 = tuple(midline[0].astype(int)), tuple(midline[-1].astype(int))
+                    for pt in (pt1, pt2):
+                        cv2.circle(out, pt, 8, (0,0,0), 2); cv2.circle(out, pt, 6, (255,255,255), -1)
+                return out
+
+            # RAW
+            out_raw = draw_base(target_rind_mask, flesh_closed) 
+            cv2.line(out_raw, raw_h_line[0], raw_h_line[1], (255, 100, 255), 2)
+            cv2.line(out_raw, raw_w_line[0], raw_w_line[1], (255, 255, 100), 2)
+            # Flesh border first
+            f_cnts_raw, _ = cv2.findContours(flesh_closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            if f_cnts_raw: cv2.polylines(out_raw, [max(f_cnts_raw, key=cv2.contourArea)], True, (255, 50, 50), 3)
+            # Rind border
+            cv2.polylines(out_raw, [raw_rind_cnt], True, (0, 200, 0), 3)
+            res.image_raw_base64 = encode_img(out_raw)
+
+            # SMOOTH
+            if sm_rind_cnt is not None:
+                out_sm = draw_base(sm_rind_mask, sm_flesh_mask)
+                cv2.line(out_sm, sm_h_line[0], sm_h_line[1], (255, 100, 255), 2)
+                cv2.line(out_sm, sm_w_line[0], sm_w_line[1], (255, 255, 100), 2)
+                
+                # Thinner lines, distinct bright colors
+                if sm_flesh_cnt is not None: cv2.polylines(out_sm, [sm_flesh_cnt], True, (255, 150, 50), 2)
+                cv2.polylines(out_sm, [sm_rind_cnt], True, (0, 255, 127), 2)
+                res.image_sm_base64 = encode_img(out_sm)
+            
+        mark("render")
+        return res
 app = FastAPI()
 
 app.add_middleware(
@@ -702,7 +742,6 @@ def read_root(): return {"status": "Phenotyping API is awake and running!"}
 async def process_single(
     file: UploadFile = File(...), 
     include_image: bool = Query(True), 
-    apply_smoothing: bool = Query(True),
     password: str = Form("")
 ):
     request_t = time.perf_counter()
@@ -733,7 +772,7 @@ async def process_single(
             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, apply_smoothing=apply_smoothing)
+        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__