Update app.py

app.py

@@ -11,23 +11,12 @@ from datetime import datetime
 from collections import Counter
 from typing import List, Dict, Any, Optional
 from ultralytics import YOLO
-import ultralytics
-import time
 import piexif
 import zipfile
-import shutil
 
-# Set YOLO config directory
 os.environ["YOLO_CONFIG_DIR"] = "/tmp/Ultralytics"
+logging.basicConfig(filename="app.log", level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
-# Set up logging
-logging.basicConfig(
-    filename="app.log",
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s"
-)
-
-# Directories
 CAPTURED_FRAMES_DIR = "captured_frames"
 OUTPUT_DIR = "outputs"
 FLIGHT_LOG_DIR = "flight_logs"
@@ -38,7 +27,6 @@ os.chmod(CAPTURED_FRAMES_DIR, 0o777)
 os.chmod(OUTPUT_DIR, 0o777)
 os.chmod(FLIGHT_LOG_DIR, 0o777)
 
-# Global variables
 log_entries: List[str] = []
 detected_counts: List[int] = []
 detected_issues: List[str] = []
@@ -46,27 +34,14 @@ gps_coordinates: List[List[float]] = []
 last_metrics: Dict[str, Any] = {}
 frame_count: int = 0
 SAVE_IMAGE_INTERVAL = 1
-
-# Detection classes
 DETECTION_CLASSES = ["Longitudinal", "Pothole", "Transverse"]
 
-# Debug: Check environment
-print(f"Torch version: {torch.__version__}")
-print(f"Gradio version: {gr.__version__}")
-print(f"Ultralytics version: {ultralytics.__version__}")
-print(f"CUDA available: {torch.cuda.is_available()}")
-
-# Load custom YOLO model
 device = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"Using device: {device}")
 model = YOLO('./data/best.pt').to(device)
 if device == "cuda":
     model.half()
-print(f"Model classes: {model.names}")
 
-# Function to zip all files in a directory
 def zip_directory(folder_path: str, zip_path: str) -> str:
-    """Zip all files in a directory."""
     try:
         with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
             for root, _, files in os.walk(folder_path):
@@ -80,7 +55,6 @@ def zip_directory(folder_path: str, zip_path: str) -> str:
         log_entries.append(f"Error: Failed to zip {folder_path}: {str(e)}")
         return ""
 
-# Function to generate the map of detected issues' locations
 def generate_map(gps_coords: List[List[float]], items: List[Dict[str, Any]]) -> str:
     map_path = os.path.join(OUTPUT_DIR, "map_temp.png")
     plt.figure(figsize=(4, 4))
@@ -93,7 +67,6 @@ def generate_map(gps_coords: List[List[float]], items: List[Dict[str, Any]]) ->
     plt.close()
     return map_path
 
-# Function to geotag the image with GPS coordinates
 def write_geotag(image_path: str, gps_coord: List[float]) -> bool:
     try:
         lat = abs(gps_coord[0])
@@ -114,7 +87,6 @@ def write_geotag(image_path: str, gps_coord: List[float]) -> bool:
         log_entries.append(f"Error: Failed to geotag {image_path}: {str(e)}")
         return False
 
-# Function to write flight logs
 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:
@@ -128,7 +100,17 @@ def write_flight_log(frame_count: int, gps_coord: List[float], timestamp: str) -
         log_entries.append(f"Error: Failed to write flight log {log_path}: {str(e)}")
         return ""
 
