Update app.py

app.py

@@ -40,7 +40,7 @@ logging.basicConfig(
 
 # Globals
 paused = False
-frame_rate = 0.5  # Process every 0.5 seconds for real-time feel
+frame_rate = 0.1  # Faster frame rate for real-time feel
 frame_count = 0
 log_entries = []
 crack_counts = []
@@ -48,15 +48,10 @@ crack_severity_all = []
 last_frame = None
 last_detections = {}
 last_timestamp = ""
-last_detected_images = []  # Store up to 100+ crack images
+last_detected_images = []  # Store up to 100+ frames with detections
 gps_coordinates = []
 video_loaded = False
-service_toggles = {
-    "under_construction": False,
-    "operations_maintenance": False,
-    "road_safety": False,
-    "plantation": False
-}
+active_service = None  # Track the active service category
 
 # Constants
 DEFAULT_VIDEO_PATH = "sample.mp4"
@@ -85,26 +80,49 @@ def initialize_video(video_file=None):
     logging.info(status)
     return status
 
-def toggle_service(service_name, value):
+def set_active_service(service_name, uc_val, om_val, rs_val, pl_val):
     """
-    Toggle a service category.
+    Set the active service category based on toggles.
+    Only one service category can be active at a time.
     """
-    global service_toggles
-    service_toggles[service_name] = value
-    status_msg = f"{service_name.replace('_', ' ').title()} Services {'Enabled' if value else 'Disabled'}"
-    log_entries.append(status_msg)
-    logging.info(status_msg)
-    return status_msg
+    global active_service, service_toggles
+    toggles = {
+        "under_construction": uc_val,
+        "operations_maintenance": om_val,
+        "road_safety": rs_val,
+        "plantation": pl_val
+    }
+    
+    # Ensure only one toggle is active
+    active_count = sum(toggles.values())
+    if active_count > 1:
+        log_entries.append("Error: Only one service category can be active at a time.")
+        logging.error("Multiple service categories enabled simultaneously.")
+        return None, "Error: Please enable only one service category at a time."
+
+    # Set active service
+    for service, enabled in toggles.items():
+        if enabled:
+            active_service = service
+            log_entries.append(f"{service.replace('_', ' ').title()} Services Enabled")
+            logging.info(f"{service} services enabled")
+            return active_service, f"{service.replace('_', ' ').title()} Services: Enabled"
+    
+    active_service = None
+    log_entries.append("No service category enabled.")
+    logging.info("No service category enabled.")
+    return None, "No Service Category Enabled"
 
 def monitor_feed():
     """
-    Main function to process video frames in real-time, showing only enabled service detections.
+    Main function to process video frames in real-time.
+    Only the active service category processes the frame.
     """
     global paused, frame_count, last_frame, last_detections, last_timestamp, gps_coordinates, last_detected_images, video_loaded
 
     if not video_loaded:
         log_entries.append("Cannot start streaming: Video not loaded successfully.")
-        logging.error("Cannot start streaming: Video not loaded successfully.")
+        logging.error("Video not loaded successfully.")
         return None, json.dumps({"error": "Video not loaded. Please upload a video file."}, indent=2), "\n".join(log_entries[-10:]), None, None, last_detected_images
 
     if paused and last_frame is not None:
@@ -113,158 +131,91 @@ def monitor_feed():
     else:
         try:
             frame = get_next_video_frame()
+            if frame is None:
+                raise RuntimeError("Failed to retrieve frame from video.")
         except RuntimeError as e:
             log_entries.append(f"Error: {str(e)}")
-            logging.error(f"Video Frame Error: {str(e)}")
+            logging.error(f"Frame retrieval error: {str(e)}")
             return None, json.dumps(last_detections, indent=2), "\n".join(log_entries[-10:]), None, None, last_detected_images
 
-        # Reset frame for overlay
-        original_frame = frame.copy()
+        # Initialize detected items list
         all_detected_items = []
-        display_items = []  # Items to display in the live feed
-        crack_items = []  # Track crack items separately for charts and gallery
 
-        # Counter for numbered labels, reset per frame
-        line_counter = 1
-
-        # Process enabled services
-        if service_toggles["under_construction"]:
-            try:
-                earthwork_dets, _ = process_earthwork(original_frame.copy())
-                culvert_dets, _ = process_culverts(original_frame.copy())
-                bridge_pier_dets, _ = process_bridge_piers(original_frame.copy())
-                uc_items = earthwork_dets + culvert_dets + bridge_pier_dets
-                # Add numbered labels
-                for item in uc_items:
-                    item["label"] = f"Line {line_counter} - {item.get('type', 'Unknown').capitalize()} (Conf: {item.get('confidence', 0):.2f})"
-                    line_counter += 1
-                all_detected_items.extend(uc_items)
-                display_items.extend(uc_items)
-            except Exception as e:
-                log_entries.append(f"Under Construction Error: {str(e)}")
-                logging.error(f"Under Construction Error: {str(e)}")
-
-        if service_toggles["operations_maintenance"]:
-            try:
-                crack_dets = detect_cracks_and_objects(original_frame.copy())
-                pothole_dets, _ = process_potholes(original_frame.copy())
-                signage_dets, _ = process_signages(original_frame.copy())
-                om_items = crack_dets + pothole_dets + signage_dets
-                # Add numbered labels
-                for item in om_items:
-                    item["label"] = f"Line {line_counter} - {item.get('type', 'Unknown').capitalize()} (Conf: {item.get('confidence', 0):.2f})"
-                    line_counter += 1
-                all_detected_items.extend(om_items)
-                display_items.extend(om_items)
-                # Track cracks for charts and gallery
-                crack_items = [item for item in om_items if item.get('type') == 'crack']
-            except Exception as e:
-                log_entries.append(f"Operations Maintenance Error: {str(e)}")
-                logging.error(f"Operations Maintenance Error: {str(e)}")
-
-        if service_toggles["road_safety"]:
-            try:
-                barrier_dets, _ = process_barriers(original_frame.copy())
-                lighting_dets, _ = process_lighting(original_frame.copy())
-                accident_dets, _ = process_accident_spots(original_frame.copy())
-                rs_items = barrier_dets + lighting_dets + accident_dets
-                # Add numbered labels
-                for item in rs_items:
-                    item["label"] = f"Line {line_counter} - {item.get('type', 'Unknown').replace('_', ' ').capitalize()} (Conf: {item.get('confidence', 0):.2f})"
-                    line_counter += 1
-                all_detected_items.extend(rs_items)
-                display_items.extend(rs_items)
-            except Exception as e:
-                log_entries.append(f"Road Safety Error: {str(e)}")
-                logging.error(f"Road Safety Error: {str(e)}")
-
-        if service_toggles["plantation"]:
-            try:
-                plant_dets, _ = process_plants(original_frame.copy())
-                health_dets, _ = process_plant_health(original_frame.copy())
-                missing_dets, _ = process_missing_patches(original_frame.copy())
-                pl_items = plant_dets + health_dets + missing_dets
-                # Add numbered labels
-                for item in pl_items:
-                    label_type = item.get('type', 'Unknown')
-                    if label_type == "plant" and "health" in item:
-                        label_str = f"Line {line_counter} - Plant (Health: {item['health'].capitalize()})"
-                    else:
-                        label_str = f"Line {line_counter} - {label_type.replace('_', ' ').capitalize()}"
-                    if "confidence" in item:
-                        label_str += f" (Conf: {item['confidence']:.2f})"
-                    item["label"] = label_str
-                    line_counter += 1
-                all_detected_items.extend(pl_items)
-                display_items.extend(pl_items)
-            except Exception as e:
-                log_entries.append(f"Plantation Error: {str(e)}")
-                logging.error(f"Plantation Error: {str(e)}")
+        # Process only the active service category
+        try:
+            if active_service == "under_construction":
+                earthwork_dets, frame = process_earthwork(frame)
+                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)
+                pothole_dets, frame = process_potholes(frame)
+                signage_dets, frame = process_signages(frame)
+                all_detected_items.extend(crack_items + 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)
+                all_detected_items.extend(barrier_dets + lighting_dets + accident_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)
 
