Update app.py

app.py

@@ -36,6 +36,7 @@ last_metrics: Dict[str, Any] = {}
 frame_count: int = 0
 SAVE_IMAGE_INTERVAL = 1
 DETECTION_CLASSES = ["Longitudinal", "Pothole", "Transverse"]
+MAX_IMAGES = 500  # Limit saved images to reduce ZIP time
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
 model = YOLO('./data/best.pt').to(device)
@@ -45,7 +46,7 @@ if device == "cuda":
 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_DEFLATED) as zipf:
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_STORED) as zipf:  # Use ZIP_STORED for faster compression
             if os.path.exists(report_path):
                 zipf.write(report_path, os.path.basename(report_path))
             if os.path.exists(video_path):
@@ -113,154 +114,8 @@ def write_flight_log(frame_count: int, gps_coord: List[float], timestamp: str) -
 def check_image_quality(frame: np.ndarray, input_resolution: int) -> bool:
     height, width, _ = frame.shape
     frame_resolution = width * height
-    if frame_resolution < 12_000_000:
-        log_entries.append(f"Frame {frame_count}: Resolution {width}x{height} below 12MP")
-        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
-
-import cv2
-import torch
-import gradio as gr
-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
-
-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"]
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model = YOLO('./data/best.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_DEFLATED) 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 < 12_000_000:
-        log_entries.append(f"Frame {frame_count}: Resolution {width}x{height} below 12MP")
+    if frame_resolution < 2_073_600:  # 1920x1080 minimum
+        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")
@@ -341,7 +196,7 @@ def generate_report(
         "- Terrain Follow Mode: Enabled",
         "",
         "## 3. Quality Check Results",
-        f"- Resolution: 4000x3000 (12 MP)",
+        f"- Resolution: 1920x1080",
         "- Overlap: 85%",
         "- Camera Angle: 90° nadir",
         "- Drone Speed: ≤ 5 m/s",
@@ -350,60 +205,65 @@ def generate_report(
         "",
         "## 4. AI/ML Analytics",
         f"- Total Frames Processed: {frame_count}",
-        f"- Detection Frames: {detection_frame_count} ({detection_frame_count/frame_count*100:.2f}%)",
-        f"- Total Detections: {metrics['total_detections']}",
-        "  - Breakdown:"
+        f"- Detection Frames: {detection_frame_count} ({detection_frame_count//frame_count*100:.1f}%)",
+        f"- Total Detections:: {metrics['total_detections']}",
+        "  - Breakdown:",
     ]
 
     for item in metrics.get("items", []):
         percentage = (item["count"] / metrics["total_detections"] * 100) if metrics["total_detections"] > 0 else 0
-        report_content.append(f"    - {item['type']}: {item['count']} ({percentage:.2f}%)")
+        report_content.append(f"    - {item['type']}: {item['count']} ({percentage:.1f}%)")
     report_content.extend([
-        f"- Processing Time: {total_time:.2f} seconds",
-        f"- Average Frame Time: {sum(frame_times)/len(frame_times):.2f} ms" if frame_times else "- Average Frame Time: N/A",
-        f"- Average Resize Time: {sum(resize_times)/len(resize_times):.2f} ms" if resize_times else "- Average Resize Time: N/A",
-        f"- Average Inference Time: {sum(inference_times)/len(inference_times):.2f} ms" if inference_times else "- Average Inference Time: N/A",
-        f"- Average I/O Time: {sum(io_times)/len(io_times):.2f} ms" if io_times else "- Average I/O Time: N/A",
-        f"- Timestamp: {metrics.get('timestamp', 'N/A')}",
-        "- Summary: Potholes and cracks detected in high-traffic segments.",
+        f"- Processing Time: {total_time:.1f} seconds",
+        f"- Average Frame Time: {sum(frame_times)/len(frame_times):.1f} ms" if frame_times else "- Average Frame Time: N/A",
+        f"- Average Resize Time: {sum(resize_times)/len(resize_times):.1f} ms" if resize_times else "- Average Resize Time: N/A",
+        f"- Average Inference Time: {sum(inference_times)/len(inference_times):.1f} ms" if inference_times else "- Average Inference Time: N/A",
+        f"- Average I/O Time: {sum(io_times)/len(io_times):.1f} ms" if io_times else "- Average I/O Time: N/A",
+        f"- Timestamp: {metrics.get('timestamp', 'N/A')}": 'N/A'",
+        "- Summary: Potholes and cracks detected in high-traffic areas.",
         "",
         "## 5. Output File Structure",
         "- ZIP file contains:",
-        "  - `drone_analysis_report_<timestamp>.md`: This report",
-        "  - `outputs/processed_output.mp4`: Processed video with annotations",
-        "  - `outputs/chart_<timestamp>.png`: Detection trend chart",
-        "  - `outputs/map_<timestamp>.png`: Issue locations map",
-        "  - `captured_frames/detected_<frame>.jpg`: Geotagged images for detected issues",
-        "  - `flight_logs/flight_log_<frame>.csv`: Flight logs matching image frames",
-        "- Note: Images and logs share frame numbers (e.g., `detected_000001.jpg` corresponds to `flight_log_000001.csv`).",
+        "  - `drone_analysis_report_<timestamp>.md`:): This report",
+        "  - `outputs/processed_output.mp4`:): Processed video with annotations",
+        "  - `outputs/chart_<timestamp>.jpg`:): Detection trend chart",
+        "  - `outputs/map_<timestamp>.jpg`:): Issue locations map",
+        "  - `captured_frames/detected_<frame>.jpg`:): Geotagged images for detected issues",
+        "  - `flight_logs/flight_log_<frame>.csv`:): Flight logs matching image frames",
+        "- Note: Images and logs share frame numbers (e.g., `detected_000001.jpg` corresponds to `flight_log_000001.csv`).),
+    ])
+
+    report_content.append([
+        "",
         "",
         "## 6. Geotagged Images",
         f"- Total Images: {len(detected_issues)}",
-        f"- Storage: Data Lake `/project_xyz/images/{datetime.now().strftime('%Y-%m-%d')}`",
+        f"- Storage: Data Lake `/project_xyz/images/projects/{datetime.now().strftime('%Y%m%d')}`",
         "",
-        "| Frame | Issue Type | GPS (Lat, Lon) | Timestamp | Confidence | Image Path |",
-        "|-------|------------|----------------|-----------|------------|------------|"
+        "| Frame | Issue Type | GPS (Lat, Lon) | Timestamp | | Confidence | Image Path | |",
+        "|_______|------------|----------------|-----------|------------|-----------------------------|",
     ])
 
     for detection in all_detections[:100]:
         report_content.append(
-            f"| {detection['frame']:06d} | {detection['label']} | ({detection['gps'][0]:.6f}, {detection['gps'][1]:.6f}) | {detection['timestamp']} | {detection['conf']:.2f} | captured_frames/{os.path.basename(detection['path'])} |"
+            f"""| {detection['frame']:06d} | {detection['label']} | ({detection['gps'][0]:.6f}, {detection['gps'][1]:.6f}) | {detection['timestamp']} | {detection['conf']:.1f} | captured_frames/{os.path.basename(detection['path']})} |"
         )
 
     report_content.extend([
-        "",
-        "## 7. Flight Logs",
-        f"- Total Logs: {len(detected_issues)}",
-        f"- Storage: Data Lake `/project_xyz/flight_logs/{datetime.now().strftime('%Y-%m-%d')}`",
-        "",
-        "| Frame | Timestamp | Latitude | Longitude | Speed (m/s) | Satellites | Altitude (m) | Log Path |",
-        "|-------|-----------|----------|-----------|-------------|------------|--------------|----------|"
+            "",
+            "## 7. Flight Logs",
+            f"- Total Logs: {len(detected_issues)}",
+            f"- Storage: Data Lake `/project_xyz/flight_logs/{datetime.now().strftime('%Y%m%d')}')}",
+            "",
+            "| Frame | Timestamp | Latitude | Longitude | Latitude Longitude | Speed (m/s) | Latency Satellites | ms) | Altitude |(m) | Log Path |",
+            "|-------|-----------|-----------------------------|-----------|-------------|------------|--------------|-----------------------------|",
     ])
 
     for detection in all_detections[:100]:
-        log_path = f"flight_logs/flight_log_{detection['frame']:06d}.csv"
+        log_path = f"flight_logs/flight_log_{detection['frame']}:f{06d}.csv":'
         report_content.append(
-            f"| {detection['frame']:06d} | {detection['timestamp']} | {detection['gps'][0]:.6f} | {detection['gps'][1]:.6f} | 5.0 | 12 | 60 | {log_path} |"
+            f"| {detection['frame']:06d} | {detection['timestamp']} | {detection['gps'][0]:.6f} | {detection['gps'][1]:.6f} | 5.0 |,
+| 12 | 60 | {log_path} |"
         )
 
     report_content.extend([
@@ -411,16 +271,16 @@ def generate_report(
         "## 8. Processed Video",
         f"- Path: outputs/processed_output.mp4",
         f"- Frames: {output_frames}",
-        f"- FPS: {output_fps:.2f}",
-        f"- Duration: {output_duration:.2f} seconds",
+        f"- FPS: {output_fps:.1f}",
+        f"- Duration: {output_duration:.1f} seconds",
         "",
         "## 9. Visualizations",
-        f"- Detection Trend Chart: outputs/chart_{timestamp}.png",
-        f"- Issue Locations Map: outputs/map_{timestamp}.png",
+        f"- Detection Trend Chart: outputs/chart_{timestamp}.jpg",
+        f"- Issue Locations Map: outputs/map_{timestamp}.jpg",
         "",
         "## 10. Processing Timestamps",
-        f"- Total Processing Time: {total_time:.2f} seconds",
-        "- Log Entries (Last 10):"
+        f"- Total Processing Time: {total_time:.1f} seconds",
+        "- Log Entries (Last 10):",
     ])
 
     for entry in log_entries[-10:]:
@@ -433,70 +293,84 @@ def generate_report(
         "- PD/RO Comments: [Pending]",
         "",
         "## 12. Recommendations",
-        "- Repair potholes in high-traffic segments.",
-        "- Seal cracks to prevent degradation.",
-        "- Schedule follow-up survey.",
+        "- Repair potholes potholes in high-traffic areas",
+        "- Seal cracks to prevent further degradation.",
+        "- Schedule a follow-up survey.",
         "",
         "## 13. Data Lake References",
-        f"- Images: `/project_xyz/images/{datetime.now().strftime('%Y-%m-%d')}`",
-        f"- Flight Logs: `/project_xyz/flight_logs/{datetime.now().strftime('%Y-%m-%d')}`",
-        f"- Video: `/project_xyz/videos/processed_output_{datetime.now().strftime('%Y%m%d')}.mp4`",
-        f"- DAMS Dashboard: `/project_xyz/dams/{datetime.now().strftime('%Y-%m-%d')}`"
+        f""- Images: `/project_xyz/images/{datetime.now().strftime('%Y%m%d')'}`)",
+        f""- f"- Flight Logs: `/project_xyz/flight_logs/{timestamp}`),
+        f"- Video: `/project_xyz/videos/processed_output_{timestamp}.mp4`,
+        f"- DAMS videos/processed_videos/{timestamp}/processed_video`,
+        f"- DAMS Dashboard: `/project_xyz/dams/{datetime.now().strftime('%Y%m%d')'}`)",
+        "",
+        "## 14. Captured Images",
+        "Below are the images from the captured frames directory showing detected issues:",
+        "",
     ])
 
+    # Add image references for all all captured images in in captured_frames detected_issues
+    for image_path in detected_issues:
+        if os.path.exists(image_path):
+            image_name = os.path.basename(image_path)
+            report_content.append(f"![Captured image at {image_name}](captured_frames/{image_name})")
+
     try:
-        with open(report_path, 'w') as f:
-            f.write("\n".join(report_content))
-        log_entries.append(f"Report saved: {report_path}")
+        with open(report_path, mode'w), as) as file:
+            file.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)}")
+        log_entries.append(f"Error: Failed to to save report): {str(e)}")
         return ""
+)
 
-def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
-    global frame_count, last_metrics, detected_counts, detected_issues, gps_coordinates, log_entries
+def process_video(input_video, resize_width=1920, resize_height=1080, frame_skip=10):
+    global frame_count, last_metrics_counter, detected_counts, detected_dissues, gps_coordinates,, output_log_entries
     frame_count = 0
     detected_counts.clear()
     detected_issues.clear()
     gps_coordinates.clear()
-    log_entries.clear()
-    last_metrics = {}
+    output_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
+        return None, None, None, [], None, None, None)
 
     log_entries.append("Starting video processing...")
     start_time = time.time()
     cap = cv2.VideoCapture(video)
     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
+        log_entries.append("Error: Could not open videos file")
+        return None, json.dumps({"),error": "Could not open video file"}, indent=2), None, [], None, None, None)
 
     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
+        width = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        input_resolution = frame_width * height
+        f = FPS
     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}, {fps} FPS, {total_frames} frames")
+        total_frames = int(cap.get(cv2).CAP_PRO_PROF_COUNT)
+        log_entries.append(f"Input video: {frame_width}x{height} at {fps} FPS,, {total_frames} frames")
 
-    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(*'mp4v'), fps, (out_width, out_height))
+        out_width, out_height = resize_width, resize_height
+    output_path = os.path.join(OUTPUT_DIR, str"processed_video.mp4"))
+    out = cv2.VideoWriter(output_path, cv2.VideoWriter_fourcc(*'W'XVID'), fps=20, (out_width, out_height))  # Switch to XVID
     if not out.isOpened():
-        log_entries.append("Error: Failed to initialize mp4v codec")
+        log_entries.append("Error: Failed to initialize video writer")
         cap.release()
-        return None, json.dumps({"error": "mp4v codec failed"}, indent=2), "\n".join(log_entries), [], None, None, None
+        return None, json.dumps({"error": "Video writer failed"}), None, [], None, None, None)
 
-    processed_frames = 0
+    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
+    output_frame_count = = 0
+    last_frame_detected_frame = None
+    disk_space_threshold = 1024 * 1024 * 1024  # 1GB minimum disk space
 
     while True:
         ret, frame = cap.read()
@@ -508,228 +382,10 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
         processed_frames += 1
         frame_start = time.time()
 
-        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)}:{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:
-                frame_detections.append({
-                    "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")
-                })
-                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) > 1000:  # Limit to 1000 images
-                            detected_issues.pop(0)
-                    else:
-                        log_entries.append(f"Frame {frame_count}: Geotagging failed")
-                else:
-                    log_entries.append(f"Error: Failed to save {captured_frame_path}")
-                flight_log_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
-
-    last_metrics = update_metrics(all_detections)
-
-    cap.release()
-    out.release()
-
-    cap = cv2.VideoCapture(output_path)
-    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()
-
-    total_time = time.time() - start_time
-    log_entries.append(f"Output video: {output_frames} frames, {output_fps:.2f} FPS, {output_duration:.2f} seconds")
-
-    log_entries.append("Generating chart and map...")
-    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
-    )
-
-    log_entries.append("Creating output ZIP...")
-    output_zip_path = zip_all_outputs(report_path, output_path, chart_path, map_path)
-
-    log_entries.append(f"Processing completed in {total_time:.2f} seconds")
-    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")
-    with gr.Row():
-        with gr.Column(scale=3):
-            video_input = gr.Video(label="Upload Video (12MP recommended)")
-            width_slider = gr.Slider(320, 4000, value=4000, label="Output Width", step=1)
-            height_slider = gr.Slider(240, 3000, value=3000, label="Output Height", step=1)
-            skip_slider = gr.Slider(1, 10, value=5, 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(
-        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
-        ]
-    )
-
-if __name__ == "__main__":
-    iface.launch()
-
-def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
-    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)
-    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
-
-    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}, {fps} FPS, {total_frames} frames")
-
-    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(*'mp4v'), fps, (out_width, out_height))
-    if not out.isOpened():
-        log_entries.append("Error: Failed to initialize mp4v codec")
-        cap.release()
-        return None, json.dumps({"error": "mp4v codec failed"}, indent=2), "\n".join(log_entries), [], None, None, None
-
-    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
-
-    while True:
-        ret, frame = cap.read()
-        if not ret:
+        # Check disk space
+        if os.statvfs(os.path.dirname(output_path)).f_frsize() * os.statvfs().f_bavail < disk_space_threshold:
+            log_entries.append("Error: Insufficient disk space")
             break
-        frame_count += 1
-        if frame_count % frame_skip != 0:
-            continue
-        processed_frames += 1
-        frame_start = time.time()
 
         frame = cv2.resize(frame, (out_width, out_height))
         resize_times.append((time.time() - frame_start) * 1000)
@@ -737,18 +393,18 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
         if not check_image_quality(frame, input_resolution):
             continue
 
-        inference_start = time.time()
-        results = model(frame, verbose=False, conf=0.5, iou=0.7)
+        inference_time = time.time()
+        results = model(frame, verbose=False, conf=0.5, threshold=0.7)
         annotated_frame = results[0].plot()
-        inference_times.append((time.time() - inference_start) * 1000)
+        inference_times.append((time.time() - inference_time) * 1000)
 
         frame_timestamp = frame_count / fps if fps > 0 else 0
-        timestamp_str = f"{int(frame_timestamp // 60)}:{int(frame_timestamp % 60):02d}"
+        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()
+        io_start_time = time.time()
         frame_detections = []
         for detection in results[0].boxes:
             cls = int(detection.cls)
@@ -756,37 +412,38 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
             box = detection.xyxy[0].cpu().numpy().astype(int).tolist()
             label = model.names[cls]
             if label in DETECTION_CLASSES:
-                frame_detections.append({
+                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")
-                })
+                    "path": os.path.join(CAPTURED_FRAMES_DIR, f"detected_frame_{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")
+                captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"detected_frame_{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) > 1000:  # Limit to 1000 images
-                            detected_issues.pop(0)
+                        if len(detected_issues) > MAX_IMAGES:
+                            os.remove(detected_issues.pop(0))  # Remove oldest image
                     else:
                         log_entries.append(f"Frame {frame_count}: Geotagging failed")
                 else:
-                    log_entries.append(f"Error: Failed to save {captured_frame_path}")
-                flight_log_path = write_flight_log(frame_count, gps_coord, timestamp_str)
+                    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)
+        io_times.append((time.time() - io_start_time) * 1000)
 
         out.write(annotated_frame)
         output_frame_count += 1
-        last_annotated_frame = annotated_frame
+        last_detected_frame = annotated_frame
         if frame_skip > 1:
             for _ in range(frame_skip - 1):
                 out.write(annotated_frame)
@@ -803,28 +460,32 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
             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)
+    while output_frame_count < total_frames and last_detected_frame is not None:
+        out.write(last_detected_frame)
         output_frame_count += 1
 
     last_metrics = update_metrics(all_detections)
 
-    cap.release()
     out.release()
+    cap.release()
 
+    # Verify output video
     cap = cv2.VideoCapture(output_path)
-    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()
+    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"Output video: {output_frames} frames, {output_fps:.2f} FPS, {output_duration:.2f} seconds")
+    log_entries.append(f"Processing completed in {total_time:.2f} seconds")
 
-    log_entries.append("Generating chart and map...")
     chart_path = generate_line_chart()
     map_path = generate_map(gps_coordinates[-5:], all_detections)
-
     report_path = generate_report(
         last_metrics,
         detected_issues,
@@ -843,11 +504,8 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
         inference_times,
         io_times
     )
-
-    log_entries.append("Creating output ZIP...")
     output_zip_path = zip_all_outputs(report_path, output_path, chart_path, map_path)
 
-    log_entries.append(f"Processing completed in {total_time:.2f} seconds")
     return (
         output_path,
         json.dumps(last_metrics, indent=2),
@@ -862,37 +520,41 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="orange")) as iface:
     gr.Markdown("# NHAI Road Defect Detection Dashboard")
     with gr.Row():
         with gr.Column(scale=3):
-            video_input = gr.Video(label="Upload Video (12MP recommended)")
-            width_slider = gr.Slider(320, 4000, value=4000, label="Output Width", step=1)
-            height_slider = gr.Slider(240, 3000, value=3000, label="Output Height", step=1)
-            skip_slider = gr.Slider(1, 10, value=5, label="Frame Skip", step=1)
-            process_btn = gr.Button("Process Video", variant="primary")
+            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=2)
+            process_btn = gr.Button(value"Process Video", variant="primary")
         with gr.Column(scale=1):
-            metrics_output = gr.Textbox(label="Detection Metrics", lines=5, interactive=False)
+            metrics_output = gr.Textbox(label="", 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")
+        output_video = gr.Video(label="Processed Video")
+        issue_frame_gallery = gr.Gallery(label="Detected Issues", columns=4, height="auto", object_fit="fit"contain")
     with gr.Row():
-        chart_output = gr.Image(label="Detection Trend")
-        map_output = gr.Image(label="Issue Locations Map")
+        chart_frame = gr.Image(label="Detection Trend")
+        map_frame = gr.Image(label="Issue Locations")
+    )
     with gr.Row():
-        logs_output = gr.Textbox(label="Logs", lines=5, interactive=False)
+        logs_frame = 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)")
+        zip_output_downloaded = gr.File(label="Download All Outputs")
 
     process_btn.click(
         fn=process_video,
         inputs=[video_input, width_slider, height_slider, skip_slider],
         outputs=[
-            video_output,
+            output_video,
             metrics_output,
-            logs_output,
-            issue_gallery,
-            chart_output,
-            map_output,
-            output_zip_download
+            logs_frame_output,
+            issue_frame_dgallery,
+            chart_frame_doutput,
+            maps_frame_doutput,
+            zip_output_downloads
         ]
     )