Update app.py

app.py

@@ -5,11 +5,12 @@ import time
 import json
 import random
 import logging
-import numpy as np  # Moved to top to fix NameError
+import numpy as np
 from datetime import datetime
 from collections import Counter
 from typing import Any, Dict, List, Optional, Tuple
-import matplotlib.pyplot as plt  # Added for chart generation
+import matplotlib.pyplot as plt
+from matplotlib import font_manager
 
 # Suppress Ultralytics warning by setting a writable config directory
 os.environ["YOLO_CONFIG_DIR"] = "/tmp/Ultralytics"
@@ -53,15 +54,16 @@ logging.basicConfig(
 
 # Global variables
 paused: bool = False
-frame_rate: float = 0.1
+frame_rate: float = 0.05  # Reduced for faster processing
 frame_count: int = 0
 log_entries: List[str] = []
-crack_counts: List[int] = []  # Track number of cracks per frame
-crack_severity_all: List[str] = []  # Track crack severities
+crack_counts: List[int] = []
+crack_severity_all: List[str] = []
 last_frame: Optional[np.ndarray] = None
 last_detections: Dict[str, Any] = {}
 last_timestamp: str = ""
 last_detected_images: List[str] = []
+detected_image_set: set = set()  # To avoid duplicates
 gps_coordinates: List[List[float]] = []
 video_loaded: bool = False
 active_service: Optional[str] = None
@@ -75,15 +77,6 @@ os.makedirs(CAPTURED_FRAMES_DIR, exist_ok=True)
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 def initialize_video(video_file: Optional[Any] = None) -> str:
-    """
-    Initialize the video file for processing.
-
-    Args:
-        video_file (Optional[Any]): Uploaded video file object (from Gradio).
-
-    Returns:
-        str: Status message indicating success or failure.
-    """
     global video_loaded, log_entries
     release_video()
     video_path = DEFAULT_VIDEO_PATH
@@ -106,19 +99,6 @@ def set_active_service(
     rs_val: bool,
     pl_val: bool
 ) -> Tuple[Optional[str], str]:
-    """
-    Set the active service category based on user selection.
-
-    Args:
-        service_name (str): Name of the service being toggled.
-        uc_val (bool): Under Construction toggle value.
-        om_val (bool): Operations Maintenance toggle value.
-        rs_val (bool): Road Safety toggle value.
-        pl_val (bool): Plantation toggle value.
-
-    Returns:
-        Tuple[Optional[str], str]: Active service name and status message.
-    """
     global active_service
     toggles = {
         "under_construction": uc_val,
@@ -146,36 +126,27 @@ def set_active_service(
     return None, "No Service Category Enabled"
 
 def generate_crack_trend_chart() -> Optional[plt.Figure]:
-    """
-    Generate a line chart for crack trend over time using Matplotlib.
-
-    Returns:
-        Optional[plt.Figure]: Matplotlib figure object or None if no data.
-    """
     if not crack_counts:
         return None
 
     data = crack_counts[-50:]
     labels = list(range(len(data)))
 
-    fig, ax = plt.subplots(figsize=(6, 4))
-    ax.plot(labels, data, color="#FF6347", label="Cracks Over Time")
-    ax.set_title("Crack Trend (Operations Maintenance)")
-    ax.set_xlabel("Frame")
-    ax.set_ylabel("Count")
+    fig, ax = plt.subplots(figsize=(6, 4), facecolor='#f0f4f8')
+    ax.plot(labels, data, color="#FF6347", linewidth=2.5, label="Cracks Over Time", marker='o', markersize=5)
+    ax.set_title("Crack Trend (Operations Maintenance)", fontsize=14, pad=15, fontweight='bold', color='#333333')
+    ax.set_xlabel("Frame", fontsize=12, color='#333333')
+    ax.set_ylabel("Count", fontsize=12, color='#333333')
     ax.set_ylim(bottom=0)
-    ax.grid(True)
-    ax.legend()
+    ax.grid(True, linestyle='--', alpha=0.7)
+    ax.set_facecolor('#ffffff')
+    ax.legend(frameon=True, facecolor='#ffffff', edgecolor='#333333')
+    for spine in ax.spines.values():
+        spine.set_edgecolor('#333333')
     plt.tight_layout()
     return fig
 
 def generate_crack_severity_chart() -> Optional[plt.Figure]:
-    """
-    Generate a pie chart for crack severity distribution using Matplotlib.
-
-    Returns:
-        Optional[plt.Figure]: Matplotlib figure object or None if no data.
-    """
     if not crack_severity_all:
         return None
 
@@ -183,25 +154,24 @@ def generate_crack_severity_chart() -> Optional[plt.Figure]:
     labels = list(count.keys())
     sizes = list(count.values())
 
-    fig, ax = plt.subplots(figsize=(6, 4))
-    ax.pie(
+    fig, ax = plt.subplots(figsize=(6, 4), facecolor='#f0f4f8')
+    colors = ['#FF6347', '#4682B4', '#FFD700']
+    wedges, texts, autotexts = ax.pie(
         sizes,
         labels=labels,
-        colors=["#FF6347", "#4682B4", "#FFD700"],
-        autopct="%1.1f%%",
-        startangle=90
+        colors=colors,
+        autopct='%1.1f%%',
+        startangle=90,
+        shadow=True,
+        textprops={'fontsize': 10, 'color': '#333333'}
     )
-    ax.set_title("Crack Severity (Operations Maintenance)")
+    ax.set_title("Crack Severity (Operations Maintenance)", fontsize=14, pad=15, fontweight='bold', color='#333333')
+    for w in wedges:
+        w.set_edgecolor('#333333')
     plt.tight_layout()
     return fig
 
 def generate_severity_distribution_chart() -> Optional[plt.Figure]:
-    """
-    Generate a bar chart for crack severity distribution using Matplotlib.
-
-    Returns:
-        Optional[plt.Figure]: Matplotlib figure object or None if no data.
-    """
     if not crack_severity_all:
         return None
 
@@ -209,12 +179,19 @@ def generate_severity_distribution_chart() -> Optional[plt.Figure]:
     labels = list(count.keys())
     sizes = list(count.values())
 
-    fig, ax = plt.subplots(figsize=(6, 4))
-    ax.bar(labels, sizes, color=["#FF6347", "#4682B4", "#FFD700"])
-    ax.set_title("Severity Distribution (Operations Maintenance)")
-    ax.set_xlabel("Severity")
-    ax.set_ylabel("Count")
+    fig, ax = plt.subplots(figsize=(6, 4), facecolor='#f0f4f8')
+    colors = ['#FF6347', '#4682B4', '#FFD700']
+    bars = ax.bar(labels, sizes, color=colors, edgecolor='#333333')
+    ax.set_title("Severity Distribution (Operations Maintenance)", fontsize=14, pad=15, fontweight='bold', color='#333333')
+    ax.set_xlabel("Severity", fontsize=12, color='#333333')
+    ax.set_ylabel("Count", fontsize=12, color='#333333')
     ax.set_ylim(bottom=0)
+    ax.set_facecolor('#ffffff')
+    for bar in bars:
+        height = bar.get_height()
+        ax.text(bar.get_x() + bar.get_width()/2, height, f'{int(height)}', ha='center', va='bottom', fontsize=10, color='#333333')
+    for spine in ax.spines.values():
+        spine.set_edgecolor('#333333')
     plt.tight_layout()
     return fig
 
@@ -227,21 +204,8 @@ def monitor_feed() -> Tuple[
     Optional[plt.Figure],
     List[str]
 ]:
-    """
-    Process video frames and perform detections based on the active service.
-
-    Returns:
-        Tuple containing:
-            - Processed frame (numpy array or None).
-            - Detection metrics (JSON string with crack trend and severity data).
-            - Recent logs (string).
-            - Crack trend chart (Matplotlib figure or None).
-            - Crack severity chart (Matplotlib figure or None).
-            - Severity distribution chart (Matplotlib figure or None).
-            - List of captured image paths.
-    """
     global paused, frame_count, last_frame, last_detections, last_timestamp
-    global gps_coordinates, last_detected_images, video_loaded
+    global gps_coordinates, last_detected_images, video_loaded, detected_image_set
 
     if not video_loaded:
         log_entries.append("Cannot start streaming: Video not loaded successfully.")
@@ -317,7 +281,7 @@ def monitor_feed() -> Tuple[
             frame = shadow_results["frame"]
             all_detected_items.extend(shadow_dets)
 
-            # Apply thermal processing if frame is grayscale
+            # Skip thermal processing to improve speed (unless grayscale frame is detected)
             if len(frame.shape) == 2:
                 thermal_results = process_thermal(frame)
                 thermal_dets = thermal_results["detections"]
@@ -329,9 +293,9 @@ def monitor_feed() -> Tuple[
             logging.error(f"Processing error in {active_service}: {str(e)}")
             all_detected_items = []
 
-        # Save temporary image for display
+        # Save temporary image for display (lower quality for speed)
         try:
-            cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
+            cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 80])
         except Exception as e:
             log_entries.append(f"Error saving temp image: {str(e)}")
             logging.error(f"Error saving temp image: {str(e)}")
@@ -339,19 +303,25 @@ def monitor_feed() -> Tuple[
         # Update detection metrics
         metrics = update_metrics(all_detected_items)
 
-        # Generate GPS coordinates with slight variation
+        # Generate 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 detections are present
+        # Save frame if detections are present (avoid duplicates)
         detection_types = {item.get("type") for item in all_detected_items if "type" in item}
         if detection_types:
             try:
-                captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"detected_{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)
+                # Create a unique identifier for the frame based on detections
+                detection_key = tuple(sorted([(item["type"], tuple(item["coordinates"])) for item in all_detected_items]))
+                detection_key_str = str(detection_key)
+                if detection_key_str not in detected_image_set:
+                    captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"detected_{frame_count}.jpg")
+                    cv2.imwrite(captured_frame_path, frame)
+                    last_detected_images.insert(0, captured_frame_path)  # Add to the beginning (newest first)
+                    detected_image_set.add(detection_key_str)
+                    if len(last_detected_images) > 100:
+                        old_image = last_detected_images.pop()
+                        detected_image_set.discard(str(old_image))
             except Exception as e:
                 log_entries.append(f"Error saving captured frame: {str(e)}")
                 logging.error(f"Error saving captured frame: {str(e)}")
@@ -386,7 +356,7 @@ def monitor_feed() -> Tuple[
         last_frame = frame.copy()
         last_detections = metrics
 
-        # Track cracks for metrics (for Operations Maintenance only)
+        # Track cracks for metrics (Operations Maintenance only)
         crack_detected = len([item for item in all_detected_items if item.get("type") == "crack"]) if active_service == "operations_maintenance" else 0
         if active_service == "operations_maintenance":
             crack_severity_all.extend([
@@ -417,10 +387,10 @@ def monitor_feed() -> Tuple[
         if len(crack_severity_all) > 500:
             crack_severity_all.pop(0)
 
-    # Resize frame and add metadata for 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)
+    # Resize frame for display (smaller size for speed)
+    frame = cv2.resize(last_frame, (320, 240))
+    cv2.putText(frame, f"Frame: {frame_count}", (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+    cv2.putText(frame, f"{last_timestamp}", (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
 
     # Generate charts for Operations Maintenance only
     line_chart = None
@@ -479,7 +449,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
 
     with gr.Row():
         with gr.Column(scale=3):
-            video_output = gr.Image(label="Live Drone Feed", width=640, height=480, elem_id="live-feed")
+            video_output = gr.Image(label="Live Drone Feed", width=320, height=240, elem_id="live-feed")
         with gr.Column(scale=1):
             detections_output = gr.Textbox(
                 label="Detection Metrics",
@@ -497,42 +467,71 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
             bar_output = gr.Plot(label="Severity Distribution (Operations Maintenance Only)")
 
     with gr.Row():
-        captured_images = gr.Gallery(label="Detected Frames (Last 100+)", columns=4, rows=25, height="auto")
+        captured_images = gr.Gallery(
+            label="Detected Frames (Last 100+)",
+            columns=4,
+            rows=5,
+            height="auto",
+            object_fit="contain",
+            preview=True
+        )
 
     with gr.Row():
         pause_btn = gr.Button("⏸️ Pause", variant="secondary")
         resume_btn = gr.Button("▶️ Resume", variant="primary")
-        frame_slider = gr.Slider(0.05, 1.0, value=0.1, label="Frame Interval (seconds)", step=0.05)
+        frame_slider = gr.Slider(0.01, 1.0, value=0.05, label="Frame Interval (seconds)", step=0.01)
 
     gr.HTML("""
     <style>
         #live-feed {
             border: 2px solid #4682B4;
             border-radius: 10px;
+            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
         }
         .gr-button-primary {
             background-color: #4682B4 !important;
+            border-radius: 5px;
+            transition: background-color 0.3s ease;
+        }
+        .gr-button-primary:hover {
+            background-color: #5a9bd4 !important;
         }
         .gr-button-secondary {
             background-color: #FF6347 !important;
+            border-radius: 5px;
+            transition: background-color 0.3s ease;
+        }
+        .gr-button-secondary:hover {
+            background-color: #ff826b !important;
+        }
+        .gr-plot {
+            background-color: #f0f4f8;
+            border-radius: 10px;
+            padding: 10px;
+            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+        }
+        .gr-gallery img {
+            border: 1px solid #4682B4;
+            border-radius: 5px;
+            transition: transform 0.3s ease;
+        }
+        .gr-gallery img:hover {
+            transform: scale(1.05);
         }
     </style>
     """)
 
     def toggle_pause() -> str:
-        """Pause the video stream."""
         global paused
         paused = True
         return "**Status:** ⏸️ Paused"
 
     def toggle_resume() -> str:
-        """Resume the video stream."""
         global paused
         paused = False
         return "**Status:** 🟢 Streaming"
 
     def set_frame_rate(val: float) -> None:
-        """Set the frame rate for streaming."""
         global frame_rate
         frame_rate = val
 
@@ -545,18 +544,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
     )
 
     def update_toggles(uc_val: bool, om_val: bool, rs_val: bool, pl_val: bool) -> Tuple[str, str, str, str, str]:
-        """
-        Update toggle states and set the active service.
-
-        Args:
-            uc_val (bool): Under Construction toggle value.
-            om_val (bool): Operations Maintenance toggle value.
-            rs_val (bool): Road Safety toggle value.
-            pl_val (bool): Plantation toggle value.
-
-        Returns:
-            Tuple[str, str, str, str, str]: Status updates for each toggle and overall status message.
-        """
         active, status_message = set_active_service("toggle", uc_val, om_val, rs_val, pl_val)
         uc_status_val = "Enabled" if active == "under_construction" else "Disabled"
         om_status_val = "Enabled" if active == "operations_maintenance" else "Disabled"
@@ -578,7 +565,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
     frame_slider.change(set_frame_rate, inputs=[frame_slider])
 
     def streaming_loop():
-        """Continuous loop to stream video and process frames."""
         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:]), None, None, None, last_detected_images