-        # Fallback: Run generic detection if no services are enabled
-        if not any(service_toggles.values()) or not all_detected_items:
-            try:
-                generic_dets, _ = process_generic(original_frame.copy())
-                # Add numbered labels
-                for item in generic_dets:
-                    item["label"] = f"Line {line_counter} - {item.get('type', 'Unknown').capitalize()} (Conf: {item.get('confidence', 0):.2f})"
-                    line_counter += 1
+            else:
+                # Fallback: Run generic detection if no service is active
+                generic_dets, frame = process_generic(frame)
                 all_detected_items.extend(generic_dets)
-                display_items.extend(generic_dets)
-            except Exception as e:
-                log_entries.append(f"Generic Detection Error: {str(e)}")
-                logging.error(f"Generic Detection Error: {str(e)}")
 
-        # Optional: Run shadow detection (only log results for now)
-        try:
-            shadow_results = detect_shadows(original_frame.copy())
+            # Optional: Run shadow detection (affects all modes for better accuracy)
+            shadow_results = detect_shadows(frame)
             shadow_dets = shadow_results["detections"]
-            # Add numbered labels if shadows are to be displayed
-            if any(service_toggles.values()):  # Only append if a service is enabled
-                for item in shadow_dets:
-                    item["label"] = f"Line {line_counter} - Shadow (Conf: {item.get('confidence', 0):.2f})"
-                    line_counter += 1
-                all_detected_items.extend(shadow_dets)
-                display_items.extend(shadow_dets)
-        except Exception as e:
-            log_entries.append(f"Shadow Detection Error: {str(e)}")
-            logging.error(f"Shadow Detection Error: {str(e)}")
+            frame = shadow_results["frame"]
+            all_detected_items.extend(shadow_dets)
 
