Update app.py

app.py

@@ -1,6 +1,10 @@
 import gradio as gr
 import cv2
 import numpy as np
+import time
+from datetime import datetime
+from collections import deque, defaultdict
+import matplotlib.pyplot as plt
 from services.video_service import VideoService
 from services.detection_service import DetectionService
 from services.thermal_service import ThermalService
@@ -23,78 +27,151 @@ VIDEO_PATHS = {
     "Shadow/Dust Feed": "data/shadow_dust_issue.mp4",
 }
 
-def process_video(video_type, confidence_threshold=0.9):
-    """Process the selected video feed and return results."""
+# State for live feed
+class LiveFeedState:
+    def __init__(self):
+        self.anomaly_history = deque(maxlen=100)  # Last 100 frames for trend
+        self.anomaly_types = defaultdict(int)     # Count of each anomaly type
+        self.captured_events = deque(maxlen=5)    # Last 5 events with frames
+        self.total_detected = 0                   # Total anomalies detected
+        self.logs = deque(maxlen=10)              # Last 10 log entries
+        self.frame_count = 0                      # Frame counter
+
+def live_feed_generator(video_type, confidence_threshold=0.9):
+    """Generator for live feed with real-time detection."""
+    state = LiveFeedState()
     video_path = VIDEO_PATHS.get(video_type)
+    
     if not video_path or not os.path.exists(video_path):
-        return "Video file not found.", None, None
+        yield gr.update(value="Video file not found."), None, None, None, None, None
+        return
+
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    frame_interval = 1 / fps  # Time between frames for real-time simulation
 
-    # Load and process video
-    frames = video_service.load_video(video_path)
-    results = []
-    output_frames = []
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)  # Loop the video
+            continue
 
-    for frame in frames:
-        # Convert frame to PIL Image
+        state.frame_count += 1
         frame_pil = video_service.frame_to_pil(frame)
 
+        # Perform detection based on video type
         if video_type == "Thermal Feed":
-            # Detect overheating (hot spots)
             detections = thermal_service.detect_hotspots(frame_pil, detection_service, confidence_threshold)
             alert_type = "Overheating"
         elif video_type == "Shadow/Dust Feed":
-            # Detect dusty or shaded panels
             detections = shadow_detection.detect_shadow_dust(frame_pil, detection_service, confidence_threshold)
             alert_type = "Shadow/Dust"
         else:
-            # General object detection for day/night feeds
             detections = detection_service.detect_objects(frame_pil, confidence_threshold)
             alert_type = "General"
 
         # Draw detections on frame
         annotated_frame = video_service.draw_detections(frame, detections)
+        annotated_frame_rgb = cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB)
+
+        # Update state
+        num_anomalies = len(detections)
+        state.anomaly_history.append(num_anomalies)
+        state.total_detected += num_anomalies
+
+        # Update anomaly types
+        for detection in detections:
+            label = detection["label"]
+            state.anomaly_types[label] += 1
+
+        # Log detection
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        log_entry = f"{timestamp} - Frame {state.frame_count} - Anomalies: {num_anomalies}"
+        state.logs.append(log_entry)
+
+        # Capture events (frames with anomalies)
+        if num_anomalies > 0:
+            state.captured_events.append(annotated_frame_rgb)
 
         # Generate Salesforce case and notifications
-        if detections:
+        if num_anomalies > 0:
             case_id = salesforce_dispatcher.create_case(
-                subject=f"{alert_type} Detected in {video_type}",
+                subject=f"{alert_type} Detected in {video_type} (Frame {state.frame_count})",
                 description=str(detections)
             )
             salesforce_dispatcher.send_email(
                 to="admin@solarplant.com",
                 subject=f"Alert: {alert_type} in {video_type}",
-                body=f"Case ID: {case_id}\nDetails: {detections}"
+                body=f"Case ID: {case_id}\nDetails: {detections}\nFrame: {state.frame_count}"
             )
             salesforce_dispatcher.notify_security_team(
-                message=f"Alert: {alert_type} detected in {video_type}. Case ID: {case_id}"
+                message=f"Alert: {alert_type} detected in {video_type}. Case ID: {case_id}, Frame: {state.frame_count}"
             )
 
