Update app.py

app.py

@@ -14,7 +14,6 @@ from typing import List, Dict, Any, Optional
 from ultralytics import YOLO
 import piexif
 import zipfile
-import subprocess
 
 os.environ["YOLO_CONFIG_DIR"] = "/tmp/Ultralytics"
 logging.basicConfig(filename="app.log", level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
@@ -47,57 +46,168 @@ def zip_all_outputs(report_path: str, video_path: str, chart_path: str, map_path
     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:
-            # Add report file
-            if report_path and os.path.exists(report_path):
+            if os.path.exists(report_path):
                 zipf.write(report_path, os.path.basename(report_path))
-                log_entries.append(f"Added report to ZIP: {report_path}")
-            else:
-                log_entries.append(f"Warning: Report file not found for ZIP: {report_path}")
-
-            # Add video file
-            if video_path and os.path.exists(video_path):
+            if os.path.exists(video_path):
                 zipf.write(video_path, os.path.join("outputs", os.path.basename(video_path)))
-                log_entries.append(f"Added video to ZIP: {video_path}")
-            else:
-                log_entries.append(f"Warning: Video file not found for ZIP: {video_path}")
-
-            # Add chart file
-            if chart_path and os.path.exists(chart_path):
+            if os.path.exists(chart_path):
                 zipf.write(chart_path, os.path.join("outputs", os.path.basename(chart_path)))
-                log_entries.append(f"Added chart to ZIP: {chart_path}")
-            else:
-                log_entries.append(f"Warning: Chart file not found for ZIP: {chart_path}")
-
-            # Add map file
-            if map_path and os.path.exists(map_path):
+            if os.path.exists(map_path):
                 zipf.write(map_path, os.path.join("outputs", os.path.basename(map_path)))
-                log_entries.append(f"Added map to ZIP: {map_path}")
-            else:
-                log_entries.append(f"Warning: Map file not found for ZIP: {map_path}")
-
-            # Add detected issue images
             for file in detected_issues:
                 if os.path.exists(file):
                     zipf.write(file, os.path.join("captured_frames", os.path.basename(file)))
-                    log_entries.append(f"Added image to ZIP: {file}")
-                else:
-                    log_entries.append(f"Warning: Image file not found for ZIP: {file}")
-
-            # Add flight logs
             for root, _, files in os.walk(FLIGHT_LOG_DIR):
                 for file in files:
                     file_path = os.path.join(root, file)
-                    if os.path.exists(file_path):
-                        zipf.write(file_path, os.path.join("flight_logs", file))
-                        log_entries.append(f"Added flight log to ZIP: {file_path}")
-                    else:
-                        log_entries.append(f"Warning: Flight log not found for ZIP: {file_path}")
+                    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")
+        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}")
-        if os.path.exists(zip_path):
-            log_entries.append(f"Confirmed ZIP file exists: {zip_path}")
-        else:
-            log_entries.append(f"Error: ZIP file not created: {zip_path}")
         return zip_path
     except Exception as e:
         log_entries.append(f"Error: Failed to create ZIP: {str(e)}")
@@ -198,206 +308,10 @@ def generate_report(
     inference_times: List[float],
     io_times: List[float]
 ) -> str:
-    # Generating LaTeX-based PDF report
     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')}.md")
     timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-    report_path = os.path.join(OUTPUT_DIR, f"drone_analysis_report_{timestamp}.pdf")
-    tex_path = os.path.join(OUTPUT_DIR, f"drone_analysis_report_{timestamp}.tex")
-    md_path = os.path.join(OUTPUT_DIR, f"drone_analysis_report_{timestamp}.md")  # Fallback Markdown path
-
-    # LaTeX document content
     report_content = [
-        r"\documentclass[a4paper,12pt]{article}",
-        r"\usepackage[utf8]{inputenc}",
-        r"\usepackage[T1]{fontenc}",
-        r"\usepackage{geometry}",
-        r"\geometry{margin=1in}",
-        r"\usepackage{graphicx}",
-        r"\graphicspath{{./}}",
-        r"\usepackage{booktabs}",
-        r"\usepackage{longtable}",
-        r"\usepackage{enumitem}",
-        r"\usepackage{hyperref}",
-        r"\hypersetup{colorlinks=true,linkcolor=blue,filecolor=blue,urlcolor=blue}",
-        r"\usepackage{amsmath}",
-        r"\usepackage{caption}",
-        r"\usepackage{pdfpages}",
-        r"\usepackage{times}",
-        r"\begin{document}",
-        r"\title{NHAI Drone Survey Analysis Report}",
-        r"\author{Nagasurendra, Data Analyst}",
-        r"\date{\today}",
-        r"\maketitle",
-        r"\tableofcontents",
-        r"\newpage",
-        r"\section{Project Details}",
-        r"\begin{itemize}",
-        r"\item \textbf{Project Name}: NH-44 Delhi-Hyderabad Section (Package XYZ)",
-        r"\item \textbf{Highway Section}: Km 100 to Km 150",
-        r"\item \textbf{State}: Telangana",
-        r"\item \textbf{Region}: South",
-        rf"\item \textbf{{Survey Date}}: {datetime.now().strftime('%Y-%m-%d')}",
-        r"\item \textbf{Drone Service Provider}: ABC Drone Services Pvt. Ltd.",
-        r"\item \textbf{Technology Service Provider}: XYZ AI Analytics Ltd.",
-        rf"\item \textbf{{Work Order Reference}}: Data Lake WO-{datetime.now().strftime('%Y-%m-%d')}-XYZ",
-        r"\item \textbf{Report Prepared By}: Nagasurendra, Data Analyst",
-        rf"\item \textbf{{Report Date}}: {datetime.now().strftime('%Y-%m-%d')}",
-        r"\end{itemize}",
-        r"\section{Introduction}",
-        r"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.",
-        r"\section{Drone Survey Metadata}",
-        r"\begin{itemize}",
-        r"\item \textbf{Drone Speed}: 5 m/s",
-        r"\item \textbf{Drone Height}: 60 m",
-        r"\item \textbf{Camera Sensor}: RGB, 12 MP",
-        r"\item \textbf{Recording Type}: JPEG, 90$^\circ$ nadir",
-        r"\item \textbf{Image Overlap}: 85\%",
-        r"\item \textbf{Flight Pattern}: Single lap, ROW centered",
-        r"\item \textbf{Geotagging}: Enabled",
-        r"\item \textbf{Satellite Lock}: 12 satellites",
-        r"\item \textbf terrain Follow Mode}: Enabled",
-        r"\end{itemize}",
-        r"\section{Quality Check Results}",
-        r"\begin{itemize}",
-        r"\item \textbf{Resolution}: 4000x3000 (12 MP)",
-        r"\item \textbf{Overlap}: 85\%",
-        r"\item \textbf{Camera Angle}: 90$^\circ$ nadir",
-        r"\item \textbf{Drone Speed}: $\leq$ 5 m/s",
-        r"\item \textbf{Geotagging}: 100\% compliant",
-        r"\item \textbf{QC Status}: Passed",
-        r"\end{itemize}",
-        r"\section{AI/ML Analytics}",
-        rf"Total Frames Processed: {frame_count}\par",
-        rf"Detection Frames: {detection_frame_count} ({detection_frame_count/frame_count*100:.2f}\%)\par",
-        rf"Total Detections: {metrics['total_detections']}\par",
-        r"\textbf{Breakdown:}",
-        r"\begin{itemize}"
-    ]
-
-    for item in metrics.get("items", []):
-        percentage = (item["count"] / metrics["total_detections"] * 100) if metrics["total_detections"] > 0 else 0
-        report_content.append(rf"\item {item['type']}: {item['count']} ({percentage:.2f}\%)")
-    report_content.extend([
-        r"\end{itemize}",
-        rf"Processing Time: {total_time:.2f} seconds\par",
-        rf"Average Frame Time: {sum(frame_times)/len(frame_times):.2f} ms" if frame_times else r"Average Frame Time: N/A\par",
-        rf"Average Resize Time: {sum(resize_times)/len(resize_times):.2f} ms" if resize_times else r"Average Resize Time: N/A\par",
-        rf"Average Inference Time: {sum(inference_times)/len(inference_times):.2f} ms" if inference_times else r"Average Inference Time: N/A\par",
-        rf"Average I/O Time: {sum(io_times)/len(io_times):.2f} ms" if io_times else r"Average I/O Time: N/A\par",
-        rf"Timestamp: {metrics.get('timestamp', 'N/A')}\par",
-        r"Summary: Potholes and cracks detected in high-traffic segments.\par",
-        r"\section{Output File Structure}",
-        r"\begin{itemize}",
-        rf"\item \texttt{{drone\_analysis\_report\_<{timestamp}>.pdf}}: This report",
-        r"\item \texttt{outputs/processed\_output.mp4}: Processed video with annotations",
-        rf"\item \texttt{{outputs/chart\_<{timestamp}>.png}}: Detection trend chart",
-        rf"\item \texttt{{outputs/map\_<{timestamp}>.png}}: Issue locations map",
-        r"\item \texttt{captured\_frames/detected\_<frame>.jpg}: Geotagged images for detected issues",
-        r"\item \texttt{flight\_logs/flight\_log\_<frame>.csv}: Flight logs matching image frames",
-        r"\end{itemize}",
-        r"\textbf{Note}: Images and logs share frame numbers (e.g., \texttt{detected\_000001.jpg} corresponds to \texttt{flight\_log\_000001.csv}).",
-        r"\section{Geotagged Images}",
-        rf"Total Images: {len(detected_issues)}\par",
-        rf"Storage: Data Lake \texttt{{/project\_xyz/images/{datetime.now().strftime('%Y-%m-%d')}}}\par",
-        r"\begin{longtable}{|c|l|l|l|l|l|}",
-        r"\hline",
-        r"\textbf{Frame} & \textbf{Issue Type} & \textbf{GPS (Lat, Lon)} & \textbf{Timestamp} & \textbf{Confidence} & \textbf{Image Path} \\ \hline",
-        r"\endhead"
-    ])
-
-    for detection in all_detections[:100]:
-        report_content.append(
-            rf"{detection['frame']:06d} & {detection['label']} & ({detection['gps'][0]:.6f}, {detection['gps'][1]:.6f}) & {detection['timestamp']} & {detection['conf']:.2f} & \texttt{{{os.path.basename(detection['path'])}}} \\ \hline"
-        )
-    report_content.append(r"\end{longtable}")
-
-    # Embedding geotagged images
-    report_content.append(r"\subsection{Geotagged Images Display}")
-    for detection in all_detections[:100]:
-        image_path = detection['path']
-        if os.path.exists(image_path):
-            report_content.append(rf"\begin{{figure}}[h]")
-            report_content.append(rf"\centering")
-            report_content.append(rf"\includegraphics[width=0.8\textwidth]{{{image_path}}}")
-            report_content.append(rf"\caption{{Frame {detection['frame']:06d}: {detection['label']} at ({detection['gps'][0]:.6f}, {detection['gps'][1]:.6f}), Confidence: {detection['conf']:.2f}}}")
-            report_content.append(rf"\end{{figure}}")
-
-    report_content.extend([
-        r"\section{Flight Logs}",
-        rf"Total Logs: {len(detected_issues)}\par",
-        rf"Storage: Data Lake \texttt{{/project\_xyz/flight\_logs/{datetime.now().strftime('%Y-%m-%d')}}}\par",
-        r"\begin{longtable}{|c|l|l|l|l|l|l|l|}",
-        r"\hline",
-        r"\textbf{Frame} & \textbf{Timestamp} & \textbf{Latitude} & \textbf{Longitude} & \textbf{Speed (m/s)} & \textbf{Satellites} & \textbf{Altitude (m)} & \textbf{Log Path} \\ \hline",
-        r"\endhead"
-    ])
-
-    for detection in all_detections[:100]:
-        log_path = f"flight_logs/flight_log_{detection['frame']:06d}.csv"
-        report_content.append(
-            rf"{detection['frame']:06d} & {detection['timestamp']} & {detection['gps'][0]:.6f} & {detection['gps'][1]:.6f} & 5.0 & 12 & 60 & \texttt{{{os.path.basename(log_path)}}} \\ \hline"
-        )
-    report_content.extend([
-        r"\end{longtable}",
-        r"\section{Processed Video}",
-        rf"Path: \texttt{{outputs/processed\_output.mp4}}\par",
-        rf"Frames: {output_frames}\par",
-        rf"FPS: {output_fps:.2f}\par",
-        rf"Duration: {output_duration:.2f} seconds\par",
-        r"\section{Visualizations}",
-        rf"Detection Trend Chart: \texttt{{outputs/chart\_<{timestamp}>.png}}\par",
-        rf"Issue Locations Map: \texttt{{outputs/map\_<{timestamp}>.png}}\par"
-    ])
-
-    if chart_path and os.path.exists(chart_path):
-        report_content.extend([
-            r"\begin{figure}[h]",
-            r"\centering",
-            rf"\includegraphics[width=0.8\textwidth]{{{chart_path}}}",
-            r"\caption{Detection Trend Chart}",
-            r"\end{figure}"
-        ])
-    if map_path and os.path.exists(map_path):
-        report_content.extend([
-            r"\begin{figure}[h]",
-            r"\centering",
-            rf"\includegraphics[width=0.8\textwidth]{{{map_path}}}",
-            r"\caption{Issue Locations Map}",
-            r"\end{figure}"
-        ])
-
-    report_content.extend([
-        r"\section{Processing Timestamps}",
-        rf"Total Processing Time: {total_time:.2f} seconds\par",
-        r"\textbf{Log Entries (Last 10):}",
-        r"\begin{itemize}"
-    ])
-
-    for entry in log_entries[-10:]:
-        report_content.append(rf"\item {entry}")
-    report_content.extend([
-        r"\end{itemize}",
-        r"\section{Stakeholder Validation}",
-        r"\begin{itemize}",
-        r"\item \textbf{AE/IE Comments}: Pending",
-        r"\item \textbf{PD/RO Comments}: Pending",
-        r"\end{itemize}",
-        r"\section{Recommendations}",
-        r"\begin{itemize}",
-        r"\item Repair potholes in high-traffic segments.",
-        r"\item Seal cracks to prevent degradation.",
-        r"\item Schedule follow-up survey.",
-        r"\end{itemize}",
-        r"\section{Data Lake References}",
-        rf"Images: \texttt{{/project\_xyz/images/{datetime.now().strftime('%Y-%m-%d')}}}\par",
-        rf"Flight Logs: \texttt{{/project\_xyz/flight\_logs/{datetime.now().strftime('%Y-%m-%d')}}}\par",
-        rf"Video: \texttt{{/project\_xyz/videos/processed\_output_{datetime.now().strftime('%Y%m%d')}.mp4}}\par",
-        rf"DAMS Dashboard: \texttt{{/project\_xyz/dams/{datetime.now().strftime('%Y-%m-%d')}}}\par",
-        r"\end{document}"
-    ])
-
-    # Fallback Markdown report content
-    md_report_content = [
         "# NHAI Drone Survey Analysis Report",
         "",
         "## Project Details",
@@ -443,8 +357,8 @@ def generate_report(
 
     for item in metrics.get("items", []):
         percentage = (item["count"] / metrics["total_detections"] * 100) if metrics["total_detections"] > 0 else 0
-        md_report_content.append(f"    - {item['type']}: {item['count']} ({percentage:.2f}%)")
-    md_report_content.extend([
+        report_content.append(f"    - {item['type']}: {item['count']} ({percentage:.2f}%)")
+    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",
@@ -455,10 +369,10 @@ def generate_report(
         "",
         "## 5. Output File Structure",
         "- ZIP file contains:",
-        f"  - `drone_analysis_report_{timestamp}.md`: This report (fallback due to PDF generation failure)",
+        "  - `drone_analysis_report_<timestamp>.md`: This report",
         "  - `outputs/processed_output.mp4`: Processed video with annotations",
-        f"  - `outputs/chart_{timestamp}.png`: Detection trend chart",
-        f"  - `outputs/map_{timestamp}.png`: Issue locations map",
+        "  - `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`).",
@@ -472,11 +386,11 @@ def generate_report(
     ])
 
     for detection in all_detections[:100]:
-        md_report_content.append(
+        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'])} |"
         )
 
-    md_report_content.extend([
+    report_content.extend([
         "",
         "## 7. Flight Logs",
         f"- Total Logs: {len(detected_issues)}",
@@ -488,11 +402,11 @@ def generate_report(
 
     for detection in all_detections[:100]:
         log_path = f"flight_logs/flight_log_{detection['frame']:06d}.csv"
-        md_report_content.append(
+        report_content.append(
             f"| {detection['frame']:06d} | {detection['timestamp']} | {detection['gps'][0]:.6f} | {detection['gps'][1]:.6f} | 5.0 | 12 | 60 | {log_path} |"
         )
 
-    md_report_content.extend([
+    report_content.extend([
         "",
         "## 8. Processed Video",
         f"- Path: outputs/processed_output.mp4",
@@ -510,9 +424,9 @@ def generate_report(
     ])
 
     for entry in log_entries[-10:]:
-        md_report_content.append(f"  - {entry}")
+        report_content.append(f"  - {entry}")
 
-    md_report_content.extend([
+    report_content.extend([
         "",
         "## 11. Stakeholder Validation",
         "- AE/IE Comments: [Pending]",
@@ -531,44 +445,12 @@ def generate_report(
     ])
 
     try:
-        # Writing LaTeX file
-        with open(tex_path, 'w') as f:
+        with open(report_path, 'w') as f:
             f.write("\n".join(report_content))
-        log_entries.append(f"LaTeX file saved: {tex_path}")
-
-        # Compiling LaTeX to PDF using latexmk
-        result = subprocess.run(
-            ["latexmk", "-pdf", "-interaction=nonstopmode", tex_path],
-            cwd=OUTPUT_DIR,
-            capture_output=True,
-            text=True
-        )
-        if result.returncode == 0:
-            log_entries.append(f"PDF report generated: {report_path}")
-            if os.path.exists(report_path):
-                log_entries.append(f"Confirmed report file exists: {report_path}")
-                return report_path
-            else:
-                log_entries.append(f"Error: PDF report not found at {report_path}")
-        else:
-            log_entries.append(f"Error: LaTeX compilation failed: {result.stderr}")
+        log_entries.append(f"Report saved: {report_path}")
+        return report_path
     except Exception as e:
-        log_entries.append(f"Error: Failed to generate PDF report: {str(e)}")
-
-    # Fallback: Generate Markdown report if PDF fails
-    log_entries.append("Falling back to Markdown report due to PDF generation failure")
-    try:
-        with open(md_path, 'w') as f:
-            f.write("\n".join(md_report_content))
-        log_entries.append(f"Markdown report saved: {md_path}")
-        if os.path.exists(md_path):
-            log_entries.append(f"Confirmed Markdown report file exists: {md_path}")
-            return md_path
-        else:
-            log_entries.append(f"Error: Markdown report not found at {md_path}")
-            return ""
-    except Exception as e:
-        log_entries.append(f"Error: Failed to save Markdown report: {str(e)}")
+        log_entries.append(f"Error: Failed to save report: {str(e)}")
         return ""
 
 def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
@@ -791,5 +673,228 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="orange")) as iface:
         ]
     )
 
+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:
+            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)
+
+        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()