-        # Optional: Run thermal processing if frame is grayscale (simulated check)
-        if len(original_frame.shape) == 2:
-            try:
-                thermal_results = process_thermal(original_frame.copy())
+            # Optional: Run thermal processing if frame is grayscale (simulated check)
+            if len(frame.shape) == 2:  # Grayscale frame (simulating thermal input)
+                thermal_results = process_thermal(frame)
                 thermal_dets = thermal_results["detections"]
-                # Add numbered labels
-                for item in thermal_dets:
-                    item["label"] = f"Line {line_counter} - Thermal Anomaly (Conf: {item.get('confidence', 0):.2f})"
-                    line_counter += 1
+                frame = thermal_results["frame"]
                 all_detected_items.extend(thermal_dets)
-                display_items.extend(thermal_dets)
-            except Exception as e:
-                log_entries.append(f"Thermal Processing Error: {str(e)}")
-                logging.error(f"Thermal Processing Error: {str(e)}")
 
-        # Overlay only the display_items on the frame
-        frame = original_frame.copy()
-        if display_items:
-            frame = overlay_boxes(frame, display_items)
+        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 frame with overlays
-        cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
+        try:
+            cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
+        except Exception as e:
+            log_entries.append(f"Error saving temp image: {str(e)}")
+            logging.error(f"Error saving temp image: {str(e)}")
+
         metrics = update_metrics(all_detected_items)
 
         # Simulate 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 cracks are detected (only if operations_maintenance is enabled)
