Update main.py

main.py

@@ -113,11 +113,20 @@ class ProcessResult:
     width_val: Optional[float] = None
     height_val: Optional[float] = None
     perimeter_val: 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
+    midline_curvature: Optional[float] = None
     delta_e_initial: Optional[float] = None
     delta_e_final: Optional[float] = None
     image_base64: Optional[str] = None
     filename: Optional[str] = None
     measurement_unit: Optional[str] = None
+    area_unit: Optional[str] = None
     scale_source: Optional[str] = None
     color_checker_found: bool = False
     rind_source: Optional[str] = None
@@ -248,6 +257,52 @@ class WatermelonProcessor:
         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 contour_area_px(points):
+        cnt = points.reshape(-1, 1, 2).astype(np.float32)
+        return float(abs(cv2.contourArea(cnt)))
+
+    @staticmethod
+    def elongation_from_points(points):
+        cnt = points.reshape(-1, 1, 2).astype(np.float32)
+        if len(cnt) >= 5:
+            _, (axis_a, axis_b), _ = cv2.fitEllipse(cnt)
+            minor = max(min(axis_a, axis_b), 1e-6)
+            return float(max(axis_a, axis_b) / minor)
+
+        _, _, bw, bh = cv2.boundingRect(cnt.astype(np.int32))
+        return float(max(bw, bh) / max(min(bw, bh), 1))
+
+    @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
+
+        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
+
+        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
+
+        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
+
+        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
+
+        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)
@@ -466,27 +521,40 @@ class WatermelonProcessor:
         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]))
+        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)
 
         if cm_per_px is not None:
             measurement_unit = "cm"
+            area_unit = "cm2"
             scale_source = "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)
         else:
             measurement_unit = "px"
+            area_unit = "px2"
             scale_source = "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)
+        total_area = float(total_area_px * area_scale)
+        flesh_area = float(flesh_area_px * area_scale)
         mark("fit")
 
         # --- 4. DRAWING ---
         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
@@ -524,9 +592,13 @@ class WatermelonProcessor:
         return ProcessResult(
             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, scale_source=scale_source,
+            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