Update app.py

app.py

@@ -243,6 +243,7 @@ def monitor_feed() -> Tuple[
         metrics = last_metrics.copy()
     else:
         max_retries = 3
+        start_time = time.time()
         for attempt in range(max_retries):
             try:
                 if is_video:
@@ -282,6 +283,9 @@ def monitor_feed() -> Tuple[
                 None
             )
 
+        # Resize frame for faster detection (320x512)
+        detection_frame = cv2.resize(frame, (512, 320))
+
         all_detected_items: List[Dict[str, Any]] = []
         shadow_issue = False
         thermal_flag = False
@@ -289,33 +293,33 @@ def monitor_feed() -> Tuple[
         try:
             # Process frame based on active service
             if active_service == "under_construction":
-                earthwork_dets, frame = process_earthwork(frame)
-                culvert_dets, frame = process_culverts(frame)
-                bridge_pier_dets, frame = process_bridge_piers(frame)
+                earthwork_dets, detection_frame = process_earthwork(detection_frame)
+                culvert_dets, detection_frame = process_culverts(detection_frame)
+                bridge_pier_dets, detection_frame = process_bridge_piers(detection_frame)
                 all_detected_items.extend(earthwork_dets + culvert_dets + bridge_pier_dets)
             elif active_service == "operations_maintenance":
-                crack_hole_dets, frame = detect_cracks_and_holes(frame)
-                pothole_dets, frame = process_potholes(frame)
-                signage_dets, frame = process_signages(frame)
+                crack_hole_dets, detection_frame = detect_cracks_and_holes(detection_frame)
+                pothole_dets, detection_frame = process_potholes(detection_frame)
+                signage_dets, detection_frame = process_signages(detection_frame)
                 all_detected_items.extend(crack_hole_dets + pothole_dets + signage_dets)
             elif active_service == "road_safety":
-                barrier_dets, frame = process_barriers(frame)
-                lighting_dets, frame = process_lighting(frame)
-                accident_dets, frame = process_accident_spots(frame)
-                pothole_crack_dets, frame = detect_potholes_and_cracks(frame)
+                barrier_dets, detection_frame = process_barriers(detection_frame)
+                lighting_dets, detection_frame = process_lighting(detection_frame)
+                accident_dets, detection_frame = process_accident_spots(detection_frame)
+                pothole_crack_dets, detection_frame = detect_potholes_and_cracks(detection_frame)
                 all_detected_items.extend(barrier_dets + lighting_dets + accident_dets + pothole_crack_dets)
             elif active_service == "plantation":
-                plant_dets, frame = process_plants(frame)
-                health_dets, frame = process_plant_health(frame)
-                missing_dets, frame = process_missing_patches(frame)
+                plant_dets, detection_frame = process_plants(detection_frame)
+                health_dets, detection_frame = process_plant_health(detection_frame)
+                missing_dets, detection_frame = process_missing_patches(detection_frame)
                 all_detected_items.extend(plant_dets + health_dets + missing_dets)
             else:
-                generic_dets, frame = process_generic(frame)
+                generic_dets, detection_frame = process_generic(detection_frame)
                 all_detected_items.extend(generic_dets)
 
             # Apply shadow detection
             try:
-                cv2.imwrite(TEMP_IMAGE_PATH, frame)
+                cv2.imwrite(TEMP_IMAGE_PATH, detection_frame)
                 shadow_issue = detect_shadow_coverage(TEMP_IMAGE_PATH)
             except Exception as e:
                 log_entries.append(f"Error saving temp image for shadow detection: {str(e)}")
@@ -323,14 +327,28 @@ def monitor_feed() -> Tuple[
                 shadow_issue = False
 
             # Apply thermal processing if frame is grayscale
-            if len(frame.shape) == 2:
-                thermal_results = process_thermal(frame)
+            if len(detection_frame.shape) == 2:
+                thermal_results = process_thermal(detection_frame)
                 thermal_dets = thermal_results["detections"]
-                frame = thermal_results["frame"]
+                detection_frame = thermal_results["frame"]
                 all_detected_items.extend(thermal_dets)
                 thermal_flag = bool(thermal_dets)
 
-            # Overlay detections with distinct colors
+            # Scale bounding boxes back to original frame size
+            orig_h, orig_w = frame.shape[:2]
+            det_h, det_w = detection_frame.shape[:2]
+            scale_x, scale_y = orig_w / det_w, orig_h / det_h
+            for item in all_detected_items:
+                if "box" in item:
+                    box = item["box"]
+                    item["box"] = [
+                        int(box[0] * scale_x),
+                        int(box[1] * scale_y),
+                        int(box[2] * scale_x),
+                        int(box[3] * scale_y)
+                    ]
+
+            # Overlay detections on the original frame
             for item in all_detected_items:
                 box = item.get("box", [])
                 if not box:
@@ -372,6 +390,10 @@ def monitor_feed() -> Tuple[
         gps_coord = [17.385044 + random.uniform(-0.001, 0.001), 78.486671 + frame_count * 0.0001]
         gps_coordinates.append(gps_coord)
 
+        # Add GPS to detected items for mapping
+        for item in all_detected_items:
+            item["gps"] = gps_coord
+
         # Save frame if detections are present
         detection_types = {item.get("type") for item in all_detected_items if "type" in item}
         if detection_types:
@@ -436,6 +458,7 @@ def monitor_feed() -> Tuple[
         detected_counts.append(plant_detected + crack_detected + hole_detected + missing_detected)
 
         # Log frame processing details in the requested format
+        processing_time = time.time() - start_time
         detection_summary = {
             "timestamp": last_timestamp,
             "frame": frame_count,
@@ -443,7 +466,8 @@ def monitor_feed() -> Tuple[
             "cracks": crack_detected,
             "holes": hole_detected,
             "missing_patches": missing_detected,
-            "gps": gps_coord
+            "gps": gps_coord,
+            "processing_time_ms": processing_time * 1000
         }
         log_message = json.dumps(detection_summary, indent=2)
         log_entries.append(log_message)
@@ -613,4 +637,4 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
     app.load(streaming_loop, outputs=[media_output, metrics_output, logs_output, plant_images, issue_images, chart_output, map_output])
 
 if __name__ == "__main__":
-    app.launch(share=False)
+    app.launch(share=True)  # Set share=True to create a public link