Update app.py

app.py

@@ -2,140 +2,113 @@ import gradio as gr
 import cv2
 import time
 import os
-import random
-import matplotlib.pyplot as plt
-import numpy as np
+import json
 from datetime import datetime
-from collections import Counter
 from services.video_service import get_next_video_frame, reset_video_index, preload_video
-from services.crack_detection_service import detect_cracks_and_holes
-from services.overlay_service import overlay_boxes
-from services.metrics_service import update_metrics
-from services.map_service import generate_map
-
-# Preload video to reduce startup time
-preload_video()
+# Under Construction services
+from services.under_construction.earthwork_detection import process_earthwork
+from services.under_construction.culvert_check import process_culverts
+from services.under_construction.bridge_pier_check import process_bridge_piers
+# Comment out other services
+# from services.operations_maintenance.pothole_detection import process_potholes
+# from services.operations_maintenance.crack_detection import process_cracks
+# from services.operations_maintenance.signage_check import process_signages
+# from services.road_safety.barrier_check import process_barriers
+# from services.road_safety.lighting_check import process_lighting
+# from services.road_safety.accident_spot_check import process_accident_spots
+# from services.plantation.plant_count import process_plants
+# from services.plantation.plant_health import process_plant_health
+# from services.plantation.missing_patch_check import process_missing_patches
+# Original services (not used in this mode but imported for potential future use)
+from services.detection_service import process_frame as process_generic
+from services.metrics_service import compute_metrics
+from services.overlay_service import add_overlay
+from services.salesforce_dispatcher import dispatch_to_salesforce
+from services.shadow_detection import detect_shadows
+from services.thermal_service import process_thermal
+
+# Preload video
+try:
+    preload_video()
+except Exception as e:
+    print(f"Error preloading video: {str(e)}")
 
 # Globals
 paused = False
-frame_rate = 0.3  # Faster frame rate for quicker video reading
+frame_rate = 0.5  # Process every 0.5 seconds for real-time feel
 frame_count = 0
 log_entries = []
-crack_counts = []
-crack_severity_all = []
 last_frame = None
-last_metrics = {}
+last_detections = {}
 last_timestamp = ""
-last_detected_cracks = []  # Store up to 100+ crack images
-last_detected_holes = []   # Store up to 100+ hole images
-gps_coordinates = []
 
 # Constants
 TEMP_IMAGE_PATH = "temp.jpg"
-CAPTURED_FRAMES_DIR = "captured_frames"
-os.makedirs(CAPTURED_FRAMES_DIR, exist_ok=True)
+OUTPUT_DIR = "outputs"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
 
-# Core monitor function
 def monitor_feed():
-    global paused, frame_count, last_frame, last_metrics, last_timestamp, gps_coordinates, last_detected_cracks, last_detected_holes
+    """
+    Main function to process video frames in real-time.
+    """
+    global paused, frame_count, last_frame, last_detections, last_timestamp
 
     if paused and last_frame is not None:
         frame = last_frame.copy()
-        metrics = last_metrics.copy()
+        detections = last_detections.copy()
     else:
         try:
             frame = get_next_video_frame()
         except RuntimeError as e:
             log_entries.append(f"Error: {str(e)}")
-            return None, last_metrics, "\n".join(log_entries[-10:]), None, None, last_detected_cracks, last_detected_holes, None
-
-        detected_items = detect_cracks_and_holes(frame)  # Includes cracks and holes
-        frame = overlay_boxes(frame, detected_items)
-        cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
-        metrics = update_metrics(detected_items)
+            return None, json.dumps(last_detections, indent=2), "\n".join(log_entries[-10:])
+
+        # Run Under Construction detections
+        earthwork_dets, frame = process_earthwork(frame)
+        culvert_dets, frame = process_culverts(frame)
+        bridge_pier_dets, frame = process_bridge_piers(frame)
+
+        # Combine detections
+        all_detections = {
+            "earthwork": earthwork_dets,
+            "culverts": culvert_dets,
+            "bridge_piers": bridge_pier_dets,
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "frame_count": frame_count
+        }
+
+        # Compute metrics
+        all_dets_list = earthwork_dets + culvert_dets + bridge_pier_dets
+        metrics = compute_metrics(all_dets_list)
+        all_detections["metrics"] = metrics
+
+        # Dispatch to Salesforce
+        dispatch_to_salesforce(all_detections, all_detections["timestamp"])
+
+        # Save annotated frame
+        frame_path = os.path.join(OUTPUT_DIR, f"frame_{frame_count:04d}.jpg")
+        cv2.imwrite(frame_path, frame)
 
         frame_count += 1
         last_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        gps_coord = [17.385044 + random.uniform(-0.001, 0.001), 78.486671 + frame_count * 0.0001]
-        gps_coordinates.append(gps_coord)
-
-        # Save detected cracks and holes separately
-        if detected_items:
-            captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"detected_{frame_count}.jpg")
-            cv2.imwrite(captured_frame_path, frame)
-            for item in detected_items:
-                if item['type'] == 'crack':
-                    last_detected_cracks.append(captured_frame_path)
-                    if len(last_detected_cracks) > 100:
-                        last_detected_cracks.pop(0)
-                elif item['type'] == 'hole':
-                    last_detected_holes.append(captured_frame_path)
-                    if len(last_detected_holes) > 100:
-                        last_detected_holes.pop(0)
+        log_entries.append(f"{last_timestamp} - Frame {frame_count} - Detections: {len(all_dets_list)} - Avg Conf: {metrics['avg_confidence']:.2f}")
 
         last_frame = frame.copy()
