Update app.py

app.py

@@ -18,32 +18,14 @@ os.environ["YOLO_CONFIG_DIR"] = "/tmp/Ultralytics"
 # Import service modules
 try:
     from services.video_service import get_next_video_frame, reset_video_index, preload_video, release_video
-    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 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_holes
-    from services.operations_maintenance.pothole_detection import process_potholes
-    from services.operations_maintenance.signage_check import process_signages
-    # Road Safety services
-    from services.road_safety.barrier_check import process_barriers
-    from services.road_safety.lighting_check import process_lighting
-    from services.road_safety.accident_spot_check import process_accident_spots
-    from services.road_safety.pothole_crack_detection import detect_potholes_and_cracks
-    # Plantation services
-    from services.plantation.plant_count import process_plants
-    from services.plantation.plant_health import process_plant_health
-    from services.plantation.missing_patch_check import process_missing_patches
-    # General object detection
-    from services.object_detection import detect_objects
 except ImportError as e:
     print(f"Failed to import service modules: {str(e)}")
     logging.error(f"Import error: {str(e)}")
@@ -65,13 +47,13 @@ detected_counts: List[int] = []
 last_frame: Optional[np.ndarray] = None
 last_metrics: Dict[str, Any] = {}
 last_timestamp: str = ""
-detected_plants: List[str] = []  # For plants and missing patches
-detected_issues: List[str] = []  # For cracks, holes, and other issues
+detected_issues: List[str] = []
 gps_coordinates: List[List[float]] = []
 media_loaded: bool = False
 active_service: Optional[str] = None
 is_video: bool = True
 static_image: Optional[np.ndarray] = None
+enabled_services: List[str] = []
 
 # Constants
 DEFAULT_VIDEO_PATH = "sample.mp4"
@@ -83,21 +65,19 @@ TEMP_MEDIA_DIR = os.path.abspath("temp_media")
 # Ensure directories exist with write permissions
 for directory in [CAPTURED_FRAMES_DIR, OUTPUT_DIR, TEMP_MEDIA_DIR]:
     os.makedirs(directory, exist_ok=True)
-    os.chmod(directory, 0o777)  # Ensure write permissions
+    os.chmod(directory, 0o777)
 
 def initialize_media(media_file: Optional[Any] = None) -> str:
     global media_loaded, is_video, static_image, log_entries, frame_count
     release_video()
     static_image = None
-    frame_count = 0  # Reset frame count on new media load
+    frame_count = 0
 
-    # If no media file is provided, try the default video
     if media_file is None:
         media_path = DEFAULT_VIDEO_PATH
         log_entries.append(f"No media uploaded, attempting to load default: {media_path}")
         logging.info(f"No media uploaded, attempting to load default: {media_path}")
     else:
-        # Validate media file
         if not hasattr(media_file, 'name') or not media_file.name:
             status = "Error: Invalid media file uploaded."
             log_entries.append(status)
@@ -105,7 +85,6 @@ def initialize_media(media_file: Optional[Any] = None) -> str:
             media_loaded = False
             return status
 
-        # Copy the uploaded file to a known location to avoid path issues
         original_path = media_file.name
         file_extension = os.path.splitext(original_path)[1].lower()
         temp_media_path = os.path.join(TEMP_MEDIA_DIR, f"uploaded_media{file_extension}")
@@ -121,7 +100,6 @@ def initialize_media(media_file: Optional[Any] = None) -> str:
             media_loaded = False
             return status
 
-    # Verify the file exists
     if not os.path.exists(media_path):
         status = f"Error: Media file '{media_path}' not found."
         log_entries.append(status)
@@ -130,7 +108,6 @@ def initialize_media(media_file: Optional[Any] = None) -> str:
         return status
 
     try:
-        # Determine if the file is a video or image
         if file_extension in (".mp4", ".avi"):
             is_video = True
             preload_video(media_path)
@@ -161,42 +138,28 @@ def initialize_media(media_file: Optional[Any] = None) -> str:
         logging.error(status)
         return status
 
