Update app.py

app.py

@@ -1,7 +1,6 @@
 import os
 import uuid
 import threading
-import time
 import cv2
 import numpy as np
 import base64
@@ -75,6 +74,10 @@ def custom_nms(preds, iou_threshold=0.3):
             filtered_preds.append(pred)
     return filtered_preds
 
+#########################################
+# 3. Processing Function with Homography Measurement
+#########################################
+
 def process_image(job_id, image_path, object_type):
     try:
         jobs[job_id]['progress'] = 10
@@ -106,10 +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
                     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
                     x1 = max(0, min(x1, img_width - 1))
                     y1 = max(0, min(y1, img_height - 1))
                     x2 = max(0, min(x2, img_width - 1))
@@ -125,53 +130,92 @@ def process_image(job_id, image_path, object_type):
             box_detections = custom_nms(processed_preds, iou_threshold=0.3)
             jobs[job_id]['progress'] = 60
 
-            # (Optional) Detect ArUco marker for measurement
-            marker_real_width_cm = 10.0
+            # -------------------------------
+            # Improved ArUco marker detection and homography computation
+            # -------------------------------
+            # Since your marker is 10 cm, we set:
+            marker_real_width_cm = 10.0  
+            homography = None
+            conversion_factor = None
             try:
                 gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
                 aruco_dict = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_6X6_250)
-                aruco_params = cv2.aruco.DetectorParameters()
+                # 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)
-                    marker_width_pixels = np.linalg.norm(marker_corners[0] - marker_corners[1])
-                    marker_height_pixels = np.linalg.norm(marker_corners[1] - marker_corners[2])
-                    marker_pixel_size = (marker_width_pixels + marker_height_pixels) / 2.0
-                    conversion_factor = marker_real_width_cm / marker_pixel_size
+                    # 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
                 else:
+                    homography = None
                     conversion_factor = None
             except Exception as e:
+                homography = None
                 conversion_factor = None
 
+            # Process each detected box
             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 conversion_factor is not None:
+
+                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
                     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
-                    size_text = f"{box_width_cm:.1f}x{box_height_cm:.1f} cm"
-                    detection_info.append({
-                        "class": label,
-                        "confidence": f"{confidence:.2f}",
-                        "width_cm": f"{box_width_cm:.1f}",
-                        "height_cm": f"{box_height_cm:.1f}"
-                    })
+                    width_str = f"{box_width_cm:.1f}"
+                    height_str = f"{box_height_cm:.1f}"
                 else:
-                    detection_info.append({
-                        "class": label,
-                        "confidence": f"{confidence:.2f}",
-                        "width_cm": "N/A",
-                        "height_cm": "N/A"
-                    })
+                    width_str = "N/A"
+                    height_str = "N/A"
+
+                detection_info.append({
+                    "class": label,
+                    "confidence": f"{confidence:.2f}",
+                    "width_cm": width_str,
+                    "height_cm": height_str
+                })
+
                 text = f"{label} ({confidence:.2f})"
                 (text_width, text_height), baseline = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
-                cv2.rectangle(image, (x1, y1 - text_height - baseline - 5), (x1 + text_width, y1 - 5), (0, 255, 0), -1)
-                cv2.putText(image, text, (x1, y1 - 5 - baseline), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1)
+                cv2.rectangle(image, (x1, y1 - text_height - baseline - 5),
+                              (x1 + text_width, y1 - 5), (0, 255, 0), -1)
+                cv2.putText(image, text, (x1, y1 - 5 - baseline),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1)
+
         elif object_type in {"person", "car"}:
             if yolov5_model is None:
                 jobs[job_id]['progress'] = 100
@@ -192,8 +236,10 @@ def process_image(job_id, image_path, object_type):
                         cv2.rectangle(image, (xmin, ymin), (xmax, ymax), (255, 0, 0), 2)
                         text = f"{label} ({conf:.2f})"
                         (text_width, text_height), baseline = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