-        last_metrics = metrics.copy()
-
-        # Update logs and stats
-        crack_detected = len([item for item in last_metrics.get('items', []) if item['type'] == 'crack'])
-        hole_detected = len([item for item in last_metrics.get('items', []) if item['type'] == 'hole'])
-        crack_severity_all.extend([
-            item['severity']
-            for item in last_metrics.get('items', [])
-            if item['type'] in ['crack', 'hole'] and isinstance(item, dict) and 'severity' in item
-        ])
-
-        log_entries.append(f"{last_timestamp} - Frame {frame_count} - Cracks: {crack_detected} - Holes: {hole_detected} - GPS: {gps_coord}")
-        crack_counts.append(crack_detected + hole_detected)
+        last_detections = all_detections
 
         if len(log_entries) > 100:
             log_entries.pop(0)
-        if len(crack_counts) > 500:
-            crack_counts.pop(0)
-        if len(crack_severity_all) > 500:
-            crack_severity_all.pop(0)
 
+    # Add frame count and timestamp to display
     frame = cv2.resize(last_frame, (640, 480))
     cv2.putText(frame, f"Frame: {frame_count}", (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
     cv2.putText(frame, f"{last_timestamp}", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
 
-    map_path = generate_map(gps_coordinates[-5:], [item for item in last_metrics.get('items', []) if item['type'] in ['crack', 'hole']])
-
-    return frame[:, :, ::-1], last_metrics, "\n".join(log_entries[-10:]), generate_line_chart(), generate_pie_chart(), last_detected_cracks, last_detected_holes, map_path
-
-# Line chart
-def generate_line_chart():
-    if not crack_counts:
-        return None
-    fig, ax = plt.subplots(figsize=(4, 2))
-    ax.plot(crack_counts[-50:], marker='o')
-    ax.set_title("Cracks/Holes Over Time")
-    ax.set_xlabel("Frame")
-    ax.set_ylabel("Count")
-    fig.tight_layout()
-    chart_path = "chart_temp.png"
-    fig.savefig(chart_path)
-    plt.close(fig)
-    return chart_path
-
-# Pie chart for severity
-def generate_pie_chart():
-    if not crack_severity_all:
-        return None
-    fig, ax = plt.subplots(figsize=(4, 2))
-    count = Counter(crack_severity_all[-200:])
-    labels, sizes = zip(*count.items())
-    ax.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=140)
-    ax.axis('equal')
-    fig.tight_layout()
-    pie_path = "pie_temp.png"
-    fig.savefig(pie_path)
-    plt.close(fig)
-    return pie_path
+    return frame[:, :, ::-1], json.dumps(last_detections, indent=2), "\n".join(log_entries[-10:])
 
 # Gradio UI
 with gr.Blocks(theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🛡️ Drone Road Inspection Dashboard")
+    gr.Markdown("# 🛡️ NHAI Drone Analytics Monitoring System - Under Construction")
 
     status_text = gr.Markdown("**Status:** 🟢 Running")
 
@@ -143,23 +116,15 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
         with gr.Column(scale=3):
             video_output = gr.Image(label="Live Drone Feed", width=640, height=480)
         with gr.Column(scale=1):
-            metrics_output = gr.Textbox(label="Crack/Hole Metrics", lines=4)
+            detections_output = gr.Textbox(label="Detections", lines=10)
 
     with gr.Row():
         logs_output = gr.Textbox(label="Live Logs", lines=8)
-        chart_output = gr.Image(label="Crack/Hole Trend")
-        pie_output = gr.Image(label="Severity Distribution")
-
-    with gr.Row():
-        map_output = gr.Image(label="Crack/Hole Locations Map")
-        with gr.Column():
-            crack_images = gr.Gallery(label="Detected Cracks (Last 100+)", columns=4, rows=13)
-            hole_images = gr.Gallery(label="Detected Holes (Last 100+)", columns=4, rows=13)
 
     with gr.Row():
         pause_btn = gr.Button("⏸️ Pause")
         resume_btn = gr.Button("▶️ Resume")
-        frame_slider = gr.Slider(0.0005, 5, value=0.3, label="Frame Interval (seconds)")
+        frame_slider = gr.Slider(0.1, 5, value=0.5, label="Frame Interval (seconds)")
 
     def toggle_pause():
         global paused
@@ -181,14 +146,14 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
 
     def streaming_loop():
         while True:
-            frame, metrics, logs, chart, pie, cracks, holes, map_path = monitor_feed()
+            frame, detections, logs = monitor_feed()
             if frame is None:
-                yield None, str(metrics), logs, chart, pie, cracks, holes, map_path
+                yield None, detections, logs
             else:
-                yield frame, str(metrics), logs, chart, pie, cracks, holes, map_path
+                yield frame, detections, logs
             time.sleep(frame_rate)
 
-    app.load(streaming_loop, outputs=[video_output, metrics_output, logs_output, chart_output, pie_output, crack_images, hole_images, map_output])
+    app.load(streaming_loop, outputs=[video_output, detections_output, logs_output])
 
 if __name__ == "__main__":
     app.launch(share=True)