Update app.py

app.py

@@ -1,597 +1,102 @@
-import cv2
-import torch
 import gradio as gr
+import cv2
 import numpy as np
-import os
-import json
-import logging
-import matplotlib.pyplot as plt
-import csv
-import time
-from datetime import datetime
-from collections import Counter
-from typing import List, Dict, Any, Optional
 from ultralytics import YOLO
-import piexif
-import zipfile
-import base64
-
-os.environ["YOLO_CONFIG_DIR"] = "/tmp/Ultralytics"
-logging.basicConfig(filename="app.log", level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-
-CAPTURED_FRAMES_DIR = "captured_frames"
-OUTPUT_DIR = "outputs"
-FLIGHT_LOG_DIR = "flight_logs"
-os.makedirs(CAPTURED_FRAMES_DIR, exist_ok=True)
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-os.makedirs(FLIGHT_LOG_DIR, exist_ok=True)
-os.chmod(CAPTURED_FRAMES_DIR, 0o777)
-os.chmod(OUTPUT_DIR, 0o777)
-os.chmod(FLIGHT_LOG_DIR, 0o777)
-
-log_entries: List[str] = []
-detected_counts: List[int] = []
-detected_issues: List[str] = []
-gps_coordinates: List[List[float]] = []
-last_metrics: Dict[str, Any] = {}
-frame_count: int = 0
-SAVE_IMAGE_INTERVAL = 1
-DETECTION_CLASSES = ["Longitudinal", "Pothole", "Transverse"]
-MAX_IMAGES = 500
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model = YOLO('./data/yolo11n (2).pt').to(device)
-if device == "cuda":
-    model.half()
-
-def zip_all_outputs(report_path: str, video_path: str, chart_path: str, map_path: str) -> str:
-    zip_path = os.path.join(OUTPUT_DIR, f"drone_analysis_outputs_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip")
-    try:
-        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_STORED) as zipf:
-            if os.path.exists(report_path):
-                zipf.write(report_path, os.path.basename(report_path))
-            if os.path.exists(video_path):
-                zipf.write(video_path, os.path.join("outputs", os.path.basename(video_path)))
-            if os.path.exists(chart_path):
-                zipf.write(chart_path, os.path.join("outputs", os.path.basename(chart_path)))
-            if os.path.exists(map_path):
-                zipf.write(map_path, os.path.join("outputs", os.path.basename(map_path)))
-            for file in detected_issues:
-                if os.path.exists(file):
-                    zipf.write(file, os.path.join("captured_frames", os.path.basename(file)))
-            for root, _, files in os.walk(FLIGHT_LOG_DIR):
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    zipf.write(file_path, os.path.join("flight_logs", file))
-        log_entries.append(f"Created ZIP: {zip_path}")
-        return zip_path
-    except Exception as e:
-        log_entries.append(f"Error: Failed to create ZIP: {str(e)}")
-        return ""
-
-def generate_map(gps_coords: List[List[float]], items: List[Dict[str, Any]]) -> str:
-    map_path = os.path.join(OUTPUT_DIR, f"map_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png")
-    plt.figure(figsize=(4, 4))
-    plt.scatter([x[1] for x in gps_coords], [x[0] for x in gps_coords], c='blue', label='GPS Points')
-    plt.title("Issue Locations Map")
-    plt.xlabel("Longitude")
-    plt.ylabel("Latitude")
-    plt.legend()
-    plt.savefig(map_path)
-    plt.close()
-    return map_path
-
-def write_geotag(image_path: str, gps_coord: List[float]) -> bool:
-    try:
-        lat = abs(gps_coord[0])
-        lon = abs(gps_coord[1])
-        lat_ref = "N" if gps_coord[0] >= 0 else "S"
-        lon_ref = "E" if gps_coord[1] >= 0 else "W"
-        exif_dict = piexif.load(image_path) if os.path.exists(image_path) else {"GPS": {}}
-        exif_dict["GPS"] = {
-            piexif.GPSIFD.GPSLatitudeRef: lat_ref,
-            piexif.GPSIFD.GPSLatitude: ((int(lat), 1), (0, 1), (0, 1)),
-            piexif.GPSIFD.GPSLongitudeRef: lon_ref,
-            piexif.GPSIFD.GPSLongitude: ((int(lon), 1), (0, 1), (0, 1))
-        }
-        piexif.insert(piexif.dump(exif_dict), image_path)
-        return True
-    except Exception as e:
-        log_entries.append(f"Error: Failed to geotag {image_path}: {str(e)}")
-        return False
-
-def write_flight_log(frame_count: int, gps_coord: List[float], timestamp: str) -> str:
-    log_path = os.path.join(FLIGHT_LOG_DIR, f"flight_log_{frame_count:06d}.csv")
-    try:
-        with open(log_path, 'w', newline='') as csvfile:
-            writer = csv.writer(csvfile)
-            writer.writerow(["Frame", "Timestamp", "Latitude", "Longitude", "Speed_ms", "Satellites", "Altitude_m"])
-            writer.writerow([frame_count, timestamp, gps_coord[0], gps_coord[1], 5.0, 12, 60])
-        return log_path
-    except Exception as e:
-        log_entries.append(f"Error: Failed to write flight log {log_path}: {str(e)}")
-        return ""
-
-def check_image_quality(frame: np.ndarray, input_resolution: int) -> bool:
-    height, width, _ = frame.shape
-    frame_resolution = width * height
-    if frame_resolution < 2_073_600:
-        log_entries.append(f"Frame {frame_count}: Resolution {width}x{height} below 2MP")
-        return False
-    if frame_resolution < input_resolution:
-        log_entries.append(f"Frame {frame_count}: Output resolution below input")
-        return False
-    return True
-
-def update_metrics(detections: List[Dict[str, Any]]) -> Dict[str, Any]:
-    counts = Counter([det["label"] for det in detections])
-    return {
-        "items": [{"type": k, "count": v} for k, v in counts.items()],
-        "total_detections": len(detections),
-        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    }
-
-def generate_line_chart() -> Optional[str]:
-    if not detected_counts:
-        return None
-    plt.figure(figsize=(4, 2))
-    plt.plot(detected_counts[-50:], marker='o', color='#FF8C00')
-    plt.title("Detections Over Time")
-    plt.xlabel("Frame")
-    plt.ylabel("Count")
-    plt.grid(True)
-    plt.tight_layout()
-    chart_path = os.path.join(OUTPUT_DIR, f"chart_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png")
-    plt.savefig(chart_path)
-    plt.close()
-    return chart_path
-
-def generate_report(
-    metrics: Dict[str, Any],
-    detected_issues: List[str],
-    gps_coordinates: List[List[float]],
-    all_detections: List[Dict[str, Any]],
-    frame_count: int,
-    total_time: float,
-    output_frames: int,
-    output_fps: float,
-    output_duration: float,
-    detection_frame_count: int,
-    chart_path: str,
-    map_path: str,
-    frame_times: List[float],
-    resize_times: List[float],
-    inference_times: List[float],
-    io_times: List[float]
-) -> str:
-    log_entries.append("Generating report...")
-    report_path = os.path.join(OUTPUT_DIR, f"drone_analysis_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html")
-    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-    report_content = [
-        "<!DOCTYPE html>",
-        "<html lang='en'>",
-        "<head>",
-        "<meta charset='UTF-8'>",
-        "<title>NHAI Drone Survey Analysis Report</title>",
-        "<style>",
-        "body { font-family: Arial, sans-serif; margin: 40px; }",
-        "h1, h2, h3 { color: #333; }",
-        "ul { margin-left: 20px; }",
-        "table { border-collapse: collapse; width: 100%; margin: 10px 0; }",
-        "th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }",
-        "th { background-color: #f2f2f2; }",
-        "img { max-width: 600px; height: auto; margin: 10px 0; }",
-        "p.caption { font-weight: bold; margin: 5px 0; }",
-        "</style>",
-        "</head>",
-        "<body>",
-        "<h1>NHAI Drone Survey Analysis Report</h1>",
-        "",
-        "<h2>Project Details</h2>",
-        "<ul>",
-        "<li><strong>Project Name:</strong> NH-44 Delhi-Hyderabad Section (Package XYZ)</li>",
-        "<li><strong>Highway Section:</strong> Km 100 to Km 150</li>",
-        "<li><strong>State:</strong> Telangana</li>",
-        "<li><strong>Region:</strong> South</li>",
-        f"<li><strong>Survey Date:</strong> {datetime.now().strftime('%Y-%m-%d')}</li>",
-        "<li><strong>Drone Service Provider:</strong> ABC Drone Services Pvt. Ltd.</li>",
-        "<li><strong>Technology Service Provider:</strong> XYZ AI Analytics Ltd.</li>",
-        f"<li><strong>Work Order Reference:</strong> Data Lake WO-{datetime.now().strftime('%Y-%m-%d')}-XYZ</li>",
-        "<li><strong>Report Prepared By:</strong> Nagasurendra, Data Analyst</li>",
-        f"<li><strong>Report Date:</strong> {datetime.now().strftime('%Y-%m-%d')}</li>",
-        "</ul>",
-        "",
-        "<h2>1. Introduction</h2>",
-        "<p>This report consolidates drone survey results for NH-44 (Km 100–150) under Operations & Maintenance, per NHAI Policy Circular No. 18.98/2024, detecting potholes and cracks using YOLOv8 for Monthly Progress Report integration.</p>",
-        "",
-        "<h2>2. Drone Survey Metadata</h2>",
-        "<ul>",
-        "<li><strong>Drone Speed:</strong> 5 m/s</li>",
-        "<li><strong>Drone Height:</strong> 60 m</li>",
-        "<li><strong>Camera Sensor:</strong> RGB, 12 MP</li>",
-        "<li><strong>Recording Type:</strong> JPEG, 90° nadir</li>",
-        "<li><strong>Image Overlap:</strong> 85%</li>",
-        "<li><strong>Flight Pattern:</strong> Single lap, ROW centered</li>",
-        "<li><strong>Geotagging:</strong> Enabled</li>",
-        "<li><strong>Satellite Lock:</strong> 12 satellites</li>",
-        "<li><strong>Terrain Follow Mode:</strong> Enabled</li>",
-        "</ul>",
-        "",
-        "<h2>3. Quality Check Results</h2>",
-        "<ul>",
-        "<li><strong>Resolution:</strong> 1920x1080</li>",
-        "<li><strong>Overlap:</strong> 85%</li>",
-        "<li><strong>Camera Angle:</strong> 90° nadir</li>",
-        "<li><strong>Drone Speed:</strong> ≤ 5 m/s</li>",
-        "<li><strong>Geotagging:</strong> 100% compliant</li>",
-        "<li><strong>QC Status:</strong> Passed</li>",
-        "</ul>",
-        "",
-        "<h2>4. AI/ML Analytics</h2>",
-        f"<p><strong>Total Frames Processed:</strong> {frame_count}</p>",
-        f"<p><strong>Detection Frames:</strong> {detection_frame_count} ({detection_frame_count/frame_count*100:.1f}%)</p>",
-        f"<p><strong>Total Detections:</strong> {metrics['total_detections']}</p>",
-        "<p><strong>Breakdown:</strong></p>",
-        "<ul>"
-    ]
-
-    for item in metrics.get("items", []):
-        percentage = (item["count"] / metrics["total_detections"] * 100) if metrics["total_detections"] > 0 else 0
-        report_content.append(f"<li>{item['type']}: {item['count']} ({percentage:.1f}%)</li>")
-    report_content.extend([
-        "</ul>",
-        f"<p><strong>Processing Time:</strong> {total_time:.1f} seconds</p>",
-        f"<p><strong>Average Frame Time:</strong> {sum(frame_times)/len(frame_times):.1f} ms</p>" if frame_times else "<p><strong>Average Frame Time:</strong> N/A</p>",
-        f"<p><strong>Average Resize Time:</strong> {sum(resize_times)/len(resize_times):.1f} ms</p>" if resize_times else "<p><strong>Average Resize Time:</strong> N/A</p>",
-        f"<p><strong>Average Inference Time:</strong> {sum(inference_times)/len(inference_times):.1f} ms</p>" if inference_times else "<p><strong>Average Inference Time:</strong> N/A</p>",
-        f"<p><strong>Average I/O Time:</strong> {sum(io_times)/len(io_times):.1f} ms</p>" if io_times else "<p><strong>Average I/O Time:</strong> N/A</p>",
-        f"<p><strong>Timestamp:</strong> {metrics.get('timestamp', 'N/A')}</p>",
-        "<p><strong>Summary:</strong> Potholes and cracks detected in high-traffic areas.</p>",
-        "",
-        "<h2>5. Output File Structure</h2>",
-        "<p>ZIP file contains:</p>",
-        "<ul>",
-        f"<li><code>drone_analysis_report_{timestamp}.html</code>: This report</li>",
-        "<li><code>outputs/processed_output.mp4</code>: Processed video with annotations</li>",
-        f"<li><code>outputs/chart_{timestamp}.png</code>: Detection trend chart</li>",
-        f"<li><code>outputs/map_{timestamp}.png</code>: Issue locations map</li>",
-        "<li><code>captured_frames/detected_&lt;frame&gt;.jpg</code>: Geotagged images for detected issues</li>",
-        "<li><code>flight_logs/flight_log_&lt;frame&gt;.csv</code>: Flight logs matching image frames</li>",
-        "</ul>",
-        "<p><strong>Note:</strong> Images and logs share frame numbers (e.g., <code>detected_000001.jpg</code> corresponds to <code>flight_log_000001.csv</code>).</p>",
-        "",
-        "<h2>6. Geotagged Images</h2>",
-        f"<p><strong>Total Images:</strong> {len(detected_issues)}</p>",
-        f"<p><strong>Storage:</strong> Data Lake <code>/project_xyz/images/{datetime.now().strftime('%Y%m%d')}</code></p>",
-        "",
-        "<table>",
-        "<tr><th>Frame</th><th>Issue Type</th><th>GPS (Lat, Lon)</th><th>Timestamp</th><th>Confidence</th><th>Image Path</th></tr>"
-    ])
-
-    for detection in all_detections[:100]:
-        report_content.append(
-            f"<tr><td>{detection['frame']:06d}</td><td>{detection['label']}</td><td>({detection['gps'][0]:.6f}, {detection['gps'][1]:.6f})</td><td>{detection['timestamp']}</td><td>{detection['conf']:.1f}</td><td>captured_frames/{os.path.basename(detection['path'])}</td></tr>"
-        )
-
-    report_content.extend([
-        "</table>",
-        "",
-        "<h2>7. Flight Logs</h2>",
-        f"<p><strong>Total Logs:</strong> {len(detected_issues)}</p>",
-        f"<p><strong>Storage:</strong> Data Lake <code>/project_xyz/flight_logs/{datetime.now().strftime('%Y%m%d')}</code></p>",
-        "",
-        "<table>",
-        "<tr><th>Frame</th><th>Timestamp</th><th>Latitude</th><th>Longitude</th><th>Speed (m/s)</th><th>Satellites</th><th>Altitude (m)</th><th>Log Path</th></tr>"
-    ])
-
-    for detection in all_detections[:100]:
-        log_path = f"flight_logs/flight_log_{detection['frame']:06d}.csv"
-        report_content.append(
-            f"<tr><td>{detection['frame']:06d}</td><td>{detection['timestamp']}</td><td>{detection['gps'][0]:.6f}</td><td>{detection['gps'][1]:.6f}</td><td>5.0</td><td>12</td><td>60</td><td>{log_path}</td></tr>"
-        )
-
-    report_content.extend([
-        "</table>",
-        "",
-        "<h2>8. Processed Video</h2>",
-        f"<p><strong>Path:</strong> outputs/processed_output.mp4</p>",
-        f"<p><strong>Frames:</strong> {output_frames}</p>",
-        f"<p><strong>FPS:</strong> {output_fps:.1f}</p>",
-        f"<p><strong>Duration:</strong> {output_duration:.1f} seconds</p>",
-        "",
-        "<h2>9. Visualizations</h2>",
-        f"<p><strong>Detection Trend Chart:</strong> outputs/chart_{timestamp}.png</p>",
-        f"<p><strong>Issue Locations Map:</strong> outputs/map_{timestamp}.png</p>",
-        "",
-        "<h2>10. Processing Timestamps</h2>",
-        f"<p><strong>Total Processing Time:</strong> {total_time:.1f} seconds</p>",
-        "<p><strong>Log Entries (Last 10):</strong></p>",
-        "<ul>"
-    ])
-
-    for entry in log_entries[-10:]:
-        report_content.append(f"<li>{entry}</li>")
-
-    report_content.extend([
-        "</ul>",
-        "",
-        "<h2>11. Stakeholder Validation</h2>",
-        "<ul>",
-        "<li><strong>AE/IE Comments:</strong> [Pending]</li>",
-        "<li><strong>PD/RO Comments:</strong> [Pending]</li>",
-        "</ul>",
-        "",
-        "<h2>12. Recommendations</h2>",
-        "<ul>",
-        "<li>Repair potholes in high-traffic areas.</li>",
-        "<li>Seal cracks to prevent further degradation.</li>",
-        "<li>Schedule a follow-up survey.</li>",
-        "</ul>",
-        "",
-        "<h2>13. Data Lake References</h2>",
-        "<ul>",
-        f"<li><strong>Images:</strong> <code>/project_xyz/images/{datetime.now().strftime('%Y%m%d')}</code></li>",
-        f"<li><strong>Flight Logs:</strong> <code>/project_xyz/flight_logs/{datetime.now().strftime('%Y%m%d')}</code></li>",
-        f"<li><strong>Video:</strong> <code>/project_xyz/videos/processed_output_{timestamp}.mp4</code></li>",
-        f"<li><strong>DAMS Dashboard:</strong> <code>/project_xyz/dams/{datetime.now().strftime('%Y%m%d')}</code></li>",
-        "</ul>",
-        "",
-        "<h2>14. Captured Images</h2>",
-        "<p>Below are the embedded images from the captured frames directory showing detected issues:</p>",
-        ""
-    ])
-
-    for image_path in detected_issues:
-        if os.path.exists(image_path):
-            image_name = os.path.basename(image_path)
-            try:
-                with open(image_path, "rb") as image_file:
-                    base64_string = base64.b64encode(image_file.read()).decode('utf-8')
-                report_content.append(f"<img src='data:image/jpeg;base64,{base64_string}' alt='{image_name}'>")
-                report_content.append(f"<p class='caption'>Image: {image_name}</p>")
-                report_content.append("")
-            except Exception as e:
-                log_entries.append(f"Error: Failed to encode image {image_name} to base64: {str(e)}")
-
-    report_content.extend([
-        "</body>",
-        "</html>"
-    ])
-
-    try:
-        with open(report_path, 'w') as f:
-            f.write("\n".join(report_content))
-        log_entries.append(f"Report saved at: {report_path}")
-        return report_path
-    except Exception as e:
-        log_entries.append(f"Error: Failed to save report: {str(e)}")
-        return ""
-
-def process_video(video, resize_width=1920, resize_height=1080, frame_skip=10):
-    global frame_count, last_metrics, detected_counts, detected_issues, gps_coordinates, log_entries
-    frame_count = 0
-    detected_counts.clear()
-    detected_issues.clear()
-    gps_coordinates.clear()
-    log_entries.clear()
-    last_metrics = {}
-
-    if video is None:
-        log_entries.append("Error: No video uploaded")
-        return None, json.dumps({"error": "No video uploaded"}, indent=2), "\n".join(log_entries), [], None, None, None
-
-    log_entries.append("Starting video processing...")
-    start_time = time.time()
-    cap = cv2.VideoCapture(video)
+import os
+import tempfile
+from moviepy.editor import ImageSequenceClip
+from PIL import Image
+
+# Load both YOLO models
+model_yolo11 = YOLO('./data/yolo11n.pt')
+model_best = YOLO('./data/best.pt')
+
+def process_video(video_path, model_name, conf_threshold=0.4):
+    """
+    Process the input video frame by frame using the selected YOLO model,
+    draw bounding boxes, and return the processed video path.
+    """
+    # Select model based on user input
+    model = model_yolo11 if model_name == "YOLO11n" else model_best
+
+    # Open video capture
+    cap = cv2.VideoCapture(video_path)
     if not cap.isOpened():
-        log_entries.append("Error: Could not open video file")
-        return None, json.dumps({"error": "Could not open video file"}, indent=2), "\n".join(log_entries), [], None, None, None
+        raise ValueError("Could not open video file")
 
-    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    input_resolution = frame_width * frame_height
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    log_entries.append(f"Input video: {frame_width}x{frame_height} at {fps} FPS, {total_frames} frames")
+    # Get video properties
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
-    out_width, out_height = resize_width, resize_height
-    output_path = os.path.join(OUTPUT_DIR, "processed_output.mp4")
-    out = cv2.VideoWriter(output_path, cv2.VideoWriter_fourcc(*'XVID'), fps, (out_width, out_height))
-    if not out.isOpened():
-        log_entries.append("Error: Failed to initialize video writer")
-        cap.release()
-        return None, json.dumps({"error": "Video writer failed"}, indent=2), "\n".join(log_entries), [], None, None, None
+    # Store processed frames
+    processed_frames = []
 
-    processed_frames = 0
-    all_detections = []
-    frame_times = []
-    inference_times = []
-    resize_times = []
-    io_times = []
-    detection_frame_count = 0
-    output_frame_count = 0
-    last_annotated_frame = None
-    disk_space_threshold = 1024 * 1024 * 1024
-
-    while True:
+    while cap.isOpened():
         ret, frame = cap.read()
         if not ret:
             break
-        frame_count += 1
-        if frame_count % frame_skip != 0:
-            continue
-        processed_frames += 1
-        frame_start = time.time()
-
-        if os.statvfs(os.path.dirname(output_path)).f_frsize * os.statvfs(os.path.dirname(output_path)).f_bavail < disk_space_threshold:
-            log_entries.append("Error: Insufficient disk space")
-            break
-
-        frame = cv2.resize(frame, (out_width, out_height))
-        resize_times.append((time.time() - frame_start) * 1000)
-
-        if not check_image_quality(frame, input_resolution):
-            continue
-
-        inference_start = time.time()
-        results = model(frame, verbose=False, conf=0.5, iou=0.7)
-        annotated_frame = results[0].plot()
-        inference_times.append((time.time() - inference_start) * 1000)
-
-        frame_timestamp = frame_count / fps if fps > 0 else 0
-        timestamp_str = f"{int(frame_timestamp // 60):02d}:{int(frame_timestamp % 60):02d}"
-
-        gps_coord = [17.385044 + (frame_count * 0.0001), 78.486671 + (frame_count * 0.0001)]
-        gps_coordinates.append(gps_coord)
-
-        io_start = time.time()
-        frame_detections = []
-        for detection in results[0].boxes:
-            cls = int(detection.cls)
-            conf = float(detection.conf)
-            box = detection.xyxy[0].cpu().numpy().astype(int).tolist()
-            label = model.names[cls]
-            if label in DETECTION_CLASSES:
-                detection_data = {
-                    "label": label,
-                    "box": box,
-                    "conf": conf,
-                    "gps": gps_coord,
-                    "timestamp": timestamp_str,
-                    "frame": frame_count,
-                    "path": os.path.join(CAPTURED_FRAMES_DIR, f"detected_{frame_count:06d}.jpg")
-                }
-                frame_detections.append(detection_data)
-                log_entries.append(f"Frame {frame_count} at {timestamp_str}: Detected {label} with confidence {conf:.2f}")
-
-        if frame_detections:
-            detection_frame_count += 1
-            if detection_frame_count % SAVE_IMAGE_INTERVAL == 0:
-                captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"detected_{frame_count:06d}.jpg")
-                if cv2.imwrite(captured_frame_path, annotated_frame):
-                    if write_geotag(captured_frame_path, gps_coord):
-                        detected_issues.append(captured_frame_path)
-                        if len(detected_issues) > MAX_IMAGES:
-                            os.remove(detected_issues.pop(0))
-                    else:
-                        log_entries.append(f"Frame {frame_count}: Geotagging failed")
-                else:
-                    log_entries.append(f"Error: Failed to save frame at {captured_frame_path}")
-                write_flight_log(frame_count, gps_coord, timestamp_str)
-
-        io_times.append((time.time() - io_start) * 1000)
-
-        out.write(annotated_frame)
-        output_frame_count += 1
-        last_annotated_frame = annotated_frame
-        if frame_skip > 1:
-            for _ in range(frame_skip - 1):
-                out.write(annotated_frame)
-                output_frame_count += 1
-
-        detected_counts.append(len(frame_detections))
-        all_detections.extend(frame_detections)
-
-        frame_times.append((time.time() - frame_start) * 1000)
-        if len(log_entries) > 50:
-            log_entries.pop(0)
-
-        if time.time() - start_time > 600:
-            log_entries.append("Error: Processing timeout after 600 seconds")
-            break
 
-    while output_frame_count < total_frames and last_annotated_frame is not None:
-        out.write(last_annotated_frame)
-        output_frame_count += 1
+        # Perform object detection
+        results = model.predict(
+            source=frame,
+            conf=conf_threshold,
+            imgsz=640,
+            show_labels=True,
+            show_conf=True
+        )
 
-    last_metrics = update_metrics(all_detections)
+        # Draw bounding boxes on the frame
+        for result in results:
+            im_array = result.plot()  # Plot bounding boxes
+            processed_frames.append(im_array[..., ::-1])  # Convert BGR to RGB
 
-    out.release()
     cap.release()
 
-    cap = cv2.VideoCapture(output_path)
-    if not cap.isOpened():
-        log_entries.append("Error: Failed to open output video for verification")
-        output_path = None
-    else:
-        output_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        output_fps = cap.get(cv2.CAP_PROP_FPS)
-        output_duration = output_frames / output_fps if output_fps > 0 else 0
-        cap.release()
-        log_entries.append(f"Output video: {output_frames} frames, {output_fps:.2f} FPS, {output_duration:.2f} seconds")
-
-    total_time = time.time() - start_time
-    log_entries.append(f"Processing completed in {total_time:.2f} seconds")
-
-    chart_path = generate_line_chart()
-    map_path = generate_map(gps_coordinates[-5:], all_detections)
-    report_path = generate_report(
-        last_metrics,
-        detected_issues,
-        gps_coordinates,
-        all_detections,
-        frame_count,
-        total_time,
-        output_frames,
-        output_fps,
-        output_duration,
-        detection_frame_count,
-        chart_path,
-        map_path,
-        frame_times,
-        resize_times,
-        inference_times,
-        io_times
-    )
-    output_zip_path = zip_all_outputs(report_path, output_path, chart_path, map_path)
-
-    return (
-        output_path,
-        json.dumps(last_metrics, indent=2),
-        "\n".join(log_entries[-10:]),
-        detected_issues,
-        chart_path,
-        map_path,
-        output_zip_path
-    )
-
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="orange")) as iface:
-    gr.Markdown("# NHAI Road Defect Detection Dashboard")
+    # Save processed frames to a temporary video file
+    temp_video_path = os.path.join(tempfile.gettempdir(), "output.mp4")
+    clip = ImageSequenceClip(processed_frames, fps=fps)
+    clip.write_videofile(temp_video_path, codec='libx264')
+
+    return temp_video_path
+
+# Define Gradio interface
+with gr.Blocks() as app:
+    gr.HTML("""
+        <h1 style='text-align: center'>
+            Video Object Detection with YOLO Models
+        </h1>
+    """)
+    
     with gr.Row():