-# Function to update the metrics for detections
+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 {
@@ -137,7 +119,6 @@ def update_metrics(detections: List[Dict[str, Any]]) -> Dict[str, Any]:
         "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     }
 
-# Function to generate detection trend chart
 def generate_line_chart() -> Optional[str]:
     if not detected_counts:
         return None
@@ -153,49 +134,130 @@ def generate_line_chart() -> Optional[str]:
     plt.close()
     return chart_path
 
-# Function to generate a single ZIP report containing all results
-def generate_single_report(output_path, detected_issues, flight_logs, metrics, chart_path, map_path):
-    try:
-        # Create a directory for the report files
-        report_dir = os.path.join(OUTPUT_DIR, "final_report")
-        os.makedirs(report_dir, exist_ok=True)
-
-        # Copy the processed video
-        shutil.copy(output_path, os.path.join(report_dir, "processed_video.mp4"))
-        
-        # Save the metrics JSON
-        metrics_json_path = os.path.join(report_dir, "metrics.json")
-        with open(metrics_json_path, 'w') as json_file:
-            json.dump(metrics, json_file, indent=2)
-        
-        # Zip all captured frames
-        images_zip_path = zip_directory(CAPTURED_FRAMES_DIR, os.path.join(report_dir, "captured_frames.zip"))
-        
-        # Zip the flight logs
-        logs_zip_path = zip_directory(FLIGHT_LOG_DIR, os.path.join(report_dir, "flight_logs.zip"))
-        
-        # Save the detection trend chart
-        if chart_path:
-            shutil.copy(chart_path, os.path.join(report_dir, "detection_trend_chart.png"))
-        
-        # Save the issue locations map
-        if map_path:
-            shutil.copy(map_path, os.path.join(report_dir, "issue_locations_map.png"))
-        
-        # Create a ZIP of the entire report folder
-        zip_path = os.path.join(OUTPUT_DIR, "final_report.zip")
-        shutil.make_archive(zip_path.replace('.zip', ''), 'zip', report_dir)
-        
-        # Clean up the report directory after zipping
-        shutil.rmtree(report_dir)
+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
+) -> str:
+    report_path = os.path.join(OUTPUT_DIR, f"drone_analysis_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md")
+    report_content = [
+        "# NHAI Drone Survey Analysis Report",
+        "",
+        "## Project Details",
+        "- Project Name: NH-44 Delhi-Hyderabad Section (Package XYZ)",
+        "- Highway Section: Km 100 to Km 150",
+        "- State: Telangana",
+        "- Region: South",
+        f"- Survey Date: {datetime.now().strftime('%Y-%m-%d')}",
+        "- Drone Service Provider: ABC Drone Services Pvt. Ltd.",
+        "- Technology Service Provider: XYZ AI Analytics Ltd.",
+        f"- Work Order Reference: Data Lake WO-{datetime.now().strftime('%Y-%m-%d')}-XYZ",
+        "- Report Prepared By: Nagasurendra, Data Analyst",
+        f"- Report Date: {datetime.now().strftime('%Y-%m-%d')}",
+        "",
+        "## 1. Introduction",
+        "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.",
+        "",
+        "## 2. Drone Survey Metadata",
+        "- Drone Speed: 5 m/s",
+        "- Drone Height: 60 m",
+        "- Camera Sensor: RGB, 12 MP",
+        "- Recording Type: JPEG, 90° nadir",
+        "- Image Overlap: 85%",
+        "- Flight Pattern: Single lap, ROW centered",
+        "- Geotagging: Enabled",
+        "- Satellite Lock: 12 satellites",
+        "- Terrain Follow Mode: Enabled",
+        "",
+        "## 3. Quality Check Results",
+        f"- Resolution: 4000x3000 (12 MP)",
+        "- Overlap: 85%",
+        "- Camera Angle: 90° nadir",
+        "- Drone Speed: ≤ 5 m/s",
+        "- Geotagging: 100% compliant",
+        "- QC Status: Passed",
+        "",
+        "## 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:"
+    ]
+
+    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.extend([
+        f"- Processing Time: {total_time:.2f} seconds",
+        f"- Timestamp: {metrics.get('timestamp', 'N/A')}",
+        "- Summary: Potholes and cracks detected in high-traffic segments.",
+        "",
+        "## 5. Geotagged Data Summary",
+        f"- Total Images: {len(detected_issues)}",
+        f"- Storage: Data Lake `/project_xyz/images/{datetime.now().strftime('%Y-%m-%d')}`"
+    ])
+
+    if detected_issues:
+        report_content.extend([
+            "| Frame | Issue Type | GPS (Lat, Lon) | Timestamp | Image Path |",
+            "|-------|------------|----------------|-----------|------------|"
+        ])
+        for i, detection in enumerate(all_detections[:5]):
+            report_content.append(
+                f"| {detection['frame']:06d} | {detection['label']} | ({detection['gps'][0]}, {detection['gps'][1]}) | {detection['timestamp']} | {detection['path']} |"
+            )
+
+    report_content.extend([
+        "",
+        "## 6. Flight Log Summary",
+        f"- Total Logs: {len(detected_issues)}",
+        "- Parameters: Frame, Timestamp, Latitude, Longitude, Speed (5 m/s), Satellites (12), Altitude (60 m)",
+        "- Sample Log:",
+        "```csv",
+        f"Frame,Timestamp,Latitude,Longitude,Speed_ms,Satellites,Altitude_m",
+        f"{all_detections[0]['frame'] if all_detections else 0},{all_detections[0]['timestamp'] if all_detections else 'N/A'},{all_detections[0]['gps'][0] if all_detections else 0},{all_detections[0]['gps'][1] if all_detections else 0},5.0,12,60",
+        "```",
+        f"- Storage: Data Lake `/project_xyz/flight_logs/{datetime.now().strftime('%Y-%m-%d')}`",
+        "",
+        "## 7. Visualizations",
+        f"- Detection Trend Chart: `/project_xyz/charts/chart_temp_{datetime.now().strftime('%Y%m%d')}.png`",
+        f"- Issue Locations Map: `/project_xyz/maps/map_temp_{datetime.now().strftime('%Y%m%d')}.png`",
+        "",
+        "## 8. Stakeholder Validation",
+        "- AE/IE Comments: [Pending]",
+        "- PD/RO Comments: [Pending]",
+        "",
+        "## 9. Recommendations",
+        "- Repair potholes in high-traffic segments.",
+        "- Seal cracks to prevent degradation.",
+        "- Schedule follow-up survey.",
+        "",
+        "## 10. 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')}`"
+    ])
 
