Update app.py

app.py

@@ -5,12 +5,11 @@ import time
 import json
 import random
 import logging
-import numpy as np
+import matplotlib.pyplot as plt
 from datetime import datetime
 from collections import Counter
 from typing import Any, Dict, List, Optional, Tuple
-import matplotlib.pyplot as plt
-from matplotlib import font_manager
+import numpy as np
 
 # Suppress Ultralytics warning by setting a writable config directory
 os.environ["YOLO_CONFIG_DIR"] = "/tmp/Ultralytics"
@@ -21,15 +20,16 @@ try:
     from services.detection_service import process_frame as process_generic
     from services.metrics_service import update_metrics
     from services.overlay_service import overlay_boxes
-    from services.salesforce_dispatcher import dispatch_to_salesforce
-    from services.shadow_detection import detect_shadows
+    from services.salesforce_dispatcher import send_to_salesforce
+    from services.shadow_detection import detect_shadow_coverage
     from services.thermal_service import process_thermal
+    from services.map_service import generate_map
     # 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
     # Operations Maintenance services
-    from services.operations_maintenance.crack_detection import detect_cracks_and_objects
+    from services.operations_maintenance.crack_detection import detect_cracks_and_holes
     from services.operations_maintenance.pothole_detection import process_potholes
     from services.operations_maintenance.signage_check import process_signages
     # Road Safety services
@@ -54,16 +54,16 @@ logging.basicConfig(
 
 # Global variables
 paused: bool = False
-frame_rate: float = 0.05  # Reduced for faster processing
+frame_rate: float = 0.3
 frame_count: int = 0
 log_entries: List[str] = []
 crack_counts: List[int] = []
 crack_severity_all: List[str] = []
 last_frame: Optional[np.ndarray] = None
-last_detections: Dict[str, Any] = {}
+last_metrics: Dict[str, Any] = {}
 last_timestamp: str = ""
-last_detected_images: List[str] = []
-detected_image_set: set = set()  # To avoid duplicates
+last_detected_cracks: List[str] = []
+last_detected_holes: List[str] = []
 gps_coordinates: List[List[float]] = []
 video_loaded: bool = False
 active_service: Optional[str] = None
@@ -86,11 +86,19 @@ def initialize_video(video_file: Optional[Any] = None) -> str:
         log_entries.append(f"Using uploaded video: {video_path}")
         logging.info(f"Using uploaded video: {video_path}")
     
-    status = preload_video(video_path)
-    video_loaded = "Error" not in status
-    log_entries.append(status)
-    logging.info(status)
-    return status
+    try:
+        preload_video()
+        video_loaded = True
+        status = f"Successfully loaded video: {video_path}"
+        log_entries.append(status)
+        logging.info(status)
+        return status
+    except Exception as e:
+        video_loaded = False
+        status = f"Error loading video: {str(e)}"
+        log_entries.append(status)
+        logging.error(status)
+        return status
 
 def set_active_service(
     service_name: str,
@@ -125,87 +133,47 @@ def set_active_service(
     logging.info("No service category enabled.")
     return None, "No Service Category Enabled"
 
-def generate_crack_trend_chart() -> Optional[plt.Figure]:
+def generate_line_chart() -> Optional[str]:
     if not crack_counts:
         return None
-
-    data = crack_counts[-50:]
-    labels = list(range(len(data)))
-
-    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, 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]:
+    fig, ax = plt.subplots(figsize=(4, 2))
+    ax.plot(crack_counts[-50:], marker='o', color='#4682B4')
+    ax.set_title("Cracks/Holes Over Time")
+    ax.set_xlabel("Frame")
+    ax.set_ylabel("Count")
+    ax.grid(True)
+    fig.tight_layout()
+    chart_path = "chart_temp.png"
+    fig.savefig(chart_path)
+    plt.close(fig)
+    return chart_path
+
+def generate_pie_chart() -> Optional[str]:
     if not crack_severity_all:
         return None
-
+    fig, ax = plt.subplots(figsize=(4, 2))
     count = Counter(crack_severity_all[-200:])
-    labels = list(count.keys())
-    sizes = list(count.values())
-
-    fig, ax = plt.subplots(figsize=(6, 4), facecolor='#f0f4f8')
-    colors = ['#FF6347', '#4682B4', '#FFD700']
-    wedges, texts, autotexts = ax.pie(
-        sizes,
-        labels=labels,
-        colors=colors,
-        autopct='%1.1f%%',
-        startangle=90,
-        shadow=True,
-        textprops={'fontsize': 10, 'color': '#333333'}
-    )
-    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]:
-    if not crack_severity_all:
-        return None
-
-    count = Counter(crack_severity_all[-200:])
-    labels = list(count.keys())
-    sizes = list(count.values())
-
-    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
+    labels, sizes = zip(*count.items())
+    colors = ['#FF6347', '#FFA500', '#32CD32', '#800080']
+    ax.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=140, colors=colors[:len(labels)])
+    ax.axis('equal')
+    fig.tight_layout()
+    pie_path = "pie_temp.png"
+    fig.savefig(pie_path)
+    plt.close(fig)
+    return pie_path
 
 def monitor_feed() -> Tuple[
     Optional[np.ndarray],
     str,
     str,
-    Optional[plt.Figure],
-    Optional[plt.Figure],
-    Optional[plt.Figure],
-    List[str]
+    List[str],
+    List[str],
+    Optional[str],
+    Optional[str]
 ]:
-    global paused, frame_count, last_frame, last_detections, last_timestamp
-    global gps_coordinates, last_detected_images, video_loaded, detected_image_set
+    global paused, frame_count, last_frame, last_metrics, last_timestamp
+    global gps_coordinates, last_detected_cracks, last_detected_holes, video_loaded
 
     if not video_loaded:
         log_entries.append("Cannot start streaming: Video not loaded successfully.")
@@ -214,15 +182,15 @@ def monitor_feed() -> Tuple[
             None,
             json.dumps({"error": "Video not loaded. Please upload a video file."}, indent=2),
             "\n".join(log_entries[-10:]),
+            last_detected_cracks,
+            last_detected_holes,
             None,
-            None,
-            None,
-            last_detected_images
+            None
         )
 
     if paused and last_frame is not None:
         frame = last_frame.copy()
-        detections = last_detections.copy()
+        metrics = last_metrics.copy()
     else:
         try:
             frame = get_next_video_frame()
@@ -233,15 +201,17 @@ def monitor_feed() -> Tuple[
             logging.error(f"Frame retrieval error: {str(e)}")
             return (
                 None,
-                json.dumps(last_detections, indent=2),
+                json.dumps(last_metrics, indent=2),
                 "\n".join(log_entries[-10:]),
+                last_detected_cracks,
+                last_detected_holes,
                 None,
-                None,
-                None,
-                last_detected_images
+                None
             )
 
         all_detected_items: List[Dict[str, Any]] = []
+        shadow_issue = False
+        thermal_flag = False
 
         try:
             # Process frame based on active service
@@ -250,56 +220,48 @@ def monitor_feed() -> Tuple[
                 culvert_dets, frame = process_culverts(frame)
                 bridge_pier_dets, frame = process_bridge_piers(frame)
                 all_detected_items.extend(earthwork_dets + culvert_dets + bridge_pier_dets)
-
             elif active_service == "operations_maintenance":
-                crack_items = detect_cracks_and_objects(frame)
-                frame = overlay_boxes(frame, crack_items)
+                crack_hole_dets, frame = detect_cracks_and_holes(frame)
                 pothole_dets, frame = process_potholes(frame)
                 signage_dets, frame = process_signages(frame)
-                all_detected_items.extend(crack_items + pothole_dets + signage_dets)
-
+                all_detected_items.extend(crack_hole_dets + pothole_dets + signage_dets)
             elif active_service == "road_safety":
                 barrier_dets, frame = process_barriers(frame)
                 lighting_dets, frame = process_lighting(frame)
                 accident_dets, frame = process_accident_spots(frame)
                 pothole_crack_dets, frame = detect_potholes_and_cracks(frame)
                 all_detected_items.extend(barrier_dets + lighting_dets + accident_dets + pothole_crack_dets)
-
             elif active_service == "plantation":
                 plant_dets, frame = process_plants(frame)
                 health_dets, frame = process_plant_health(frame)
                 missing_dets, frame = process_missing_patches(frame)
                 all_detected_items.extend(plant_dets + health_dets + missing_dets)
-
             else:
                 generic_dets, frame = process_generic(frame)
                 all_detected_items.extend(generic_dets)
 
             # Apply shadow detection
-            shadow_results = detect_shadows(frame)
-            shadow_dets = shadow_results["detections"]
-            frame = shadow_results["frame"]
-            all_detected_items.extend(shadow_dets)
+            shadow_issue = detect_shadow_coverage(TEMP_IMAGE_PATH)
 
-            # Skip thermal processing to improve speed (unless grayscale frame is detected)
+            # Apply thermal processing if frame is grayscale
             if len(frame.shape) == 2:
                 thermal_results = process_thermal(frame)
                 thermal_dets = thermal_results["detections"]
                 frame = thermal_results["frame"]
                 all_detected_items.extend(thermal_dets)
+                thermal_flag = bool(thermal_dets)
+
+            # Overlay detections
+            frame = overlay_boxes(frame, all_detected_items)
+
+            # Save temporary image
+            cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
 
         except Exception as e:
             log_entries.append(f"Processing Error: {str(e)}")
             logging.error(f"Processing error in {active_service}: {str(e)}")
             all_detected_items = []
 
-        # Save temporary image for display (lower quality for speed)
-        try:
-            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)}")
-
         # Update detection metrics
         metrics = update_metrics(all_detected_items)
 