-def set_active_service(
-    service_name: str,
-    uc_val: bool,
-    om_val: bool,
-    rs_val: bool,
-    pl_val: bool
-) -> Tuple[Optional[str], str]:
-    global active_service
-    # Enable all requested services
+def set_active_service(uc_val: bool) -> Tuple[Optional[str], str]:
+    global active_service, enabled_services
     enabled_services = []
     if uc_val:
         enabled_services.append("under_construction")
-    if om_val:
-        enabled_services.append("operations_maintenance")
-    if rs_val:
-        enabled_services.append("road_safety")
-    if pl_val:
-        enabled_services.append("plantation")
 
     if not enabled_services:
         active_service = None
-        log_entries.append("No service category enabled.")
-        logging.info("No service category enabled.")
-        return None, "No Service Category Enabled"
+        log_entries.append("Under Construction service disabled.")
+        logging.info("Under Construction service disabled.")
+        return None, "No Service Enabled"
 
-    # Since multiple services are requested, we'll process all enabled services
-    active_service = "all_enabled"  # Custom state to process all enabled services
-    log_entries.append(f"Enabled services: {', '.join(enabled_services)}")
-    logging.info(f"Enabled services: {', '.join(enabled_services)}")
-    return active_service, f"Enabled: {', '.join([s.replace('_', ' ').title() for s in enabled_services])}"
+    active_service = "under_construction"
+    log_entries.append("Enabled service: Under Construction")
+    logging.info("Enabled service: Under Construction")
+    return active_service, "Enabled: Under Construction"
 
 def generate_line_chart() -> Optional[str]:
     if not detected_counts:
         return None
     fig, ax = plt.subplots(figsize=(4, 2))
-    ax.plot(detected_counts[-50:], marker='o', color='#4682B4')
+    ax.plot(detected_counts[-50:], marker='o', color='#FF8C00')
     ax.set_title("Detections Over Time")
     ax.set_xlabel("Frame")
     ax.set_ylabel("Count")
@@ -217,13 +180,12 @@ def monitor_feed() -> Tuple[
     str,
     str,
     List[str],
-    List[str],
     Optional[str],
     Optional[str]
 ]:
     global paused, frame_count, last_frame, last_metrics, last_timestamp
-    global gps_coordinates, detected_plants, detected_issues, media_loaded
-    global is_video, static_image
+    global gps_coordinates, detected_issues, media_loaded
+    global is_video, static_image, enabled_services
 
     if not media_loaded:
         log_entries.append("Cannot start processing: Media not loaded successfully.")
