Update app.py

app.py

@@ -14,7 +14,7 @@ app = Flask(__name__)
 app.secret_key = 'your_secret_key'  # Replace with a secure secret key
 
 # Global dictionary to hold job progress and results
-jobs = {}  # jobs[job_id] = {"progress": int, "result": {...}}
+jobs = {}  # jobs[job_id] = {"progress": int, "result": {…}}
 
 #########################################
 # 1. Initialize the Models
@@ -75,10 +75,11 @@ def custom_nms(preds, iou_threshold=0.3):
             filtered_preds.append(pred)
     return filtered_preds
 
+# Note the added multiplier parameter.
 def process_image(job_id, image_path, object_type, multiplier):
     try:
         jobs[job_id]['progress'] = 10
-        # Load a fresh copy of the original image
+        # Load image
         image = cv2.imread(image_path)
         if image is None:
             jobs[job_id]['progress'] = 100
@@ -96,35 +97,18 @@ def process_image(job_id, image_path, object_type, multiplier):
                 jobs[job_id]['progress'] = 100
                 jobs[job_id]['result'] = {"error": "Roboflow model not available."}
                 return
+            try:
+                results = box_model.predict(image_path, confidence=50, overlap=30).json()
+                predictions = results.get("predictions", [])
+            except Exception as e:
+                jobs[job_id]['progress'] = 100
+                jobs[job_id]['result'] = {"error": "Error during Roboflow prediction."}
+                return
 
-            # Upscale the image if it is small to help detect small boxes.
-            scale_factor = 1
-            if img_width < 1000 or img_height < 1000:
-                scale_factor = 2
-
-            if scale_factor > 1:
-                upscaled_image = cv2.resize(image, None, fx=scale_factor, fy=scale_factor, interpolation=cv2.INTER_LINEAR)
-                temp_path = "upscaled.jpg"
-                cv2.imwrite(temp_path, upscaled_image)
-                results = box_model.predict(temp_path, confidence=30, overlap=20).json()
-            else:
-                results = box_model.predict(image_path, confidence=30, overlap=20).json()
-
-            predictions = results.get("predictions", [])
             processed_preds = []
             for prediction in predictions:
                 try:
-                    if scale_factor > 1:
-                        x = prediction["x"] / scale_factor
-                        y = prediction["y"] / scale_factor
-                        width = prediction["width"] / scale_factor
-                        height = prediction["height"] / scale_factor
-                    else:
-                        x = prediction["x"]
-                        y = prediction["y"]
-                        width = prediction["width"]
-                        height = prediction["height"]
-
+                    x, y, width, height = prediction["x"], prediction["y"], prediction["width"], prediction["height"]
                     x1 = int(round(x - width / 2))
                     y1 = int(round(y - height / 2))
                     x2 = int(round(x + width / 2))
@@ -141,54 +125,22 @@ def process_image(job_id, image_path, object_type, multiplier):
                 except Exception as e:
                     continue
 
-            # Use a higher NMS IoU threshold to avoid merging valid nearby detections.
-            box_detections = custom_nms(processed_preds, iou_threshold=0.7)
+            box_detections = custom_nms(processed_preds, iou_threshold=0.3)
             jobs[job_id]['progress'] = 60
 
-            # --- ArUco Marker Detection for Measurement ---
-            # We assume the printed marker is 5 cm x 5 cm.
-            marker_real_width_cm = 5.0
-            conversion_factor = None
-            marker_bbox = None
+            # (Optional) Detect ArUco marker for measurement
+            marker_real_width_cm = 10.0  
             try:
-                # Convert to grayscale
                 gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-                # Try with histogram equalization
-                equalized = cv2.equalizeHist(gray)
-                
-                # Use the DICT_6X6_250 dictionary; ensure your marker is generated with this dictionary.
-                aruco_dict = cv2.aruco.Dictionary_get(cv2.aruco.DICT_6X6_50)
-                parameters = cv2.aruco.DetectorParameters_create()
-                # Optionally tweak parameters if needed:
-                parameters.adaptiveThreshWinSizeMax = 400
-                parameters.minDistanceToBorder = 0
-                parameters.minMarkerPerimeterRate = 0.02
-                parameters.cornerRefinementMethod = cv2.aruco.CORNER_REFINE_SUBPIX
-
-                # First attempt detection on the equalized image
-                corners, ids, rejected = cv2.aruco.detectMarkers(equalized, aruco_dict, parameters=parameters)
-                print("DEBUG: Detected marker IDs (equalized):", ids)
-                # If no markers found, try the original grayscale image
-                if ids is None or len(ids) == 0:
-                    print("DEBUG: No markers detected on equalized image. Trying original grayscale.")
-                    corners, ids, rejected = cv2.aruco.detectMarkers(gray, aruco_dict, parameters=parameters)
-                    print("DEBUG: Detected marker IDs (original):", ids)
-                
-                if ids is not None and len(ids) > 0:
-                    selected_index = None
-                    # Try to select marker with ID 42 first
-                    for i, marker_id in enumerate(ids):
-                        if marker_id[0] == 42:
-                            selected_index = i
-                            break
-                    # If marker 42 is not found, use the first detected marker.
-                    if selected_index is None:
-                        print("DEBUG: Marker with ID 42 not found. Using first detected marker.")
-                        selected_index = 0
-
-                    marker_corners = corners[selected_index].reshape((4, 2))
-                    # Draw the detected marker on the image.
-                    cv2.aruco.drawDetectedMarkers(image, [corners[selected_index]], [ids[selected_index]])
+                aruco_dict = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_6X6_250)
+                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:
+                    marker_corners = corners[0].reshape((4, 2))
+                    cv2.aruco.drawDetectedMarkers(image, corners, ids)
                     side_lengths = []
                     for i in range(4):
                         pt1 = marker_corners[i]
