Update main.py

main.py

@@ -123,6 +123,12 @@ class ProcessResult:
     sm_height: Optional[float] = None
     raw_perimeter: Optional[float] = None
     sm_perimeter: Optional[float] = None
+    raw_flesh_width: Optional[float] = None 
+    sm_flesh_width: Optional[float] = None   
+    raw_flesh_height: Optional[float] = None 
+    sm_flesh_height: Optional[float] = None  
+    raw_flesh_perimeter: Optional[float] = None 
+    sm_flesh_perimeter: Optional[float] = None  
     raw_rind_thick: Optional[float] = None
     sm_rind_thick: Optional[float] = None
     raw_rind_ratio: Optional[float] = None
@@ -343,19 +349,23 @@ 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)
+        
+        # FIX: Extrapolate the line 100 pixels in both directions to guarantee it completely bisects smoothed/expanded masks
+        m = midline.astype(np.float32)
+        p0, p1, pn, pn_1 = m[0], m[1], m[-1], m[-2]
+        n0, n1 = np.linalg.norm(p0 - p1), np.linalg.norm(pn - pn_1)
+        ext_start = p0 + (p0 - p1) / n0 * 100 if n0 > 1e-5 else p0
+        ext_end = pn + (pn - pn_1) / n1 * 100 if n1 > 1e-5 else pn
+        ext_midline = np.vstack([ext_start, m, ext_end]).astype(np.int32)
+        
+        cv2.polylines(split_mask, [ext_midline], 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
@@ -422,13 +432,14 @@ class WatermelonProcessor:
 
         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)
+        _, _, f_height_px = get_intersections(phi + np.pi/2, flesh_mask) # NEW
+        _, _, f_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)
+        return height_px, width_px, rind_thick_px, (pt_top, pt_bot), (pt_left, pt_right), f_height_px, f_width_px
 
     @staticmethod
     def get_dual_mask_midline(f_left, f_right, rind_cnt, pred_cnt, cx, cy):
@@ -561,7 +572,13 @@ class WatermelonProcessor:
         t_r, raw_r_r, (cx, cy), raw_rind_cnt = rind_data
         pts_r_raw = raw_rind_cnt.reshape(-1, 2).astype(np.float32)
 
-        # --- NEW SCAN-LINE FLESH GAP FILLING (Preserves V-shape) ---
+        # Raw Flesh perimeter length
+        raw_flesh_perim = None
+        if flesh_data:
+            _, _, _, raw_flesh_cnt = flesh_data
+            raw_flesh_perim = float(cv2.arcLength(raw_flesh_cnt, True))
+
+        # --- SCAN-LINE FLESH GAP FILLING (Preserves V-shape) ---
         _, (ma, Ma), angle = cv2.fitEllipse(raw_rind_cnt) if len(raw_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)
@@ -603,7 +620,8 @@ class WatermelonProcessor:
         _, _, 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)
+        # Capture raw_f_h and raw_f_w
+        raw_h, raw_w, raw_rt, raw_h_line, raw_w_line, raw_f_h, raw_f_w = self.calculate_axis_metrics(cx, cy, raw_phi, target_rind_mask, flesh_closed)
         
         # Midline is found using flesh_combined (with gap) and clipped to the raw rind contour
         midline = self.get_dual_mask_midline(flesh_l_m, flesh_r_m, raw_rind_cnt, pts_r_raw, cx, cy)
@@ -632,7 +650,11 @@ class WatermelonProcessor:
                 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
-            
+
+            # R² Warning Flag
+            if r2_rind is not None and r2_rind < 0.85:
+                warnings.append(f"R² below 0.85 ({r2_rind:.2f}). Fruit may be damaged or irregular.")
+                
             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)
@@ -667,11 +689,13 @@ class WatermelonProcessor:
                 
                 sm_f_a = self.contour_area_px(sm_flesh_pts)
                 sm_flesh_asym = self.split_asymmetry(sm_flesh_mask, midline, thickness=3)
+                sm_flesh_perim = float(np.sum(np.linalg.norm(np.diff(sm_flesh_pts, axis=0), axis=1)) + np.linalg.norm(sm_flesh_pts[-1]-sm_flesh_pts[0]))
             else:
                 sm_flesh_mask = np.zeros_like(target_rind_mask)
+                sm_flesh_perim = None
 
             # 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)
+            sm_h, sm_w, sm_rt, sm_h_line, sm_w_line, sm_f_h, sm_f_w = 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)
 
@@ -699,6 +723,9 @@ class WatermelonProcessor:
             
             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_flesh_width=s(raw_f_w), sm_flesh_width=s(sm_f_w),
+            raw_flesh_height=s(raw_f_h), sm_flesh_height=s(sm_f_h),
+            raw_flesh_perimeter=s(raw_flesh_perim), sm_flesh_perimeter=s(sm_flesh_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),
@@ -717,7 +744,7 @@ class WatermelonProcessor:
                 
             def draw_base(r_m, f_m):
                 out = image.copy().astype(np.float32)
-                alpha = 0.15 # Transparency
+                alpha = 0.10 # Transparency
                 
                 # --- THE FIX: Only paint the rind where there is NO flesh ---
                 rind_only = (r_m > 0) & (f_m == 0)