Update app.py

app.py

@@ -1,22 +1,24 @@
-import gradio as gr
-import cv2
-import os
-import numpy as np
-from datetime import datetime
-import matplotlib.pyplot as plt
+import gradio as gr  # Import Gradio for building the interactive UI
+import cv2  # Import OpenCV for video processing and annotation
+import os  # Import os for file handling
+import numpy as np  # Import NumPy for array operations
+from datetime import datetime  # Import datetime for timestamp generation
+import matplotlib.pyplot as plt  # Import Matplotlib for plotting trends
+
+# Import custom modules for fault detection, model loading, and settings
 from services.detection_service import detect_faults_solar, detect_faults_windmill
 from services.anomaly_service import track_faults, predict_fault
 from models.solar_model import load_solar_model
 from models.windmill_model import load_windmill_model
 from config.settings import VIDEO_FOLDER
 
-# Initialize global state
-logs = []
-fault_counts = []
-frame_numbers = []
-total_detected = 0
+# Initialize global state to track faults across frames
+logs = []  # List to store log entries
+fault_counts = []  # List to store fault counts per frame
+frame_numbers = []  # List to store frame numbers
+total_detected = 0  # Counter for total faults detected
 
-# Custom CSS to match the screenshot and simulate Box styling
+# Custom CSS to style the dashboard, mimicking the screenshot's blue borders and layout
 css = """
 <style>
 .main-header {
@@ -58,41 +60,42 @@ css = """
 </style>
 """
 
+# Function to process video frames and detect faults
 def process_video(video_path, detection_type):
     global logs, fault_counts, frame_numbers, total_detected
-    cap = cv2.VideoCapture(video_path)
+    cap = cv2.VideoCapture(video_path)  # Open the video file
     if not cap.isOpened():
         return "Error: Could not open video file.", None, None, None, None, None
 
-    model = load_solar_model() if detection_type == "Solar Panel" else load_windmill_model()
+    model = load_solar_model() if detection_type == "Solar Panel" else load_windmill_model()  # Load appropriate model
     frame_count = 0
 
-    # Clear previous state for a new video
+    # Clear previous state for a new video session
     logs.clear()
     fault_counts.clear()
     frame_numbers.clear()
     total_detected = 0
 
     while cap.isOpened():
-        ret, frame = cap.read()
+        ret, frame = cap.read()  # Read each frame
         if not ret:
             break
 
         frame_count += 1
-        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)  # Convert to RGB for display
 
-        # Detect faults
+        # Detect faults using the appropriate model
         faults = detect_faults_solar(model, frame_rgb) if detection_type == "Solar Panel" else detect_faults_windmill(model, frame_rgb)
         num_faults = len(faults)
 
-        # Draw bounding boxes and labels
+        # Draw bounding boxes and labels for detected faults
         for fault in faults:
             x, y = int(fault['location'][0]), int(fault['location'][1])
-            cv2.rectangle(frame_rgb, (x-30, y-30), (x+30, y+30), (255, 0, 0), 2)
+            cv2.rectangle(frame_rgb, (x-30, y-30), (x+30, y+30), (255, 0, 0), 2)  # Draw blue box
             cv2.putText(frame_rgb, f"{fault['type']}", (x, y-40), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2)
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2)  # Add fault type label
 
-        # Update state
+        # Update state with current frame data
         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         log_entry = f"{timestamp} - Frame {frame_count} - Faults: {num_faults}"
         logs.append(log_entry)
@@ -100,19 +103,19 @@ def process_video(video_path, detection_type):
         fault_counts.append(num_faults)
         frame_numbers.append(frame_count)
 
-        # Limit to last 100 frames
+        # Limit data to last 100 frames for performance
         if len(frame_numbers) > 100:
             frame_numbers.pop(0)
             fault_counts.pop(0)
 
-        # Prepare outputs
+        # Prepare outputs for Gradio UI
         video_output = frame_rgb
         metrics = f"faults: {num_faults}<br>total_detected: {total_detected}"
-        live_logs = "<br>".join(logs[-20:])  # Show last 20 logs for brevity
+        live_logs = "<br>".join(logs[-20:])  # Display last 20 logs
         last_5_events = "<br>".join(logs[-5:]) if logs else "No events yet"
         prediction = "Potential fault escalation detected!" if predict_fault(fault_counts) else ""
 
-        # Generate trends graph
+        # Generate fault trends graph
         fig, ax = plt.subplots(figsize=(6, 3))
         ax.plot(frame_numbers, fault_counts, marker='o', color='blue')
         ax.set_title("Faults Over Time", fontsize=10)
@@ -124,55 +127,55 @@ def process_video(video_path, detection_type):
 
         return video_output, metrics, live_logs, last_5_events, fig, prediction
 
-# Gradio interface
+# Create Gradio Blocks interface with custom CSS
 with gr.Blocks(css=css) as demo:
-    gr.Markdown('<div class="main-header">THERMAL FAULT DETECTION DASHBOARD</div>')
-    gr.Markdown('<div class="status">🟢 RUNNING</div>')
+    gr.Markdown("### THERMAL FAULT DETECTION DASHBOARD")  # Main header
+    gr.Markdown("#### 🟢 RUNNING")  # Status indicator
 
     with gr.Row():
         with gr.Column(scale=3):
             with gr.Column():
-                gr.Markdown('<div class="section-title">LIVE VIDEO FEED</div>', unsafe_allow_html=True)
+                gr.Markdown("**LIVE VIDEO FEED**")  # Section title
                 gr.Markdown('<div class="section-box">', unsafe_allow_html=True)
-                video_output = gr.Image(label="", interactive=False)
+                video_output = gr.Image(label="", interactive=False)  # Display video feed
                 gr.Markdown('</div>', unsafe_allow_html=True)
         with gr.Column(scale=1):
             with gr.Column():
-                gr.Markdown('<div class="section-title">LIVE METRICS</div>', unsafe_allow_html=True)
+                gr.Markdown("**LIVE METRICS**")  # Section title
                 gr.Markdown('<div class="section-box">', unsafe_allow_html=True)
-                metrics_output = gr.Markdown(label="", unsafe_allow_html=True)
-                prediction_output = gr.Markdown(label="")
+                metrics_output = gr.Markdown(label="")  # Display metrics
+                prediction_output = gr.Markdown(label="")  # Display prediction warning
                 gr.Markdown('</div>', unsafe_allow_html=True)
 
     with gr.Row():
         with gr.Column(scale=1):
             with gr.Column():
-                gr.Markdown('<div class="section-title">LIVE LOGS</div>', unsafe_allow_html=True)
+                gr.Markdown("**LIVE LOGS**")  # Section title
                 gr.Markdown('<div class="section-box">', unsafe_allow_html=True)
-                logs_output = gr.Markdown(label="", unsafe_allow_html=True)
+                logs_output = gr.Markdown(label="")  # Display live logs
                 gr.Markdown('</div>', unsafe_allow_html=True)
             with gr.Column():
-                gr.Markdown('<div class="section-title">LAST 5 CAPTURED EVENTS</div>', unsafe_allow_html=True)
+                gr.Markdown("**LAST 5 CAPTURED EVENTS**")  # Section title
                 gr.Markdown('<div class="section-box">', unsafe_allow_html=True)
-                events_output = gr.Markdown(label="", unsafe_allow_html=True)
+                events_output = gr.Markdown(label="")  # Display last 5 events
                 gr.Markdown('</div>', unsafe_allow_html=True)
         with gr.Column(scale=2):
             with gr.Column():
-                gr.Markdown('<div class="section-title">DETECTION TRENDS</div>', unsafe_allow_html=True)
+                gr.Markdown("**DETECTION TRENDS**")  # Section title
                 gr.Markdown('<div class="section-box">', unsafe_allow_html=True)
-                gr.Markdown('<div style="font-size: 14px; font-weight: bold; margin-bottom: 10px;">Faults Over Time</div>', unsafe_allow_html=True)
-                trends_output = gr.Plot(label="")
+                gr.Markdown("**Faults Over Time**")  # Sub-title
+                trends_output = gr.Plot(label="")  # Display fault trends graph
                 gr.Markdown('</div>', unsafe_allow_html=True)
 
-    # Sidebar for settings
+    # Sidebar for user inputs
     with gr.Row():
         with gr.Column():
-            video_files = [f for f in os.listdir(VIDEO_FOLDER) if f.endswith('.mp4')]
-            video_input = gr.Dropdown(choices=video_files, label="Select Video")
-            detection_type = gr.Dropdown(choices=["Solar Panel", "Windmill"], label="Detection Type")
-            submit_btn = gr.Button("Start Processing")
+            video_files = [f for f in os.listdir(VIDEO_FOLDER) if f.endswith('.mp4')]  # Get video files
+            video_input = gr.Dropdown(choices=video_files, label="Select Video")  # Video selection
+            detection_type = gr.Dropdown(choices=["Solar Panel", "Windmill"], label="Detection Type")  # Detection type
+            submit_btn = gr.Button("Start Processing")  # Trigger button
 
-    # Connect inputs to outputs
+    # Connect inputs to outputs with event trigger
     submit_btn.click(
         fn=process_video,
         inputs=[video_input, detection_type],
@@ -180,4 +183,5 @@ with gr.Blocks(css=css) as demo:
         _js="() => [document.querySelector('input[type=\"file\"]').value, document.querySelector('select[name=\"detection_type\"]').value]"
     )
 
+# Launch the Gradio app
 demo.launch()