-        return zip_path
+    try:
+        with open(report_path, 'w') as f:
+            f.write("\n".join(report_content))
+        logging.info(f"Report saved: {report_path}")
+        return report_path
     except Exception as e:
-        logging.error(f"Error generating single report: {str(e)}")
-        log_entries.append(f"Error generating single report: {str(e)}")
+        logging.error(f"Failed to save report: {str(e)}")
+        log_entries.append(f"Error: Failed to save report: {str(e)}")
         return ""
 
-# Video processing function
 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
@@ -208,24 +270,20 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
     if video is None:
         log_entries.append("Error: No video uploaded")
         logging.error("No video uploaded")
-        return None, json.dumps({"error": "No video uploaded"}, indent=2), "\n".join(log_entries), [], None, None, None, None, None, None
+        return None, json.dumps({"error": "No video uploaded"}, indent=2), "\n".join(log_entries), [], None, None, None
 
     start_time = time.time()
     cap = cv2.VideoCapture(video)
     if not cap.isOpened():
         log_entries.append("Error: Could not open video file")
         logging.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, None, None, None
+        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))
-    expected_duration = total_frames / fps if fps > 0 else 0
-    log_entries.append(f"Input video: {frame_width}x{frame_height} ({input_resolution/1e6:.2f}MP), {fps} FPS, {total_frames} frames, {expected_duration:.2f} seconds, Frame skip: {frame_skip}")
-    logging.info(f"Input video: {frame_width}x{frame_height} ({input_resolution/1e6:.2f}MP), {fps} FPS, {total_frames} frames, {expected_duration:.2f} seconds, Frame skip: {frame_skip}")
-    print(f"Input video: {frame_width}x{frame_height} ({input_resolution/1e6:.2f}MP), {fps} FPS, {total_frames} frames, {expected_duration:.2f} seconds, Frame skip: {frame_skip}")
 
     out_width, out_height = resize_width, resize_height
     output_path = os.path.join(OUTPUT_DIR, "processed_output.mp4")