@@ -307,42 +269,44 @@ def monitor_feed() -> Tuple[
         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 (avoid duplicates)
+        # Save frame if detections are present
         detection_types = {item.get("type") for item in all_detected_items if "type" in item}
         if detection_types:
             try:
-                # 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))
+                captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"detected_{frame_count}.jpg")
+                cv2.imwrite(captured_frame_path, frame)
+                for item in all_detected_items:
+                    if item.get("type") == "crack":
+                        last_detected_cracks.append(captured_frame_path)
+                        if len(last_detected_cracks) > 100:
+                            last_detected_cracks.pop(0)
+                    elif item.get("type") == "hole":
+                        last_detected_holes.append(captured_frame_path)
+                        if len(last_detected_holes) > 100:
+                            last_detected_holes.pop(0)
             except Exception as e:
                 log_entries.append(f"Error saving captured frame: {str(e)}")
                 logging.error(f"Error saving captured frame: {str(e)}")
 
         # Prepare data for Salesforce dispatch
         all_detections = {
-            "items": all_detected_items,
+            "detections": all_detected_items,
             "metrics": metrics,
             "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             "frame_count": frame_count,
-            "gps_coordinates": gps_coord
+            "gps_coordinates": gps_coord,
+            "shadow_issue": shadow_issue,
+            "thermal": thermal_flag
         }
 
         # Dispatch to Salesforce
         try:
-            dispatch_to_salesforce(all_detections, all_detections["timestamp"])
+            send_to_salesforce(all_detections)
         except Exception as e:
             log_entries.append(f"Salesforce Dispatch Error: {str(e)}")
             logging.error(f"Salesforce dispatch error: {str(e)}")
 
-        # Save processed frame to output directory
+        # Save processed frame
         try:
             frame_path = os.path.join(OUTPUT_DIR, f"frame_{frame_count:04d}.jpg")
             cv2.imwrite(frame_path, frame)
@@ -354,30 +318,23 @@ def monitor_feed() -> Tuple[
         frame_count += 1
         last_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         last_frame = frame.copy()
-        last_detections = metrics
+        last_metrics = metrics
 
-        # 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":
+        # Track cracks/holes for metrics
+        crack_detected = len([item for item in all_detected_items if item.get("type") == "crack"])
+        hole_detected = len([item for item in all_detected_items if item.get("type") == "hole"])
+        if active_service in ["operations_maintenance", "road_safety"]:
             crack_severity_all.extend([
                 item["severity"]
                 for item in all_detected_items
-                if item.get("type") == "crack" and "severity" in item
+                if item.get("type") in ["crack", "hole"] and "severity" in item
             ])
-
-        # Add crack trend and severity to metrics
-        if active_service == "operations_maintenance":
-            last_detections["crack_count_last_50_frames"] = crack_counts[-50:] if crack_counts else []
-            severity_counts = Counter(crack_severity_all[-200:]) if crack_severity_all else {}
-            last_detections["crack_severity_distribution"] = dict(severity_counts)
+        crack_counts.append(crack_detected + hole_detected)
 
         # Log frame processing details
-        log_message = f"{last_timestamp} - Frame {frame_count} - Detections: {len(all_detected_items)} - GPS: {gps_coord} - Avg Conf: {metrics.get('avg_confidence', 0):.2f}"
-        if crack_detected:
-            log_message += f" - Cracks: {crack_detected}"
+        log_message = f"{last_timestamp} - Frame {frame_count} - Cracks: {crack_detected} - Holes: {hole_detected} - GPS: {gps_coord}"
         log_entries.append(log_message)
         logging.info(log_message)
-        crack_counts.append(crack_detected)
 
         # Limit the size of logs and crack data
         if len(log_entries) > 100:
@@ -387,28 +344,22 @@ def monitor_feed() -> Tuple[
         if len(crack_severity_all) > 500:
             crack_severity_all.pop(0)
 
-    # 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)
+    # 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)
 
-    # Generate charts for Operations Maintenance only
-    line_chart = None
-    pie_chart = None
-    bar_chart = None
-    if active_service == "operations_maintenance":
-        line_chart = generate_crack_trend_chart()
-        pie_chart = generate_crack_severity_chart()
-        bar_chart = generate_severity_distribution_chart()
+    # Generate map
+    map_path = generate_map(gps_coordinates[-5:], [item for item in last_metrics.get("items", []) if item.get("type") in ["crack", "hole"]])
 
     return (
         frame[:, :, ::-1],  # Convert BGR to RGB for Gradio
-        json.dumps(last_detections, indent=2),
+        json.dumps(last_metrics, indent=2),
         "\n".join(log_entries[-10:]),
-        line_chart,
-        pie_chart,
-        bar_chart,
-        last_detected_images
+        last_detected_cracks,
+        last_detected_holes,
+        generate_line_chart(),
+        map_path
     )
 
 # Gradio UI setup
@@ -449,74 +400,42 @@ 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=320, height=240, elem_id="live-feed")
+            video_output = gr.Image(label="Live Drone Feed", width=640, height=480, elem_id="live-feed")
         with gr.Column(scale=1):
-            detections_output = gr.Textbox(
+            metrics_output = gr.Textbox(
                 label="Detection Metrics",
                 lines=10,
                 interactive=False,
-                placeholder="Detection metrics, crack trends, and severity distribution will appear here."
+                placeholder="Detection metrics, crack/hole counts will appear here."
             )
 
     with gr.Row():
         with gr.Column(scale=2):
             logs_output = gr.Textbox(label="Live Logs", lines=8, interactive=False)
         with gr.Column(scale=1):
-            chart_output = gr.Plot(label="Crack Trend (Operations Maintenance Only)")
-            pie_output = gr.Plot(label="Crack Severity (Operations Maintenance Only)")
-            bar_output = gr.Plot(label="Severity Distribution (Operations Maintenance Only)")
+            crack_images = gr.Gallery(label="Detected Cracks (Last 100+)", columns=4, rows=13, height="auto")
+            hole_images = gr.Gallery(label="Detected Holes (Last 100+)", columns=4, rows=13, height="auto")
 
     with gr.Row():
-        captured_images = gr.Gallery(
-            label="Detected Frames (Last 100+)",
-            columns=4,
-            rows=5,
-            height="auto",
-            object_fit="contain",
-            preview=True
-        )
+        chart_output = gr.Image(label="Crack/Hole Trend")
+        map_output = gr.Image(label="Crack/Hole Locations Map")
 
     with gr.Row():
         pause_btn = gr.Button("⏸️ Pause", variant="secondary")
         resume_btn = gr.Button("▶️ Resume", variant="primary")
-        frame_slider = gr.Slider(0.01, 1.0, value=0.05, label="Frame Interval (seconds)", step=0.01)
+        frame_slider = gr.Slider(0.05, 1.0, value=0.3, label="Frame Interval (seconds)", step=0.05)
 
     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>
     """)
@@ -567,16 +486,16 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
     def streaming_loop():
         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
+                yield None, json.dumps({"error": "Video not loaded. Please upload a video file."}, indent=2), "\n".join(log_entries[-10:]), last_detected_cracks, last_detected_holes, None, None
             else:
-                frame, detections, logs, line_chart, pie_chart, bar_chart, captured = monitor_feed()
+                frame, metrics, logs, cracks, holes, chart, map_path = monitor_feed()
                 if frame is None:
-                    yield None, detections, logs, None, None, None, captured
+                    yield None, metrics, logs, cracks, holes, chart, map_path
                 else:
-                    yield frame, detections, logs, line_chart, pie_chart, bar_chart, captured
+                    yield frame, metrics, logs, cracks, holes, chart, map_path
             time.sleep(frame_rate)
 
-    app.load(streaming_loop, outputs=[video_output, detections_output, logs_output, chart_output, pie_output, bar_output, captured_images])
+    app.load(streaming_loop, outputs=[video_output, metrics_output, logs_output, crack_images, hole_images, chart_output, map_output])
 
 if __name__ == "__main__":
     app.launch(share=False)