Update app.py

app.py

@@ -4,6 +4,7 @@ import time
 import os
 import json
 import random
+import logging
 from datetime import datetime
 from collections import Counter
 from services.video_service import get_next_video_frame, reset_video_index, preload_video, release_video
@@ -30,6 +31,13 @@ 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
 
+# Setup logging
+logging.basicConfig(
+    filename="app.log",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
 # Globals
 paused = False
 frame_rate = 0.5  # Process every 0.5 seconds for real-time feel
@@ -45,7 +53,7 @@ gps_coordinates = []
 video_loaded = False
 service_toggles = {
     "under_construction": False,
-    "operations_maintenance": True,  # Default to crack detection focus
+    "operations_maintenance": False,
     "road_safety": False,
     "plantation": False
 }
@@ -69,10 +77,12 @@ def initialize_video(video_file=None):
     if video_file is not None:
         video_path = video_file.name
         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
 
 def toggle_service(service_name, value):
@@ -81,17 +91,20 @@ def toggle_service(service_name, value):
     """
     global service_toggles
     service_toggles[service_name] = value
-    log_entries.append(f"{service_name.replace('_', ' ').title()} Services {'Enabled' if value else 'Disabled'}")
-    return f"{service_name.replace('_', ' ').title()} Services: {'Enabled' if value else 'Disabled'}"
+    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
 
 def monitor_feed():
     """
-    Main function to process video frames in real-time.
+    Main function to process video frames in real-time, showing only enabled service detections.
     """
     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.")
         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:
@@ -102,54 +115,140 @@ def monitor_feed():
             frame = get_next_video_frame()
         except RuntimeError as e:
             log_entries.append(f"Error: {str(e)}")
+            logging.error(f"Video Frame Error: {str(e)}")
             return None, json.dumps(last_detections, indent=2), "\n".join(log_entries[-10:]), None, None, last_detected_images
 
-        # Initialize detected items list
+        # Reset frame for overlay
+        original_frame = frame.copy()
         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
 
-        # Run services based on toggles
+        # Process enabled services
         if service_toggles["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)
+            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"]:
-            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)
+            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"]:
-            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)
+            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"]:
-            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 items detected
-        if not all_detected_items:
-            generic_dets, frame = process_generic(frame)
-            all_detected_items.extend(generic_dets)
-
-        # Optional: Run shadow detection
-        shadow_results = detect_shadows(frame)
-        shadow_dets = shadow_results["detections"]
-        frame = shadow_results["frame"]
-        all_detected_items.extend(shadow_dets)
+            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)}")
+
+        # 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
+                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())
+            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)}")
 
         # 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"]
-            frame = thermal_results["frame"]
-            all_detected_items.extend(thermal_dets)
+        if len(original_frame.shape) == 2:
+            try:
+                thermal_results = process_thermal(original_frame.copy())
+                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
+                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)
 
         # Save frame with overlays
         cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
@@ -160,7 +259,7 @@ def monitor_feed():
         gps_coordinates.append(gps_coord)
 
         # Save frame if cracks are detected (only if operations_maintenance is enabled)
-        if service_toggles["operations_maintenance"] and any(item['type'] == 'crack' for item in all_detected_items if 'type' in item):
+        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)
@@ -177,7 +276,11 @@ def monitor_feed():
         }
 
         # Dispatch to Salesforce
-        dispatch_to_salesforce(all_detections, all_detections["timestamp"])
+        try:
+            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)}")
 
         # Save annotated frame
         frame_path = os.path.join(OUTPUT_DIR, f"frame_{frame_count:04d}.jpg")
@@ -189,16 +292,17 @@ def monitor_feed():
         last_detections = metrics
 
         # Update logs and stats (focus on cracks if operations_maintenance is enabled)
-        crack_detected = 0
+        crack_detected = len(crack_items)
         if service_toggles["operations_maintenance"]:
-            crack_detected = len([item for item in all_detected_items if 'type' in item and item['type'] == 'crack'])
             crack_severity_all.extend([
                 item['severity']
-                for item in all_detected_items
-                if 'type' in item and item['type'] == 'crack' and 'severity' in item
+                for item in crack_items
+                if 'severity' in item
             ])
 
-        log_entries.append(f"{last_timestamp} - Frame {frame_count} - Cracks: {crack_detected} - Total Detections: {len(all_detected_items)} - GPS: {gps_coord} - Avg Conf: {metrics['avg_confidence']:.2f}")
+        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)
         crack_counts.append(crack_detected)
 
         if len(log_entries) > 100:
@@ -326,7 +430,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
             uc_status = gr.Textbox(label="Under Construction Status", value="Under Construction Services: Disabled")
         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: Enabled")
+            om_status = gr.Textbox(label="Operations Maintenance Status", value="Operations Maintenance Services: Disabled")
         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")