-        results.append(detections)
-        output_frames.append(annotated_frame)
+        # Generate live metrics
+        metrics = []
+        for detection in detections:
+            box = detection["box"]
+            coords = f"[{box['xmin']},{box['ymin']},{box['xmax']},{box['ymax']}]"
+            metrics.append(coords)
+        metrics_str = f"anomalies: {metrics}, total_detected: {state.total_detected}"
 
-    # Save output video
-    output_path = "output_annotated.mp4"
-    video_service.save_video(output_frames, output_path)
+        # Generate detection trend plot
+        plt.figure(figsize=(4, 2))
+        plt.plot(list(state.anomaly_history), marker='o')
+        plt.title("Anomalies Over Time")
+        plt.xlabel("Frame")
+        plt.ylabel("Count")
+        plt.grid(True)
+        trend_plot = plt.gcf()
+        plt.close()
 
-    return str(results), output_path, None
+        # Generate anomaly types summary
+        anomaly_types_str = "\n".join([f"{k}: {v}" for k, v in state.anomaly_types.items()])
+
+        # Yield updated UI components
+        yield (
+            gr.update(value=annotated_frame_rgb),           # Live Video Feed
+            gr.update(value=metrics_str),                   # Live Metrics
+            gr.update(value="\n".join(state.logs)),        # Live Logs
+            gr.update(value=trend_plot),                    # Detection Trend
+            gr.update(value=anomaly_types_str),            # Anomaly Types
+            gr.update(value=list(state.captured_events))    # Captured Events
+        )
+
+        # Simulate real-time by sleeping between frames
+        time.sleep(frame_interval)
+
+    cap.release()
 
 # Gradio Interface
 with gr.Blocks() as demo:
     gr.Markdown("# Solar Panel Monitoring System")
-    video_type = gr.Dropdown(
-        choices=["Day Feed", "Night Feed", "Thermal Feed", "Shadow/Dust Feed"],
-        label="Select Drone Feed"
-    )
-    confidence_threshold = gr.Slider(0.5, 1.0, value=0.9, label="Confidence Threshold")
-    process_button = gr.Button("Process Video")
-    output_text = gr.Textbox(label="Detection Results")
-    output_video = gr.Video(label="Annotated Video")
-    error_message = gr.Textbox(label="Error Message")
-
-    process_button.click(
-        fn=process_video,
+    with gr.Row():
+        with gr.Column():
+            video_type = gr.Dropdown(
+                choices=["Day Feed", "Night Feed", "Thermal Feed", "Shadow/Dust Feed"],
+                label="Select Drone Feed",
+                value="Thermal Feed"
+            )
+            confidence_threshold = gr.Slider(0.5, 1.0, value=0.9, label="Confidence Threshold")
+            start_button = gr.Button("Start Live Feed")
+        with gr.Column():
+            live_feed = gr.Image(label="Live Video Feed", streaming=True)
+    with gr.Row():
+        with gr.Column():
+            live_metrics = gr.Textbox(label="Live Metrics")
+            live_logs = gr.Textbox(label="Live Logs")
+        with gr.Column():
+            detection_trend = gr.Plot(label="Detection Trend")
+            anomaly_types = gr.Textbox(label="Anomaly Types")
+    captured_events = gr.Gallery(label="Captured Events (Last 5)")
+
+    start_button.click(
+        fn=live_feed_generator,
         inputs=[video_type, confidence_threshold],
-        outputs=[output_text, output_video, error_message]
+        outputs=[live_feed, live_metrics, live_logs, detection_trend, anomaly_types, captured_events],
+        _js="() => {return [document.querySelector('select').value, document.querySelector('input[type=range]').value]}"
     )
 
 demo.launch()