@@ -232,7 +194,6 @@ def monitor_feed() -> Tuple[
             None,
             json.dumps({"error": "Media not loaded. Please upload a video or image file."}, indent=2),
             "\n".join(log_entries[-10:]),
-            detected_plants,
             detected_issues,
             None,
             None
@@ -265,7 +226,6 @@ def monitor_feed() -> Tuple[
                         None,
                         json.dumps(last_metrics, indent=2),
                         "\n".join(log_entries[-10:]),
-                        detected_plants,
                         detected_issues,
                         None,
                         None
@@ -277,51 +237,23 @@ def monitor_feed() -> Tuple[
                 None,
                 json.dumps(last_metrics, indent=2),
                 "\n".join(log_entries[-10:]),
-                detected_plants,
                 detected_issues,
                 None,
                 None
             )
 
-        # Resize frame for faster detection (320x512)
         detection_frame = cv2.resize(frame, (512, 320))
-
         all_detected_items: List[Dict[str, Any]] = []
         shadow_issue = False
         thermal_flag = False
 
         try:
-            # Process all enabled services
-            # Under Construction Services
-            earthwork_dets, detection_frame = process_earthwork(detection_frame)
-            culvert_dets, detection_frame = process_culverts(detection_frame)
-            bridge_pier_dets, detection_frame = process_bridge_piers(detection_frame)
-            all_detected_items.extend(earthwork_dets + culvert_dets + bridge_pier_dets)
-
-            # Operations Maintenance Services
-            crack_hole_dets, detection_frame = detect_cracks_and_holes(detection_frame)
-            pothole_dets, detection_frame = process_potholes(detection_frame)
-            signage_dets, detection_frame = process_signages(detection_frame)
-            all_detected_items.extend(crack_hole_dets + pothole_dets + signage_dets)
-
-            # Road Safety Services
-            barrier_dets, detection_frame = process_barriers(detection_frame)
-            lighting_dets, detection_frame = process_lighting(detection_frame)
-            accident_dets, detection_frame = process_accident_spots(detection_frame)
-            pothole_crack_dets, detection_frame = detect_potholes_and_cracks(detection_frame)
-            all_detected_items.extend(barrier_dets + lighting_dets + accident_dets + pothole_crack_dets)
-
-            # Plantation Services
-            plant_dets, detection_frame = process_plants(detection_frame)
-            health_dets, detection_frame = process_plant_health(detection_frame)
-            missing_dets, detection_frame = process_missing_patches(detection_frame)
-            all_detected_items.extend(plant_dets + health_dets + missing_dets)
-
-            # General Object Detection (cars, bikes, humans, dogs, etc.)
-            object_dets, detection_frame = detect_objects(detection_frame)
-            all_detected_items.extend(object_dets)
-
-            # Apply shadow detection
+            if "under_construction" in enabled_services:
+                earthwork_dets, detection_frame = process_earthwork(detection_frame)
+                culvert_dets, detection_frame = process_culverts(detection_frame)
+                bridge_pier_dets, detection_frame = process_bridge_piers(detection_frame)
+                all_detected_items.extend(earthwork_dets + culvert_dets + bridge_pier_dets)
+
             try:
                 cv2.imwrite(TEMP_IMAGE_PATH, detection_frame)
                 shadow_issue = detect_shadow_coverage(TEMP_IMAGE_PATH)
@@ -330,7 +262,6 @@ def monitor_feed() -> Tuple[
                 logging.error(f"Error saving temp image: {str(e)}")
                 shadow_issue = False
 
-            # Apply thermal processing if frame is grayscale
             if len(detection_frame.shape) == 2:
                 thermal_results = process_thermal(detection_frame)
                 thermal_dets = thermal_results["detections"]
@@ -338,7 +269,6 @@ def monitor_feed() -> Tuple[
                 all_detected_items.extend(thermal_dets)
                 thermal_flag = bool(thermal_dets)
 
-            # Scale bounding boxes back to original frame size
             orig_h, orig_w = frame.shape[:2]
             det_h, det_w = detection_frame.shape[:2]
             scale_x, scale_y = orig_w / det_w, orig_h / det_h
@@ -352,7 +282,6 @@ def monitor_feed() -> Tuple[
                         int(box[3] * scale_y)
                     ]
 
-            # Overlay detections on the original frame with specified colors
             for item in all_detected_items:
                 box = item.get("box", [])
                 if not box:
@@ -360,43 +289,27 @@ def monitor_feed() -> Tuple[
                 x_min, y_min, x_max, y_max = box
                 label = item.get("label", "")
                 dtype = item.get("type", "")
-                health = item.get("health", "")  # For plant health
-
-                # Assign colors based on detection type as per requirements
-                if dtype == "plant":
-                    color = (255, 0, 0)  # Blue mark for plant count
-                    if health == "healthy":
-                        color = (255, 165, 0)  # Orange mark for healthy plants
-                elif dtype == "missing_patch":
-                    color = (0, 0, 255)  # Red mark for missing patches
-                elif dtype == "earthwork":
-                    color = (255, 105, 180)  # Pink for earthwork
+
+                if dtype == "earthwork":
+                    color = (255, 105, 180)  # Pink
                 elif dtype == "culvert":
-                    color = (0, 165, 255)  # Blue and orange mix (approximated)
+                    color = (0, 128, 128)  # Teal
                 elif dtype == "bridge_pier":
-                    color = (255, 99, 71)  # Light red for bridge piers
-                elif dtype == "pothole" or dtype == "hole":
-                    color = (255, 0, 0)  # Red for potholes (from pothole_detection and pothole_crack_detection)
-                elif dtype == "crack":
-                    color = (255, 105, 180)  # Pink for cracks
-                elif dtype == "signage":
-                    color = (255, 255, 0)  # Yellow for signage
-                elif dtype == "car":
-                    color = (128, 0, 128)  # Purple for cars
-                elif dtype == "bike":
-                    color = (0, 255, 255)  # Cyan for bikes
-                elif dtype == "person":
-                    color = (0, 255, 0)  # Green for humans
-                elif dtype == "dog":
-                    color = (139, 69, 19)  # Brown for dogs
+                    color = (255, 127, 127)  # Coral
                 else:
-                    color = (255, 255, 255)  # White for other objects
+                    continue
 
-                cv2.rectangle(frame, (x_min, y_min), (x_max, y_max), color, 2)
-                cv2.putText(frame, label, (x_min, y_min - 10),
-                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+                cv2.rectangle(frame, (x_min, y_min), (x_max, y_max), color, 3)
+                (text_w, text_h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
+                label_background = frame[y_min - text_h - 15:y_min - 5, x_min:x_min + text_w + 10]
+                if label_background.size > 0:
+                    overlay = label_background.copy()
+                    cv2.rectangle(overlay, (0, 0), (text_w + 10, text_h + 10), (0, 0, 0), -1)
+                    alpha = 0.5
+                    cv2.addWeighted(overlay, alpha, label_background, 1 - alpha, 0, label_background)
+                cv2.putText(frame, label, (x_min + 5, y_min - 10),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
 
-            # Save temporary image
             try:
                 cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
             except Exception as e:
@@ -408,40 +321,28 @@ def monitor_feed() -> Tuple[
             logging.error(f"Processing error: {str(e)}")
             all_detected_items = []
 
-        # Update detection metrics
         metrics = update_metrics(all_detected_items)
-
-        # Generate GPS coordinates
         gps_coord = [17.385044 + random.uniform(-0.001, 0.001), 78.486671 + frame_count * 0.0001]
         gps_coordinates.append(gps_coord)
 
-        # Add GPS to detected items for mapping
         for item in all_detected_items:
             item["gps"] = gps_coord
 
-        # 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:
                 captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"detected_{frame_count}.jpg")
-                success = cv2.imwrite(captured_frame_path, frame)
+                success = cv2.imwrite(captured_frame_path, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
                 if not success:
                     raise RuntimeError(f"Failed to save captured frame: {captured_frame_path}")
                 for item in all_detected_items:
-                    dtype = item.get("type", "")
-                    if dtype == "plant":
-                        detected_plants.append(captured_frame_path)
-                        if len(detected_plants) > 100:
-                            detected_plants.pop(0)
-                    else:
-                        detected_issues.append(captured_frame_path)
-                        if len(detected_issues) > 100:
-                            detected_issues.pop(0)
+                    detected_issues.append(captured_frame_path)
+                    if len(detected_issues) > 100:
+                        detected_issues.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 = {
             "detections": all_detected_items,
             "metrics": metrics,
@@ -452,54 +353,38 @@ def monitor_feed() -> Tuple[
             "thermal": thermal_flag
         }
 
-        # Dispatch to Salesforce
         try:
             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
         try:
             frame_path = os.path.join(OUTPUT_DIR, f"frame_{frame_count:04d}.jpg")
-            success = cv2.imwrite(frame_path, frame)
+            success = cv2.imwrite(frame_path, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
             if not success:
                 raise RuntimeError(f"Failed to save output frame: {frame_path}")
         except Exception as e:
             log_entries.append(f"Error saving output frame: {str(e)}")
             logging.error(f"Error saving output frame: {str(e)}")
 
-        # Update global variables
         frame_count += 1
-        last_timestamp = datetime.now().strftime("%Y-%m-d %H:%M:%S")
+        last_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         last_frame = frame.copy()
         last_metrics = metrics
 
-        # Track detections for metrics
-        plant_detected = len([item for item in all_detected_items if item.get("type") == "plant"])
-        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" or item.get("type") == "pothole"])
-        missing_detected = len([item for item in all_detected_items if item.get("type") == "missing_patch"])
-        car_detected = len([item for item in all_detected_items if item.get("type") == "car"])
-        bike_detected = len([item for item in all_detected_items if item.get("type") == "bike"])
-        person_detected = len([item for item in all_detected_items if item.get("type") == "person"])
-        dog_detected = len([item for item in all_detected_items if item.get("type") == "dog"])
-        detected_counts.append(plant_detected + crack_detected + hole_detected + missing_detected +
-                              car_detected + bike_detected + person_detected + dog_detected)
-
-        # Log frame processing details in the requested format
+        earthwork_detected = len([item for item in all_detected_items if item.get("type") == "earthwork"])
+        culvert_detected = len([item for item in all_detected_items if item.get("type") == "culvert"])
+        bridge_pier_detected = len([item for item in all_detected_items if item.get("type") == "bridge_pier"])
+        detected_counts.append(earthwork_detected + culvert_detected + bridge_pier_detected)
+
         processing_time = time.time() - start_time
         detection_summary = {
             "timestamp": last_timestamp,
             "frame": frame_count,
-            "plants": plant_detected,
-            "cracks": crack_detected,
-            "holes": hole_detected,
-            "missing_patches": missing_detected,
-            "cars": car_detected,
-            "bikes": bike_detected,
-            "persons": person_detected,
-            "dogs": dog_detected,
+            "earthworks": earthwork_detected,
+            "culverts": culvert_detected,
+            "bridge_piers": bridge_pier_detected,
             "gps": gps_coord,
             "processing_time_ms": processing_time * 1000
         }
@@ -507,37 +392,32 @@ def monitor_feed() -> Tuple[
         log_entries.append(log_message)
         logging.info(log_message)
 
-        # Limit the size of logs and detection data
         if len(log_entries) > 100:
             log_entries.pop(0)
         if len(detected_counts) > 500:
             detected_counts.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)
 
-    # Generate map
-    map_items = [item for item in last_metrics.get("items", []) if item.get("type") in ["crack", "hole", "pothole", "missing_patch"]]
+    map_items = [item for item in last_metrics.get("items", []) if item.get("type") in ["earthwork", "culvert", "bridge_pier"]]
     map_path = generate_map(gps_coordinates[-5:], map_items)
 
     return (
-        frame[:, :, ::-1],  # Convert BGR to RGB for Gradio
+        frame[:, :, ::-1],
         json.dumps(last_metrics, indent=2),
         "\n".join(log_entries[-10:]),
-        detected_plants,
         detected_issues,
         generate_line_chart(),
         map_path
     )
 
-# Gradio UI setup
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green")) as app:
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="orange", secondary_hue="amber")) as app:
     gr.Markdown(
         """
-        # 🛡️ NHAI Drone Road Inspection Dashboard
-        Monitor highway conditions in real-time using drone footage or static images. All services are enabled as requested.
+        # 🛠️ Under Construction Inspection Dashboard
+        Monitor under construction elements in real-time using drone footage or static images.
         """
     )
 
@@ -554,19 +434,10 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
 
     with gr.Row():
         with gr.Column():
-            uc_toggle = gr.Checkbox(label="Enable Under Construction Services", value=True)
-            uc_status = gr.Textbox(label="Under Construction Status", value="Enabled", interactive=False)
-        with gr.Column():
-            om_toggle = gr.Checkbox(label="Enable Operations Maintenance Services", value=True)
-            om_status = gr.Textbox(label="Operations Maintenance Status", value="Enabled", interactive=False)
-        with gr.Column():
-            rs_toggle = gr.Checkbox(label="Enable Road Safety Services", value=True)
-            rs_status = gr.Textbox(label="Road Safety Status", value="Enabled", interactive=False)
-        with gr.Column():
-            pl_toggle = gr.Checkbox(label="Enable Plantation Services", value=True)
-            pl_status = gr.Textbox(label="Plantation Status", value="Enabled", interactive=False)
+            uc_toggle = gr.Checkbox(label="Enable Under Construction Services", value=False)
+            uc_status = gr.Textbox(label="Under Construction Status", value="Disabled", interactive=False)
 
-    status_text = gr.Markdown("**Status:** 🟢 Ready (Upload a media file to start)")
+    status_text = gr.Markdown("**Status:** 🟢 Ready (Upload a media file and enable the service to start)")
 
     with gr.Row():
         with gr.Column(scale=3):
@@ -583,7 +454,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
         with gr.Column(scale=2):
             logs_output = gr.Textbox(label="Live Logs", lines=8, interactive=False)
         with gr.Column(scale=1):
-            plant_images = gr.Gallery(label="Detected Plants (Last 100+)", columns=4, rows=13, height="auto")
             issue_images = gr.Gallery(label="Detected Issues (Last 100+)", columns=4, rows=13, height="auto")
 
     with gr.Row():
@@ -597,12 +467,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
 
     gr.HTML("""
     <style>
+        body {
+            background-color: #FFDAB9 !important;
+        }
         #live-feed {
-            border: 2px solid #4682B4;
+            border: 2px solid #FF8C00;
             border-radius: 10px;
         }
         .gr-button-primary {
-            background-color: #4682B4 !important;
+            background-color: #FF8C00 !important;
         }
         .gr-button-secondary {
             background-color: #FF6347 !important;
@@ -632,22 +505,12 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
         outputs=[media_status]
     )
 
-    def update_toggles(uc_val: bool, om_val: bool, rs_val: bool, pl_val: bool) -> Tuple[str, str, str, str, str]:
-        active, status_message = set_active_service("toggle", uc_val, om_val, rs_val, pl_val)
-        uc_status_val = "Enabled" if "under_construction" in status_message.lower() else "Disabled"
-        om_status_val = "Enabled" if "operations_maintenance" in status_message.lower() else "Disabled"
-        rs_status_val = "Enabled" if "road_safety" in status_message.lower() else "Disabled"
-        pl_status_val = "Enabled" if "plantation" in status_message.lower() else "Disabled"
-        return (
-            uc_status_val, om_status_val, rs_status_val, pl_status_val, status_message
-        )
+    def update_toggles(uc_val: bool) -> Tuple[str, str]:
+        active, status_message = set_active_service(uc_val)
+        uc_status_val = "Enabled" if uc_val else "Disabled"
+        return uc_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)
+    uc_toggle.change(update_toggles, inputs=[uc_toggle], outputs=[uc_status, status_text])
 
     pause_btn.click(toggle_pause, outputs=status_text)
     resume_btn.click(toggle_resume, outputs=status_text)
@@ -656,19 +519,18 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"))
     def streaming_loop():
         while True:
             if not media_loaded:
-                yield None, json.dumps({"error": "Media not loaded. Please upload a video or image file."}, indent=2), "\n".join(log_entries[-10:]), detected_plants, detected_issues, None, None
+                yield None, json.dumps({"error": "Media not loaded. Please upload a video or image file."}, indent=2), "\n".join(log_entries[-10:]), detected_issues, None, None
             else:
-                frame, metrics, logs, plants, issues, chart, map_path = monitor_feed()
+                frame, metrics, logs, issues, chart, map_path = monitor_feed()
                 if frame is None:
-                    yield None, metrics, logs, plants, issues, chart, map_path
+                    yield None, metrics, logs, issues, chart, map_path
                 else:
-                    yield frame, metrics, logs, plants, issues, chart, map_path
+                    yield frame, metrics, logs, issues, chart, map_path
                 if not is_video:
-                    # For static images, yield once and pause
                     break
             time.sleep(frame_rate)
 
-    app.load(streaming_loop, outputs=[media_output, metrics_output, logs_output, plant_images, issue_images, chart_output, map_output])
+    app.load(streaming_loop, outputs=[media_output, metrics_output, logs_output, issue_images, chart_output, map_output])
 
 if __name__ == "__main__":
-    app.launch(share=True)  # Set share=True to create a public link
+    app.launch(share=True)