Update main.py

main.py

@@ -167,39 +167,47 @@ class WatermelonProcessor:
 
     @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."""
+        """Instantly finds axes and rind thickness using fast OpenCV bitwise operations."""
         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)
+        def get_intersections(theta, mask):
+            temp = np.zeros((h, w), dtype=np.uint8)
+            L = max(h, w)
+            # Draw a line spanning across the entire image
+            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)
             
-            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
+            # Find where the line overlaps the mask
+            overlap = cv2.bitwise_and(mask, temp)
+            y_pts, x_pts = np.where(overlap > 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
+            if len(x_pts) == 0:
+                return (int(cx), int(cy)), (int(cx), int(cy)), 0.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)
+            # Project points to find the two extreme ends of the line segment
+            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
 
-        height_px = float(r_top + r_bot)
-        width_px = float(r_left + r_right)
+        # Height line (perpendicular to phi)
+        pt_top, pt_bot, height_px = get_intersections(phi + np.pi/2, rind_mask)
+        
+        # Width line (parallel to phi)
+        pt_right, pt_left, width_px = get_intersections(phi, rind_mask)
+        
+        # Flesh width along the exact same width line
+        _, _, flesh_width_px = get_intersections(phi, flesh_mask)
         
         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)
+        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)
     
@@ -578,6 +586,7 @@ class WatermelonProcessor:
             _, _, angle = cv2.fitEllipse(rind_cnt)
             phi = np.deg2rad(180 - angle) if angle > 90 else np.deg2rad(-angle)
 
+        # 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
         )