Update main.py

main.py

@@ -119,6 +119,8 @@ class ProcessResult:
     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
@@ -163,6 +165,44 @@ 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 calculate_axis_metrics(cx, cy, phi, rind_mask, flesh_mask):
+        """Casts rays along the major/minor axes to find height, width, and rind thickness."""
+        h, w = rind_mask.shape
+
+        def ray_cast(theta):
+            max_r = int(np.hypot(h, w))
+            r_steps = np.arange(0, max_r, 0.5)
+            xs = np.clip(np.round(cx + r_steps * np.cos(theta)), 0, w - 1).astype(int)
+            ys = np.clip(np.round(cy - r_steps * np.sin(theta)), 0, h - 1).astype(int)
+            
+            rind_vals = rind_mask[ys, xs]
+            inside_rind = np.where(rind_vals > 0)[0]
+            r_rind = r_steps[inside_rind[-1]] if len(inside_rind) > 0 else 0
+            
+            flesh_vals = flesh_mask[ys, xs]
+            inside_flesh = np.where(flesh_vals > 0)[0]
+            r_flesh = r_steps[inside_flesh[-1]] if len(inside_flesh) > 0 else 0
+                
+            pt_rind = (int(np.round(cx + r_rind * np.cos(theta))), int(np.round(cy - r_rind * np.sin(theta))))
+            return r_rind, r_flesh, pt_rind
+
+        # phi is the rotation of the fruit. Top/Bot are perpendicular to Left/Right
+        r_top, _, pt_top = ray_cast(phi + np.pi/2)
+        r_bot, _, pt_bot = ray_cast(phi - np.pi/2)
+        r_right, f_right, pt_right = ray_cast(phi)
+        r_left, f_left, pt_left = ray_cast(phi + np.pi)
+
+        height_px = float(r_top + r_bot)
+        width_px = float(r_left + r_right)
+        
+        rind_thick_px = None
+        if f_left > 0 and f_right > 0:
+            # Average the rind thickness of the left and right sides
+            rind_thick_px = float((max(0, r_left - f_left) + max(0, r_right - f_right)) / 2.0)
+
+        return height_px, width_px, rind_thick_px, (pt_top, pt_bot), (pt_left, pt_right)
+    
     @staticmethod
     def contour_centroid(contour):
         M = cv2.moments(contour)
@@ -529,9 +569,19 @@ class WatermelonProcessor:
             # 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]))
-        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]))
+
+        # 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)
+
+        height_px, width_px, rind_thick_px, h_line, w_line = self.calculate_axis_metrics(
+            cx, cy, phi, target_rind_mask, flesh_combined
+        )
+
         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
@@ -542,23 +592,29 @@ class WatermelonProcessor:
         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 = "cm"
-            area_unit = "cm2"
-            scale_source = "color_checker"
+            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 = "px"
-            area_unit = "px2"
-            scale_source = "original_pixels"
+            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)
         mark("fit")
@@ -586,6 +642,10 @@ class WatermelonProcessor:
             if checker_corners is not None:
                 cv2.polylines(output, [np.int32(checker_corners)], True, (0, 165, 255), 4)
 
+            # 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]))
@@ -604,6 +664,7 @@ class WatermelonProcessor:
         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,