-                        cv2.rectangle(image, (xmin, ymin - text_height - baseline - 5), (xmin + text_width, ymin - 5), (255, 0, 0), -1)
-                        cv2.putText(image, text, (xmin, ymin - 5 - baseline), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1)
+                        cv2.rectangle(image, (xmin, ymin - text_height - baseline - 5),
+                                      (xmin + text_width, ymin - 5), (255, 0, 0), -1)
+                        cv2.putText(image, text, (xmin, ymin - 5 - baseline),
+                                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1)
                         detection_info.append({
                             "class": label,
                             "confidence": f"{conf:.2f}",
@@ -205,7 +251,7 @@ def process_image(job_id, image_path, object_type):
                 jobs[job_id]['result'] = {"error": "Error during YOLOv5 inference."}
                 return
 
-        # Build summary text (drawn on image)
+        # Draw a summary of detection counts on the image
         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())
@@ -222,7 +268,7 @@ def process_image(job_id, image_path, object_type):
         jobs[job_id]['result'] = {"error": "Unexpected error during processing."}
 
 #########################################
-# 3. HTML Templates
+# 4. HTML Templates
 #########################################
 
 landing_template = '''
@@ -318,7 +364,7 @@ upload_template = '''
     </div>
   </div>
   <div class="typing-effect" id="typing"></div>
-  <!-- The file upload form (submission handled via AJAX) -->
+  <!-- File upload form (submission via AJAX) -->
   <form id="uploadForm">
     <input type="file" name="file" accept="image/*" required>
     <!-- Hidden field to pass the selected object type -->
@@ -356,7 +402,7 @@ upload_template = '''
   </div>
   <div class="footer">&copy; 2024 MathLens AI Detection App. All rights reserved.</div>
   <script>
-    // Handle typing effect (unchanged)
+    // Typing effect
     const textArray = ["MathLens", "Smart Counting with Maths"];
     let textIndex = 0, charIndex = 0, isDeleting = false;
     const typingElement = document.getElementById("typing");
@@ -380,15 +426,12 @@ upload_template = '''
     document.addEventListener("DOMContentLoaded", () => {
       setTimeout(typeEffect, 500);
     });
-
-    // AJAX-based submission and progress polling
+    // AJAX submission and progress polling
     const uploadForm = document.getElementById("uploadForm");
     uploadForm.addEventListener("submit", function(e) {
       e.preventDefault();
       const formData = new FormData(uploadForm);
-      // Show progress overlay
       document.getElementById("progressOverlay").style.display = "flex";
-      // Start the analysis job
       fetch("{{ url_for('analyze') }}", {
         method: "POST",
         body: formData
@@ -396,14 +439,12 @@ upload_template = '''
       .then(response => response.json())
       .then(data => {
         const jobId = data.job_id;
-        // Start polling progress every 500ms
         const progressInterval = setInterval(() => {
           fetch("{{ url_for('progress') }}?job_id=" + jobId)
           .then(response => response.json())
           .then(progData => {
             const progress = progData.progress;
             document.getElementById("progressBar").style.width = progress + "%";
-            // Update dynamic phrases based on progress
             if (progress < 10) {
               document.getElementById("progressText").textContent = "Starting up... 🛠️";
             } else if (progress < 30) {
@@ -419,12 +460,10 @@ upload_template = '''
             }
             if (progress >= 100) {
               clearInterval(progressInterval);
-              // Once done, fetch the result and update the page
               fetch("{{ url_for('result') }}?job_id=" + jobId)
               .then(response => response.json())
               .then(resultData => {
                 document.getElementById("progressOverlay").style.display = "none";
-                // Replace the result container with the new result
                 document.getElementById("resultContainer").innerHTML = `
                   <div class="content-wrapper">
                     <img src="data:image/jpeg;base64,${resultData.image_data}" alt="Processed Image" class="result-img">
@@ -436,7 +475,6 @@ upload_template = '''
         }, 500);
       });
     });
-
     function buildTableHTML(detectionInfo) {
       if (!detectionInfo || detectionInfo.length === 0) return "";
       let tableHTML = `<table>
@@ -468,28 +506,23 @@ upload_template = '''
 '''
 
 #########################################
-# 4. Flask Routes
+# 5. Flask Routes
 #########################################
 
-# Landing page (unchanged)
 @app.route('/')
 def landing():
     return render_template_string(landing_template)
 
-# Traditional upload page (in case you want to support non-AJAX)
 @app.route('/upload', methods=['GET'])
 def upload():
     object_type = request.args.get('object_type', '').lower()
     if object_type not in {"person", "car", "box"}:
         flash("Please select a valid object type.")
         return redirect(url_for('landing'))
-    # In this version the AJAX version is preferred.
     return render_template_string(upload_template, object_type=object_type)
 
-# Endpoint to start analysis (called via AJAX)
 @app.route('/analyze', methods=['POST'])
 def analyze():
-    # Save uploaded file
     if 'file' not in request.files:
         return jsonify({"error": "No file provided."}), 400
     file = request.files['file']
@@ -504,17 +537,12 @@ def analyze():
     except Exception as e:
         return jsonify({"error": "Error saving file."}), 500
 
-    # Create a unique job id and initialize job progress
     job_id = str(uuid.uuid4())
     jobs[job_id] = {"progress": 0, "result": None}
-    # Start background thread to process image
     thread = threading.Thread(target=process_image, args=(job_id, upload_path, object_type))
     thread.start()
-    # Optionally remove the uploaded file after starting the thread
-    # (In a real system, you might want to keep it until processing is done.)
     return jsonify({"job_id": job_id})
 
-# Endpoint for client to poll progress
 @app.route('/progress', methods=['GET'])
 def progress():
     job_id = request.args.get('job_id', '')
@@ -522,21 +550,18 @@ def progress():
         return jsonify({"progress": 0})
     return jsonify({"progress": jobs[job_id].get("progress", 0)})
 
-# Endpoint for client to fetch final result
 @app.route('/result', methods=['GET'])
 def result():
     job_id = request.args.get('job_id', '')
     if job_id not in jobs or jobs[job_id].get("result") is None:
         return jsonify({"error": "Result not available."}), 404
     result = jobs[job_id]["result"]
-    # Clean up job if desired
     del jobs[job_id]
     return jsonify(result)
 
 #########################################
-# 5. Run the App
+# 6. Run the App
 #########################################
 
 if __name__ == '__main__':
-    # Run in threaded mode so background threads can work
     app.run(host="0.0.0.0", port=7860, threaded=True)