Update app.py

app.py

@@ -1,65 +1,134 @@
+import gradio as gr
 import cv2
 import time
 import os
-from services.video_service import get_random_video_frame
+import random
+import matplotlib.pyplot as plt
+import numpy as np
+from datetime import datetime
+from services.video_service import get_next_video_frame
 from services.thermal_service import detect_thermal_anomalies
 from services.overlay_service import overlay_boxes
 from services.metrics_service import update_metrics
 
-
+# Globals
 paused = False
-frame_rate = 1.0  # seconds
-
-
-
+frame_rate = 1
+frame_count = 0
+log_entries = []
+anomaly_counts = []
 
+# Constants
+TEMP_IMAGE_PATH = "temp.jpg"
 
+# Core monitor function
 def monitor_feed():
     global paused
+    global frame_count
 
-
+    frame = None
 
     if paused:
-        frame = get_random_video_frame()  # Still fetch to keep system active
-    else:
-        frame = get_random_video_frame()
-
-
+        if os.path.exists(TEMP_IMAGE_PATH):
+            frame = cv2.imread(TEMP_IMAGE_PATH)
 
+    if frame is None:
+        frame = get_next_video_frame()
 
+    if not paused:
         detected_boxes = detect_thermal_anomalies(frame)
         frame = overlay_boxes(frame, detected_boxes)
-
+        cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
         metrics = update_metrics(detected_boxes)
-        return frame[:, :, ::-1], metrics  # BGR → RGB
-
-
-
-
-    return frame[:, :, ::-1], {"Detections": 0}
-
-
-with gr.Blocks() as app:
-    gr.Markdown("# 🌡️ Solar Surveillance Thermal Monitoring")
+    else:
+        metrics = update_metrics([])
+
+    frame = cv2.resize(frame, (640, 480))  # Fixed window size
+
+    # Add frame count and timestamp
+    frame_count += 1
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    cv2.putText(frame, f"Frame: {frame_count}", (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+    cv2.putText(frame, f"{timestamp}", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+
+    # Update logs and anomaly counts
+    anomaly_detected = len(metrics['anomalies']) if 'anomalies' in metrics else 0
+    log_entries.append(f"{timestamp} - Frame {frame_count} - Anomalies Detected: {anomaly_detected}")
+    anomaly_counts.append(anomaly_detected)
+
+    if len(log_entries) > 100:
+        log_entries.pop(0)
+    if len(anomaly_counts) > 100:
+        anomaly_counts.pop(0)
+
+    return frame[:, :, ::-1], metrics, "\n".join(log_entries[-10:]), generate_chart()
+
+# Chart generator
+def generate_chart():
+    fig, ax = plt.subplots(figsize=(4, 2))
+    ax.plot(anomaly_counts[-50:], marker='o')
+    ax.set_title("Anomalies 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
+
+# Gradio UI
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+    gr.Markdown("# \ud83c\udf10 Thermal Anomaly Monitoring Dashboard", elem_id="main-title")
+
+    status_text = gr.Markdown("**Status:** \ud83d\udfe2 Running", elem_id="status-banner")
 
     with gr.Row():
         with gr.Column(scale=3):
-            video_output = gr.Image(label="Live Video Feed", elem_id="video-feed")
+            video_output = gr.Image(label="Live Video Feed", elem_id="video-feed", width=640, height=480)
         with gr.Column(scale=1):
-            metrics_output = gr.Label(label="Detection Metrics")
+            metrics_output = gr.Label(label="Live Metrics", elem_id="metrics")
+
+    with gr.Row():
+        with gr.Column():
+            logs_output = gr.Textbox(label="Live Logs", lines=10)
+        with gr.Column():
+            chart_output = gr.Image(label="Detection Trends")
 
     with gr.Row():
-        pause_btn = gr.Button("⏸️ Pause")
-        resume_btn = gr.Button("▶️ Resume")
-        frame_slider = gr.Slider(0.5, 5.0, step=0.1, value=1.0, label="Frame Interval (seconds)")
+        pause_btn = gr.Button("\u23f8\ufe0f Pause")
+        resume_btn = gr.Button("\u25b6\ufe0f Resume")
+        frame_slider = gr.Slider(0.2, 5, value=1, label="Frame Interval (seconds)")
 
     def toggle_pause():
         global paused
+        paused = True
+        return "**Status:** \u23f8\ufe0f Paused"
+
+    def toggle_resume():
+        global paused
+        paused = False
+        return "**Status:** \ud83d\udfe2 Running"
+
+    def set_frame_rate(val):
+        global frame_rate
+        frame_rate = val
+
+    pause_btn.click(toggle_pause, outputs=status_text)
+    resume_btn.click(toggle_resume, outputs=status_text)
+    frame_slider.change(set_frame_rate, inputs=[frame_slider])
 
     def streaming_loop():
         while True:
-            frame, metrics = monitor_feed()
-            yield frame, metrics
+            frame, metrics, logs, chart = monitor_feed()
+            # Check for alerts
+            if anomaly_counts and anomaly_counts[-1] >= 5:
+                status = "**Status:** \ud83d\udd34 Alert: High Anomaly Rate"
+            else:
+                status = "**Status:** \ud83d\udfe2 Running" if not paused else "**Status:** \u23f8\ufe0f Paused"
+            yield [frame, metrics, logs, chart, status]
             time.sleep(frame_rate)
 
-    app.load(streaming_loop, outputs=[video_output, metrics_output])
+    app.load(streaming_loop, outputs=[video_output, metrics_output, logs_output, chart_output, status_text])
+
+if __name__ == "__main__":
+    app.launch()