@@ -196,41 +148,11 @@ def process_image(job_id, image_path, object_type, multiplier):
                         side_lengths.append(np.linalg.norm(pt1 - pt2))
                     avg_side_length = np.mean(side_lengths)
                     conversion_factor = marker_real_width_cm / avg_side_length
-                    print("DEBUG: Detected marker with ID", ids[selected_index][0],
-                          "Average side length (px):", avg_side_length,
-                          "Conversion factor:", conversion_factor)
-                    # Compute marker bounding box from the detected corners
-                    marker_bbox = (int(np.min(marker_corners[:, 0])),
-                                   int(np.min(marker_corners[:, 1])),
-                                   int(np.max(marker_corners[:, 0])),
-                                   int(np.max(marker_corners[:, 1])))
-                    print("DEBUG: Marker bounding box:", marker_bbox)
                 else:
-                    print("DEBUG: No markers detected in ArUco detection.")
+                    conversion_factor = None
             except Exception as e:
-                print("DEBUG: Exception during ArUco detection:", e)
                 conversion_factor = None
 
-            # --- Filter out the marker from box detections ---
-            if marker_bbox is not None:
-                print("DEBUG: Filtering out aruco marker detection from box detections.")
-                filtered_box_detections = []
-                for detection in box_detections:
-                    x1, y1, x2, y2 = detection["box"]
-                    # Compute the center of the detection
-                    cx, cy = (x1 + x2) / 2, (y1 + y2) / 2
-                    # Compute IoU between detection and marker bounding box
-                    iou_val = compute_iou(detection["box"], marker_bbox)
-                    print("DEBUG: Detection box:", detection["box"], "Center:", (cx, cy), "IoU with marker:", iou_val)
-                    # If the center falls inside the marker's bbox or if IoU is above threshold, skip this detection.
-                    mx1, my1, mx2, my2 = marker_bbox
-                    if (mx1 <= cx <= mx2 and my1 <= cy <= my2) or iou_val > 0.3:
-                        print("DEBUG: Removing detection as marker.")
-                        continue
-                    filtered_box_detections.append(detection)
-                box_detections = filtered_box_detections
-
-            # --- Draw remaining box detections and compute measurements ---
             for pred in box_detections:
                 x1, y1, x2, y2 = pred["box"]
                 label = pred["class"]
@@ -295,11 +217,9 @@ def process_image(job_id, image_path, object_type, multiplier):
         detection_counts = Counter(det["class"] for det in detection_info)
         if detection_counts:
             top_text = ", ".join(f"{cls}: {count}" for cls, count in detection_counts.items())
-            summary_font_scale = 1 * multiplier
-            summary_thickness = 2 * multiplier
-            (info_width, info_height), info_baseline = cv2.getTextSize(top_text, cv2.FONT_HERSHEY_SIMPLEX, summary_font_scale, summary_thickness)
+            (info_width, info_height), info_baseline = cv2.getTextSize(top_text, cv2.FONT_HERSHEY_SIMPLEX, 1, 2)
             cv2.rectangle(image, (5, 5), (5 + info_width, 5 + info_height + info_baseline), (0, 255, 0), -1)
-            cv2.putText(image, top_text, (5, 5 + info_height), cv2.FONT_HERSHEY_SIMPLEX, summary_font_scale, (0, 0, 0), summary_thickness)
+            cv2.putText(image, top_text, (5, 5 + info_height), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
 
         jobs[job_id]['progress'] = 100
         retval, buffer = cv2.imencode('.jpg', image)
@@ -580,6 +500,7 @@ def analyze():
     object_type = request.form.get('object_type', '').lower()
     if object_type not in {"person", "car", "box"}:
         return jsonify({"error": "Invalid object type."}), 400
+    # Retrieve the multiplier sent from the client
     try:
         multiplier = int(request.form.get('multiplier', 1))
     except ValueError: