Update app.py

app.py

@@ -75,7 +75,7 @@ def custom_nms(preds, iou_threshold=0.3):
     return filtered_preds
 
 #########################################
-# 3. Processing Function with Homography Measurement
+# 3. Processing Function with Pose-based Measurement
 #########################################
 
 def process_image(job_id, image_path, object_type):
@@ -109,12 +109,12 @@ def process_image(job_id, image_path, object_type):
             for prediction in predictions:
                 try:
                     x, y, width, height = prediction["x"], prediction["y"], prediction["width"], prediction["height"]
-                    # Convert center x,y and width, height to top-left and bottom-right coordinates
+                    # Convert from center (x, y) and width, height to top-left & bottom-right
                     x1 = int(round(x - width / 2))
                     y1 = int(round(y - height / 2))
                     x2 = int(round(x + width / 2))
                     y2 = int(round(y + height / 2))
-                    # Clamp coordinates to the image dimensions
+                    # Clamp coordinates to image boundaries
                     x1 = max(0, min(x1, img_width - 1))
                     y1 = max(0, min(y1, img_height - 1))
                     x2 = max(0, min(x2, img_width - 1))
@@ -128,74 +128,74 @@ def process_image(job_id, image_path, object_type):
                     continue
 
             box_detections = custom_nms(processed_preds, iou_threshold=0.3)
-            jobs[job_id]['progress'] = 60
+            jobs[job_id]['progress'] = 40
 
             # -------------------------------
-            # Improved ArUco marker detection and homography computation
+            # Use ArUco pose estimation to compute a conversion factor.
+            # IMPORTANT: For accurate measurement you need proper camera calibration.
+            # Replace the cameraMatrix and distCoeffs below with your calibrated parameters.
+            # Here we use an approximate calibration.
             # -------------------------------
-            # Since your marker is 10 cm, we set:
-            marker_real_width_cm = 10.0  
-            homography = None
-            conversion_factor = None
+            marker_conversion_factor = None
             try:
                 gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
                 aruco_dict = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_6X6_250)
-                # Use DetectorParameters_create if available (for newer OpenCV versions)
                 if hasattr(cv2.aruco, 'DetectorParameters_create'):
                     aruco_params = cv2.aruco.DetectorParameters_create()
                 else:
                     aruco_params = cv2.aruco.DetectorParameters()
                 corners, ids, _ = cv2.aruco.detectMarkers(gray, aruco_dict, parameters=aruco_params)
                 if ids is not None and len(corners) > 0:
-                    # Use the first detected marker as reference
-                    marker_corners = corners[0].reshape((4, 2))
-                    cv2.aruco.drawDetectedMarkers(image, corners, ids)
-                    # Define destination points for a perfect square (e.g., 1000 x 1000 pixels)
-                    dest_size = 1000.0
-                    dst_pts = np.array([[0, 0],
-                                        [dest_size, 0],
-                                        [dest_size, dest_size],
-                                        [0, dest_size]], dtype=np.float32)
-                    src_pts = marker_corners.astype(np.float32)
-                    homography = cv2.getPerspectiveTransform(src_pts, dst_pts)
-                    # In the warped image, the marker side is dest_size pixels,
-                    # which corresponds to 10 cm in real life.
-                    conversion_factor = marker_real_width_cm / dest_size  # 10 cm / 1000 pixels = 0.01 cm per pixel
+                    # Use the first detected marker
+                    # --- IMPORTANT ---
+                    # Define your camera calibration parameters below. These are only approximate.
+                    fx = 1.2 * img_width
+                    fy = 1.2 * img_height
+                    cx = img_width / 2
+                    cy = img_height / 2
+                    cameraMatrix = np.array([[fx, 0, cx],
+                                             [0, fy, cy],
+                                             [0,  0,  1]], dtype=np.float32)
+                    distCoeffs = np.zeros((5, 1), dtype=np.float32)
+                    # Marker length in meters (10 cm = 0.10 m)
+                    marker_length = 0.10  
+                    rvecs, tvecs, _ = cv2.aruco.estimatePoseSingleMarkers(corners, marker_length, cameraMatrix, distCoeffs)
+                    # For the first marker:
+                    rvec = rvecs[0]
+                    tvec = tvecs[0]
+                    # Define 3D coordinates for the marker's corners (in marker coordinate system)
+                    obj_points = np.array([
+                        [-marker_length/2,  marker_length/2, 0],
+                        [ marker_length/2,  marker_length/2, 0],
+                        [ marker_length/2, -marker_length/2, 0],
+                        [-marker_length/2, -marker_length/2, 0]
+                    ], dtype=np.float32)
+                    projected_points, _ = cv2.projectPoints(obj_points, rvec, tvec, cameraMatrix, distCoeffs)
+                    projected_points = projected_points.reshape((4,2))
+                    # Compute the pixel distance between two adjacent projected corners (e.g. top edge)
+                    pixel_distance = np.linalg.norm(projected_points[0] - projected_points[1])
+                    # Since the marker is 10 cm wide, the conversion factor is:
+                    marker_conversion_factor = 10.0 / pixel_distance  # cm per pixel
+                    # Optionally, draw the marker pose for visualization:
+                    cv2.aruco.drawAxis(image, cameraMatrix, distCoeffs, rvec, tvec, 0.05)
                 else:
-                    homography = None
-                    conversion_factor = None
+                    marker_conversion_factor = None
             except Exception as e:
-                homography = None
-                conversion_factor = None
+                marker_conversion_factor = None
+
+            jobs[job_id]['progress'] = 60
 
-            # Process each detected box
+            # Process each detected box using the conversion factor from pose estimation.
             for pred in box_detections:
                 x1, y1, x2, y2 = pred["box"]
                 label = pred["class"]
                 confidence = pred["confidence"]
                 cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
-
-                if homography is not None and conversion_factor is not None:
-                    # Warp the four corners of the bounding box using the homography
-                    pts = np.array([[x1, y1],
-                                    [x2, y1],
-                                    [x2, y2],
-                                    [x1, y2]], dtype=np.float32).reshape(-1, 1, 2)
-                    warped_pts = cv2.perspectiveTransform(pts, homography).reshape(-1, 2)
-                    new_x1, new_y1 = np.min(warped_pts, axis=0)
-                    new_x2, new_y2 = np.max(warped_pts, axis=0)
-                    box_width_pixels = new_x2 - new_x1
-                    box_height_pixels = new_y2 - new_y1
-                    box_width_cm = box_width_pixels * conversion_factor
-                    box_height_cm = box_height_pixels * conversion_factor
-                    width_str = f"{box_width_cm:.1f}"
-                    height_str = f"{box_height_cm:.1f}"
-                elif conversion_factor is not None:
-                    # Fallback: use direct pixel measurements
+                if marker_conversion_factor is not None:
                     box_width_pixels = x2 - x1
                     box_height_pixels = y2 - y1
-                    box_width_cm = box_width_pixels * conversion_factor
-                    box_height_cm = box_height_pixels * conversion_factor
+                    box_width_cm = box_width_pixels * marker_conversion_factor
+                    box_height_cm = box_height_pixels * marker_conversion_factor
                     width_str = f"{box_width_cm:.1f}"
                     height_str = f"{box_height_cm:.1f}"
                 else: