Update app.py

app.py

@@ -3,50 +3,47 @@ import cv2
 import time
 import os
 import json
+import random
 from datetime import datetime
+from collections import Counter
 from services.video_service import get_next_video_frame, reset_video_index, preload_video, release_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
-# Original services
-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.crack_detection_service import detect_cracks_and_objects
+from services.overlay_service import overlay_boxes
+from services.metrics_service import update_metrics
 from services.salesforce_dispatcher import dispatch_to_salesforce
-from services.shadow_detection import detect_shadows
-from services.thermal_service import process_thermal
 
 # Globals
 paused = False
 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_detections = {}
 last_timestamp = ""
+last_detected_images = []  # Store up to 100+ crack images
+gps_coordinates = []
 video_loaded = False
 
 # Constants
 DEFAULT_VIDEO_PATH = "sample.mp4"
 TEMP_IMAGE_PATH = "temp.jpg"
+CAPTURED_FRAMES_DIR = "captured_frames"
 OUTPUT_DIR = "outputs"
+os.makedirs(CAPTURED_FRAMES_DIR, exist_ok=True)
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 def initialize_video(video_file=None):
     """
     Initialize the video with the provided file or default path.
-    Args:
-        video_file: Uploaded video file (Gradio File object) or None.
-    Returns:
-        str: Status message
     """
     global video_loaded, log_entries
-    release_video()  # Release any existing video capture
+    release_video()
     video_path = DEFAULT_VIDEO_PATH
 
     if video_file is not None:
-        video_path = video_file.name  # Gradio File object has a 'name' attribute with the temp path
+        video_path = video_file.name
         log_entries.append(f"Using uploaded video: {video_path}")
     
     status = preload_video(video_path)
@@ -58,11 +55,11 @@ def monitor_feed():
     """
     Main function to process video frames in real-time.
     """
-    global paused, frame_count, last_frame, last_detections, last_timestamp, video_loaded
+    global paused, frame_count, last_frame, last_detections, last_timestamp, gps_coordinates, last_detected_images, video_loaded
 
     if not video_loaded:
         log_entries.append("Cannot start streaming: Video not loaded successfully.")
-        return None, json.dumps({"error": "Video not loaded. Please upload a video file."}, indent=2), "\n".join(log_entries[-10:])
+        return None, json.dumps({"error": "Video not loaded. Please upload a video file."}, indent=2), "\n".join(log_entries[-10:]), None, None, last_detected_images
 
     if paused and last_frame is not None:
         frame = last_frame.copy()
@@ -72,27 +69,35 @@ def monitor_feed():
             frame = get_next_video_frame()
         except RuntimeError as e:
             log_entries.append(f"Error: {str(e)}")
-            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
+            return None, json.dumps(last_detections, indent=2), "\n".join(log_entries[-10:]), None, None, last_detected_images
+
+        # Detect cracks and objects
+        detected_items = detect_cracks_and_objects(frame)
+        frame = overlay_boxes(frame, detected_items)
+        cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
+        metrics = update_metrics(detected_items)
+
+        # Simulate GPS coordinates
+        gps_coord = [17.385044 + random.uniform(-0.001, 0.001), 78.486671 + frame_count * 0.0001]
+        gps_coordinates.append(gps_coord)
+
+        # Save frame if cracks are detected
+        if any(item['type'] == 'crack' for item in detected_items):
+            captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"crack_{frame_count}.jpg")
+            cv2.imwrite(captured_frame_path, frame)
+            last_detected_images.append(captured_frame_path)
+            if len(last_detected_images) > 100:
+                last_detected_images.pop(0)
+
+        # Combine detections for Salesforce
         all_detections = {
-            "earthwork": earthwork_dets,
-            "culverts": culvert_dets,
-            "bridge_piers": bridge_pier_dets,
+            "items": detected_items,
+            "metrics": metrics,
             "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "frame_count": frame_count
+            "frame_count": frame_count,
+            "gps_coordinates": gps_coord
         }
 
-        # 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"])
 
@@ -102,24 +107,128 @@ def monitor_feed():
 
         frame_count += 1
         last_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        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_detections = all_detections
+        last_detections = metrics
+
+        # Update logs and stats
+        crack_detected = len([item for item in last_detections.get('items', []) if item['type'] == 'crack'])
+        crack_severity_all.extend([
+            item['severity']
+            for item in last_detections.get('items', [])
+            if item['type'] == 'crack' and 'severity' in item
+        ])
+
+        log_entries.append(f"{last_timestamp} - Frame {frame_count} - Cracks: {crack_detected} - GPS: {gps_coord} - Avg Conf: {metrics['avg_confidence']:.2f}")
+        crack_counts.append(crack_detected)
 
         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)
 
-    return frame[:, :, ::-1], json.dumps(last_detections, indent=2), "\n".join(log_entries[-10:])
+    # Generate charts
+    line_chart = generate_line_chart()
+    pie_chart = generate_pie_chart()
+
+    return frame[:, :, ::-1], json.dumps(last_detections, indent=2), "\n".join(log_entries[-10:]), line_chart, pie_chart, last_detected_images
+
+def generate_line_chart():
+    """
+    Generate a line chart for crack counts over time using Chart.js.
+    """
+    if not crack_counts:
+        return None
+
+    data = crack_counts[-50:]  # Last 50 frames
+    labels = list(range(len(data)))
+
+    return {
+        "type": "line",
+        "data": {
+            "labels": labels,
+            "datasets": [{
+                "label": "Cracks Over Time",
+                "data": data,
+                "borderColor": "#FF6347",  # Tomato
+                "backgroundColor": "rgba(255, 99, 71, 0.2)",
+                "fill": True,
+                "tension": 0.4
+            }]
+        },
+        "options": {
+            "responsive": True,
+            "plugins": {
+                "title": {
+                    "display": True,
+                    "text": "Cracks Over Time"
+                }
+            },
+            "scales": {
+                "x": {
+                    "title": {
+                        "display": True,
+                        "text": "Frame"
+                    }
+                },
+                "y": {
+                    "title": {
+                        "display": True,
+                        "text": "Count"
+                    },
+                    "beginAtZero": True
+                }
+            }
+        }
+    }
+
+def generate_pie_chart():
+    """
+    Generate a pie chart for crack severity distribution using Chart.js.
+    """
+    if not crack_severity_all:
+        return None
+
+    count = Counter(crack_severity_all[-200:])  # Last 200 cracks
+    labels = list(count.keys())
+    sizes = list(count.values())
+
+    return {
+        "type": "pie",
+        "data": {
+            "labels": labels,
+            "datasets": [{
+                "data": sizes,
+                "backgroundColor": [
+                    "#FF6347",  # Tomato
+                    "#4682B4",  # SteelBlue
+                    "#FFD700"   # Gold
+                ]
+            }]
+        },
+        "options": {
+            "responsive": True,
+            "plugins": {
+                "title": {
+                    "display": True,
+                    "text": "Crack Severity Distribution"
+                },
+                "legend": {
+                    "position": "top"
+                }
+            }
+        }
+    }
 
 # Gradio UI
 with gr.Blocks(theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🛡️ NHAI Drone Analytics Monitoring System - Under Construction")
+    gr.Markdown("# 🛡️ NHAI Drone Road Inspection Dashboard")
 
     # Video upload section
     with gr.Row():
@@ -133,15 +242,21 @@ 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):
-            detections_output = gr.Textbox(label="Detections", lines=10)
+            detections_output = gr.Textbox(label="Crack Metrics", lines=4)
 
     with gr.Row():
         logs_output = gr.Textbox(label="Live Logs", lines=8)
+        with gr.Column(scale=1):
+            chart_output = gr.Plot(label="Crack Trend")
+            pie_output = gr.Plot(label="Crack Severity")
+
+    with gr.Row():
+        captured_images = gr.Gallery(label="Detected Cracks (Last 100+)", columns=4, rows=25)
 
     with gr.Row():
         pause_btn = gr.Button("⏸️ Pause")
         resume_btn = gr.Button("▶️ Resume")
-        frame_slider = gr.Slider(0.1, 5, value=0.5, label="Frame Interval (seconds)")
+        frame_slider = gr.Slider(0.0005, 5, value=0.5, label="Frame Interval (seconds)")
 
     def toggle_pause():
         global paused
@@ -157,10 +272,9 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
         global frame_rate
         frame_rate = val
 
-    # Initialize video on app load (try default path)
+    # Initialize video on app load
     video_status.value = initialize_video()
 
-    # Load video when user uploads a file
     load_button.click(
         initialize_video,
         inputs=[video_input],
@@ -172,19 +286,18 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
     frame_slider.change(set_frame_rate, inputs=[frame_slider])
 
     def streaming_loop():
-        global video_loaded
         while True:
             if not video_loaded:
-                yield None, json.dumps({"error": "Video not loaded. Please upload a video file."}, indent=2), "\n".join(log_entries[-10:])
+                yield None, json.dumps({"error": "Video not loaded. Please upload a video file."}, indent=2), "\n".join(log_entries[-10:]), None, None, last_detected_images
             else:
-                frame, detections, logs = monitor_feed()
+                frame, detections, logs, line_chart, pie_chart, captured = monitor_feed()
                 if frame is None:
-                    yield None, detections, logs
+                    yield None, detections, logs, line_chart, pie_chart, captured
                 else:
-                    yield frame, detections, logs
+                    yield frame, detections, logs, line_chart, pie_chart, captured
             time.sleep(frame_rate)
 
-    app.load(streaming_loop, outputs=[video_output, detections_output, logs_output])
+    app.load(streaming_loop, outputs=[video_output, detections_output, logs_output, chart_output, pie_output, captured_images])
 
 if __name__ == "__main__":
     app.launch(share=True)