-        if service_toggles["operations_maintenance"] and crack_items:
-            captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"crack_{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)
+        # Save frame if there are detections (e.g., cracks, plants, etc.)
+        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)
+            except Exception as e:
+                log_entries.append(f"Error saving captured frame: {str(e)}")
+                logging.error(f"Error saving captured frame: {str(e)}")
 
         # Combine detections for Salesforce
         all_detections = {
@@ -280,29 +231,35 @@ def monitor_feed():
             dispatch_to_salesforce(all_detections, all_detections["timestamp"])
         except Exception as e:
             log_entries.append(f"Salesforce Dispatch Error: {str(e)}")
-            logging.error(f"Salesforce Dispatch Error: {str(e)}")
+            logging.error(f"Salesforce dispatch error: {str(e)}")
 
         # Save annotated frame
-        frame_path = os.path.join(OUTPUT_DIR, f"frame_{frame_count:04d}.jpg")
-        cv2.imwrite(frame_path, frame)
+        try:
+            frame_path = os.path.join(OUTPUT_DIR, f"frame_{frame_count:04d}.jpg")
+            cv2.imwrite(frame_path, frame)
+        except Exception as e:
+            log_entries.append(f"Error saving output frame: {str(e)}")
+            logging.error(f"Error saving output frame: {str(e)}")
 
         frame_count += 1
         last_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         last_frame = frame.copy()
         last_detections = metrics
 
-        # Update logs and stats (focus on cracks if operations_maintenance is enabled)
-        crack_detected = len(crack_items)
-        if service_toggles["operations_maintenance"]:
+        # Update logs and stats
+        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([
-                item['severity']
-                for item in crack_items
-                if 'severity' in item
+                item["severity"]
+                for item in all_detected_items
+                if item.get("type") == "crack" and "severity" in item
             ])
 
-        log_msg = f"{last_timestamp} - Frame {frame_count} - Cracks: {crack_detected} - Total Displayed Detections: {len(display_items)} - GPS: {gps_coord} - Avg Conf: {metrics['avg_confidence']:.2f}"
-        log_entries.append(log_msg)
-        logging.info(log_msg)
+        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_entries.append(log_message)
+        logging.info(log_message)
         crack_counts.append(crack_detected)
 
         if len(log_entries) > 100:
@@ -317,10 +274,10 @@ def monitor_feed():
     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 (only if operations_maintenance is enabled)
+    # Generate charts (only for operations_maintenance)
     line_chart = None
     pie_chart = None
-    if service_toggles["operations_maintenance"]:
+    if active_service == "operations_maintenance":
         line_chart = generate_line_chart()
         pie_chart = generate_pie_chart()
 
@@ -414,51 +371,79 @@ def generate_pie_chart():
     }
 
 # Gradio UI
-with gr.Blocks(theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🛡️ NHAI Drone Road Inspection Dashboard")
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green")) as app:
+    gr.Markdown(
+        """
+        # 🛡️ NHAI Drone Road Inspection Dashboard
+        Monitor highway conditions in real-time using drone footage. Select a service category to analyze specific aspects of the road.
+        """
+    )
 
     # Video upload section
     with gr.Row():
-        video_input = gr.File(label="Upload Video File (e.g., sample.mp4)", file_types=["video"])
-        load_button = gr.Button("Load Video")
-    video_status = gr.Textbox(label="Video Load Status", value="Please upload a video file or ensure 'sample.mp4' exists in the root directory.")
+        with gr.Column(scale=3):
+            video_input = gr.File(label="Upload Video File (e.g., sample.mp4)", file_types=["video"])
+            load_button = gr.Button("Load Video", variant="primary")
+        with gr.Column(scale=1):
+            video_status = gr.Textbox(
+                label="Video Load Status",
+                value="Please upload a video file or ensure 'sample.mp4' exists in the root directory.",
+                interactive=False
+            )
 
-    # Toggles for service categories
+    # Toggles for service categories with status indicators
     with gr.Row():
         with gr.Column():
-            uc_toggle = gr.Checkbox(label="Enable Under Construction Services", value=service_toggles["under_construction"])
-            uc_status = gr.Textbox(label="Under Construction Status", value="Under Construction Services: Disabled")
+            uc_toggle = gr.Checkbox(label="Enable Under Construction Services", value=False)
+            uc_status = gr.Textbox(label="Under Construction Status", value="Disabled", interactive=False)
         with gr.Column():
-            om_toggle = gr.Checkbox(label="Enable Operations Maintenance Services", value=service_toggles["operations_maintenance"])
-            om_status = gr.Textbox(label="Operations Maintenance Status", value="Operations Maintenance Services: Disabled")
+            om_toggle = gr.Checkbox(label="Enable Operations Maintenance Services", value=False)
+            om_status = gr.Textbox(label="Operations Maintenance Status", value="Disabled", interactive=False)
         with gr.Column():
-            rs_toggle = gr.Checkbox(label="Enable Road Safety Services", value=service_toggles["road_safety"])
-            rs_status = gr.Textbox(label="Road Safety Status", value="Road Safety Services: Disabled")
+            rs_toggle = gr.Checkbox(label="Enable Road Safety Services", value=False)
+            rs_status = gr.Textbox(label="Road Safety Status", value="Disabled", interactive=False)
         with gr.Column():
-            pl_toggle = gr.Checkbox(label="Enable Plantation Services", value=service_toggles["plantation"])
-            pl_status = gr.Textbox(label="Plantation Status", value="Plantation Services: Disabled")
+            pl_toggle = gr.Checkbox(label="Enable Plantation Services", value=False)
+            pl_status = gr.Textbox(label="Plantation Status", value="Disabled", interactive=False)
 
     status_text = gr.Markdown("**Status:** 🟢 Ready (Upload a video to start)")
 
     with gr.Row():
         with gr.Column(scale=3):
-            video_output = gr.Image(label="Live Drone Feed", width=640, height=480)
+            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(label="Detection Metrics", lines=4)
+            detections_output = gr.Textbox(label="Detection Metrics", lines=4, interactive=False)
 
     with gr.Row():
-        logs_output = gr.Textbox(label="Live Logs", lines=8)
+        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")
-            pie_output = gr.Plot(label="Crack Severity")
+            chart_output = gr.Plot(label="Crack Trend (Operations Maintenance Only)")
+            pie_output = gr.Plot(label="Crack Severity (Operations Maintenance Only)")
 
     with gr.Row():
-        captured_images = gr.Gallery(label="Detected Cracks (Last 100+)", columns=4, rows=25)
+        captured_images = gr.Gallery(label="Detected Frames (Last 100+)", columns=4, rows=25, height="auto")
 
     with gr.Row():
-        pause_btn = gr.Button("⏸️ Pause")
-        resume_btn = gr.Button("▶️ Resume")
-        frame_slider = gr.Slider(0.0005, 5, value=0.5, label="Frame Interval (seconds)")
+        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)
+
+    # Add some custom CSS for better UX
+    gr.HTML("""
+    <style>
+        #live-feed {
+            border: 2px solid #4682B4;
+            border-radius: 10px;
+        }
+        .gr-button-primary {
+            background-color: #4682B4 !important;
+        }
+        .gr-button-secondary {
+            background-color: #FF6347 !important;
+        }
+    </style>
+    """)
 
     def toggle_pause():
         global paused