-        with gr.Column(scale=3):
+        with gr.Column():
             video_input = gr.Video(label="Upload Video")
-            width_slider = gr.Slider(320, 1920, value=1920, label="Output Width", step=1)
-            height_slider = gr.Slider(240, 1080, value=1080, label="Output Height", step=1)
-            skip_slider = gr.Slider(1, 20, value=10, label="Frame Skip", step=1)
-            process_btn = gr.Button("Process Video", variant="primary")
-        with gr.Column(scale=1):
-            metrics_output = gr.Textbox(label="Detection Metrics", lines=5, interactive=False)
-    with gr.Row():
-        video_output = gr.Video(label="Processed Video")
-        issue_gallery = gr.Gallery(label="Detected Issues", columns=4, height="auto", object_fit="contain")
-    with gr.Row():
-        chart_output = gr.Image(label="Detection Trend")
-        map_output = gr.Image(label="Issue Locations Map")
-    with gr.Row():
-        logs_output = gr.Textbox(label="Logs", lines=5, interactive=False)
-    with gr.Row():
-        gr.Markdown("## Download Results")
-    with gr.Row():
-        output_zip_download = gr.File(label="Download All Outputs (ZIP)")
-
-    process_btn.click(
+            model_choice = gr.Dropdown(
+                choices=["YOLO11n", "Best Model"],
+                label="Select Model",
+                value="YOLO11n"
+            )
+            conf_threshold = gr.Slider(
+                label="Confidence Threshold",
+                minimum=0.0,
+                maximum=1.0,
+                step=0.05,
+                value=0.4
+            )
+            process_button = gr.Button("Process Video")
+        
+        with gr.Column():
+            video_output = gr.Video(
+                label="Processed Video",
+                streaming=True,
+                autoplay=True
+            )
+
+    process_button.click(
         fn=process_video,
-        inputs=[video_input, width_slider, height_slider, skip_slider],
-        outputs=[
-            video_output,
-            metrics_output,
-            logs_output,
-            issue_gallery,
-            chart_output,
-            map_output,
-            output_zip_download
-        ]
+        inputs=[video_input, model_choice, conf_threshold],
+        outputs=[video_output]
     )
 
 if __name__ == "__main__":
-    iface.launch()
+    app.launch()