Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import uuid
 import threading
+import time
 import cv2
 import numpy as np
 import base64
@@ -74,10 +75,6 @@ def custom_nms(preds, iou_threshold=0.3):
             filtered_preds.append(pred)
     return filtered_preds
 
-#########################################
-# 3. Processing Function with Pose-based Measurement
-#########################################
-
 def process_image(job_id, image_path, object_type):
     try:
         jobs[job_id]['progress'] = 10
@@ -109,12 +106,10 @@ 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 from 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 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,105 +123,64 @@ def process_image(job_id, image_path, object_type):
                     continue
 
             box_detections = custom_nms(processed_preds, iou_threshold=0.3)
-            jobs[job_id]['progress'] = 40
+            jobs[job_id]['progress'] = 60
 
-            # -------------------------------
-            # Use ArUco pose estimation to compute a conversion factor.
-            # Try multiple dictionaries in case your marker was created using a different one.
-            # IMPORTANT: For accurate measurement you need proper camera calibration.
-            # Replace the cameraMatrix and distCoeffs below with your actual parameters if available.
-            # -------------------------------
-            marker_conversion_factor = None
+            # (Optional) Detect ArUco marker for measurement
+            # IMPORTANT: Set this to your marker's real-world side length in centimeters.
+            marker_real_width_cm = 10.0  
             try:
                 gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-                # Use detector parameters
+                aruco_dict = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_6X6_250)
+                # Use the newer DetectorParameters_create if available
                 if hasattr(cv2.aruco, 'DetectorParameters_create'):
                     aruco_params = cv2.aruco.DetectorParameters_create()
                 else:
                     aruco_params = cv2.aruco.DetectorParameters()
-                # Try several common dictionaries
-                dictionaries = [
-                    cv2.aruco.DICT_6X6_250,
-                    cv2.aruco.DICT_4X4_50,
-                    cv2.aruco.DICT_4X4_100,
-                    cv2.aruco.DICT_5X5_100
-                ]
-                marker_found = False
-                for d in dictionaries:
-                    aruco_dict = cv2.aruco.getPredefinedDictionary(d)
-                    corners, ids, _ = cv2.aruco.detectMarkers(gray, aruco_dict, parameters=aruco_params)
-                    if ids is not None and len(corners) > 0:
-                        marker_found = True
-                        print("Detected marker using dictionary:", d)
-                        break
-                if marker_found:
-                    # Use approximate calibration parameters (adjust these if you have real calibration data)
-                    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)
-                    rvec = rvecs[0]
-                    tvec = tvecs[0]
-                    # Define 3D coordinates for the marker's corners in its 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 corners (e.g., top edge)
-                    pixel_distance = np.linalg.norm(projected_points[0] - projected_points[1])
-                    # Conversion factor: 10 cm (marker real width) divided by measured pixel distance
-                    marker_conversion_factor = 10.0 / pixel_distance  # cm per pixel
-                    # Optionally, draw the marker axis for visualization:
-                    cv2.aruco.drawAxis(image, cameraMatrix, distCoeffs, rvec, tvec, 0.05)
+                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)
+                    # Compute the distance between consecutive corners and take the average
+                    side_lengths = []
+                    for i in range(4):
+                        pt1 = marker_corners[i]
+                        pt2 = marker_corners[(i + 1) % 4]
+                        side_lengths.append(np.linalg.norm(pt1 - pt2))
+                    avg_side_length = np.mean(side_lengths)
+                    conversion_factor = marker_real_width_cm / avg_side_length
                 else:
-                    marker_conversion_factor = None
+                    conversion_factor = None
             except Exception as e:
-                marker_conversion_factor = None
-
-            jobs[job_id]['progress'] = 60
+                conversion_factor = None
 
-            # 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 marker_conversion_factor is not None:
+                if conversion_factor is not None:
                     box_width_pixels = x2 - x1
                     box_height_pixels = y2 - y1
-                    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}"
+                    box_width_cm = box_width_pixels * conversion_factor
+                    box_height_cm = box_height_pixels * conversion_factor
+                    detection_info.append({
+                        "class": label,
+                        "confidence": f"{confidence:.2f}",
+                        "width_cm": f"{box_width_cm:.1f}",
+                        "height_cm": f"{box_height_cm:.1f}"
+                    })
                 else:
-                    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
-                })
-
+                    detection_info.append({
+                        "class": label,
+                        "confidence": f"{confidence:.2f}",
+                        "width_cm": "N/A",
+                        "height_cm": "N/A"
+                    })
                 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
@@ -247,10 +201,8 @@ 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}",
@@ -262,7 +214,7 @@ def process_image(job_id, image_path, object_type):
                 jobs[job_id]['result'] = {"error": "Error during YOLOv5 inference."}
                 return
 
-        # Draw a summary of detection counts on the image
+        # Build summary text (drawn on 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())
@@ -279,7 +231,7 @@ def process_image(job_id, image_path, object_type):
         jobs[job_id]['result'] = {"error": "Unexpected error during processing."}
 
 #########################################
-# 4. HTML Templates
+# 3. HTML Templates
 #########################################
 
 landing_template = '''
@@ -375,7 +327,7 @@ upload_template = '''
     </div>
   </div>
   <div class="typing-effect" id="typing"></div>
-  <!-- File upload form (submission via AJAX) -->
+  <!-- The file upload form (submission handled via AJAX) -->
   <form id="uploadForm">
     <input type="file" name="file" accept="image/*" required>
     <!-- Hidden field to pass the selected object type -->
@@ -413,7 +365,7 @@ upload_template = '''
   </div>
   <div class="footer">&copy; 2024 MathLens AI Detection App. All rights reserved.</div>
   <script>
-    // Typing effect
+    // Handle typing effect
     const textArray = ["MathLens", "Smart Counting with Maths"];
     let textIndex = 0, charIndex = 0, isDeleting = false;
     const typingElement = document.getElementById("typing");
@@ -437,12 +389,14 @@ upload_template = '''
     document.addEventListener("DOMContentLoaded", () => {
       setTimeout(typeEffect, 500);
     });
-    // AJAX submission and progress polling
+    // AJAX-based 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
@@ -450,12 +404,14 @@ 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) {
@@ -471,10 +427,12 @@ 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">
@@ -517,23 +475,28 @@ upload_template = '''
 '''
 
 #########################################
-# 5. Flask Routes
+# 4. Flask Routes
 #########################################
 
+# Landing page
 @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']
@@ -548,12 +511,17 @@ 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', '')
@@ -561,18 +529,21 @@ 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)
 
 #########################################
-# 6. Run the App
+# 5. 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)