@@ -483,26 +468,23 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
         outputs=[video_status]
     )
 
-    uc_toggle.change(
-        toggle_service,
-        inputs=[gr.State("under_construction"), uc_toggle],
-        outputs=[uc_status]
-    )
-    om_toggle.change(
-        toggle_service,
-        inputs=[gr.State("operations_maintenance"), om_toggle],
-        outputs=[om_status]
-    )
-    rs_toggle.change(
-        toggle_service,
-        inputs=[gr.State("road_safety"), rs_toggle],
-        outputs=[rs_status]
-    )
-    pl_toggle.change(
-        toggle_service,
-        inputs=[gr.State("plantation"), pl_toggle],
-        outputs=[pl_status]
-    )
+    # Toggle change events
+    def update_toggles(uc_val, om_val, rs_val, pl_val):
+        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"
+        rs_status_val = "Enabled" if active == "road_safety" else "Disabled"
+        pl_status_val = "Enabled" if active == "plantation" else "Disabled"
+        return (
+            uc_status_val, om_status_val, rs_status_val, pl_status_val, status_message
+        )
+
+    toggle_inputs = [uc_toggle, om_toggle, rs_toggle, pl_toggle]
+    toggle_outputs = [uc_status, om_status, rs_status, pl_status, status_text]
+    uc_toggle.change(update_toggles, inputs=toggle_inputs, outputs=toggle_outputs)
+    om_toggle.change(update_toggles, inputs=toggle_inputs, outputs=toggle_outputs)
+    rs_toggle.change(update_toggles, inputs=toggle_inputs, outputs=toggle_outputs)
+    pl_toggle.change(update_toggles, inputs=toggle_inputs, outputs=toggle_outputs)
 
     pause_btn.click(toggle_pause, outputs=status_text)
     resume_btn.click(toggle_resume, outputs=status_text)