@@ -234,7 +292,7 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
         log_entries.append("Error: Failed to initialize mp4v codec")
         logging.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, None, None, None
+        return None, json.dumps({"error": "mp4v codec failed"}, indent=2), "\n".join(log_entries), [], None, None, None
 
     processed_frames = 0
     all_detections = []
@@ -245,12 +303,6 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
     detection_frame_count = 0
     output_frame_count = 0
     last_annotated_frame = None
-    data_lake_submission = {
-        "images": [],
-        "flight_logs": [],
-        "analytics": [],
-        "metrics": {}
-    }
 
     while True:
         ret, frame = cap.read()
@@ -262,16 +314,12 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
         processed_frames += 1
         frame_start = time.time()
 
-        # Resize
-        resize_start = time.time()
         frame = cv2.resize(frame, (out_width, out_height))
-        resize_times.append((time.time() - resize_start) * 1000)
+        resize_times.append((time.time() - frame_start) * 1000)
 
         if not check_image_quality(frame, input_resolution):
-            log_entries.append(f"Frame {frame_count}: Skipped due to low resolution")
             continue
 
-        # Inference
         inference_start = time.time()
         results = model(frame, verbose=False, conf=0.5, iou=0.7)
         annotated_frame = results[0].plot()
@@ -296,11 +344,12 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
                     "box": box,
                     "conf": conf,
                     "gps": gps_coord,
-                    "timestamp": timestamp_str
+                    "timestamp": timestamp_str,
+                    "frame": frame_count,
+                    "path": os.path.join(CAPTURED_FRAMES_DIR, f"detected_{frame_count:06d}.jpg")
                 })
-                log_message = f"Frame {frame_count} at {timestamp_str}: Detected {label} with confidence {conf:.2f}"
-                log_entries.append(log_message)
-                logging.info(log_message)
+                log_entries.append(f"Frame {frame_count} at {timestamp_str}: Detected {label} with confidence {conf:.2f}")
+                logging.info(f"Frame {frame_count} at {timestamp_str}: Detected {label} with confidence {conf:.2f}")
 
         if frame_detections:
             detection_frame_count += 1
@@ -309,12 +358,6 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
                 if cv2.imwrite(captured_frame_path, annotated_frame):
                     if write_geotag(captured_frame_path, gps_coord):
                         detected_issues.append(captured_frame_path)
-                        data_lake_submission["images"].append({
-                            "path": captured_frame_path,
-                            "frame": frame_count,
-                            "gps": gps_coord,
-                            "timestamp": timestamp_str
-                        })
                         if len(detected_issues) > 100:
                             detected_issues.pop(0)
                     else:
@@ -324,12 +367,6 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
                     logging.error(f"Failed to save {captured_frame_path}")
 
         flight_log_path = write_flight_log(frame_count, gps_coord, timestamp_str)
-        if flight_log_path:
-            data_lake_submission["flight_logs"].append({
-                "path": flight_log_path,
-                "frame": frame_count
-            })
-
         io_times.append((time.time() - io_start) * 1000)
 
         out.write(annotated_frame)
@@ -343,9 +380,7 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
         detected_counts.append(len(frame_detections))
         all_detections.extend(frame_detections)
 
-        frame_time = (time.time() - frame_start) * 1000
-        frame_times.append(frame_time)
-        log_entries.append(f"Frame {frame_count}: Processed in {frame_time:.2f} ms (Resize: {resize_times[-1]:.2f} ms, Inference: {inference_times[-1]:.2f} ms, I/O: {io_times[-1]:.2f} ms)")
+        frame_times.append((time.time() - frame_start) * 1000)
         if len(log_entries) > 50:
             log_entries.pop(0)
 
@@ -359,19 +394,6 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
         output_frame_count += 1
 
     last_metrics = update_metrics(all_detections)
-    data_lake_submission["metrics"] = last_metrics
-    data_lake_submission["frame_count"] = frame_count
-    data_lake_submission["gps_coordinates"] = gps_coordinates[-1] if gps_coordinates else [0, 0]
-
-    submission_json_path = os.path.join(OUTPUT_DIR, "data_lake_submission.json")
-    try:
-        with open(submission_json_path, 'w') as f:
-            json.dump(data_lake_submission, f, indent=2)
-        log_entries.append(f"Submission JSON saved: {submission_json_path}")
-        logging.info(f"Submission JSON saved: {submission_json_path}")
-    except Exception as e:
-        log_entries.append(f"Error: Failed to save submission JSON: {str(e)}")
-        logging.error(f"Failed to save submission JSON: {str(e)}")
 
     cap.release()
     out.release()
@@ -383,37 +405,42 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
     cap.release()
 
     total_time = time.time() - start_time
-    avg_frame_time = sum(frame_times) / len(frame_times) if frame_times else 0
-    avg_resize_time = sum(resize_times) / len(resize_times) if resize_times else 0
-    avg_inference_time = sum(inference_times) / len(inference_times) if inference_times else 0
-    avg_io_time = sum(io_times) / len(io_times) if io_times else 0
     log_entries.append(f"Output video: {output_frames} frames, {output_fps:.2f} FPS, {output_duration:.2f} seconds")
     logging.info(f"Output video: {output_frames} frames, {output_fps:.2f} FPS, {output_duration:.2f} seconds")
-    log_entries.append(f"Total processing time: {total_time:.2f} seconds, Avg frame time: {avg_frame_time:.2f} ms (Avg Resize: {avg_resize_time:.2f} ms, Avg Inference: {avg_inference_time:.2f} ms, Avg I/O: {avg_io_time:.2f} ms), Detection frames: {detection_frame_count}, Output frames: {output_frame_count}")
-    logging.info(f"Total processing time: {total_time:.2f} seconds, Avg frame time: {avg_frame_time:.2f} ms (Avg Resize: {avg_resize_time:.2f} ms, Avg Inference: {avg_inference_time:.2f} ms, Avg I/O: {avg_io_time:.2f} ms), Detection frames: {detection_frame_count}, Output frames: {output_frame_count}")
-    print(f"Output video: {output_frames} frames, {output_fps:.2f} FPS, {output_duration:.2f} seconds")
-    print(f"Total processing time: {total_time:.2f} seconds, Avg frame time: {avg_frame_time:.2f} ms, Detection frames: {detection_frame_count}, Output frames: {output_frame_count}")
 
     chart_path = generate_line_chart()
     map_path = generate_map(gps_coordinates[-5:], all_detections)
 
-    # Generate the single ZIP report
-    final_report_zip = generate_single_report(
-        output_path,
-        detected_issues,
-        flight_logs,
+    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
     )
 
-    return final_report_zip
-# Gradio interface
+    return (
+        output_path,
+        json.dumps(last_metrics, indent=2),
+        "\n".join(log_entries[-10:]),
+        detected_issues,
+        chart_path,
+        map_path,
+        report_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 for NHAI compliance)")
+            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)
@@ -431,13 +458,21 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="orange")) as iface:
     with gr.Row():
         gr.Markdown("## Download Results")
     with gr.Row():
-        zip_download = gr.File(label="Download Report (ZIP)")
+        report_download = gr.File(label="Download Analysis Report (Markdown)")
 
     process_btn.click(
         fn=process_video,
         inputs=[video_input, width_slider, height_slider, skip_slider],
-        outputs=[zip_download]
+        outputs=[
+            video_output,
+            metrics_output,
+            logs_output,
+            issue_gallery,
+            chart_output,
+            map_output,
+            report_download
+        ]
     )
 
 if __name__ == "__main__":
-    iface.launch()
+    iface.launch()