Update app.py

app.py

@@ -36,7 +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
+MAX_IMAGES = 500
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
 model = YOLO('./data/best.pt').to(device)
@@ -46,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_STORED) as zipf:  # Use ZIP_STORED for faster compression
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_STORED) as zipf:
             if os.path.exists(report_path):
                 zipf.write(report_path, os.path.basename(report_path))
             if os.path.exists(video_path):
@@ -114,7 +114,7 @@ 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 < 2_073_600:  # 1920x1080 minimum
+    if frame_resolution < 2_073_600:
         log_entries.append(f"Frame {frame_count}: Resolution {width}x{height} below 2MP")
         return False
     if frame_resolution < input_resolution:
@@ -196,7 +196,7 @@ def generate_report(
         "- Terrain Follow Mode: Enabled",
         "",
         "## 3. Quality Check Results",
-        f"- Resolution: 1920x1080",
+        "- Resolution: 1920x1080",
         "- Overlap: 85%",
         "- Camera Angle: 90° nadir",
         "- Drone Speed: ≤ 5 m/s",
@@ -205,9 +205,9 @@ 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:.1f}%)",
-        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", []):
@@ -219,51 +219,46 @@ def generate_report(
         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'",
+        f"- Timestamp: {metrics.get('timestamp', '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>.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([
-        "",
+        "  - `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`).",
         "",
         "## 6. Geotagged Images",
         f"- Total Images: {len(detected_issues)}",
-        f"- Storage: Data Lake `/project_xyz/images/projects/{datetime.now().strftime('%Y%m%d')}`",
+        f"- Storage: Data Lake `/project_xyz/images/{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']:.1f} | 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 | Latitude Longitude | Speed (m/s) | Latency Satellites | ms) | 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 | Speed (m/s) | Satellites | Altitude (m) | Log Path |",
+        "|-------|-----------|----------|-----------|-------------|------------|--------------|----------|"
     ])
 
     for detection in all_detections[:100]:
-        log_path = f"flight_logs/flight_log_{detection['frame']}:f{06d}.csv":'
+        log_path = f"flight_logs/flight_log_{detection['frame']: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([
@@ -275,12 +270,12 @@ def generate_report(
         f"- Duration: {output_duration:.1f} seconds",
         "",
         "## 9. Visualizations",
-        f"- Detection Trend Chart: outputs/chart_{timestamp}.jpg",
-        f"- Issue Locations Map: outputs/map_{timestamp}.jpg",
+        f"- Detection Trend Chart: outputs/chart_{timestamp}.png",
+        f"- Issue Locations Map: outputs/map_{timestamp}.png",
         "",
         "## 10. Processing Timestamps",
         f"- Total Processing Time: {total_time:.1f} seconds",
-        "- Log Entries (Last 10):",
+        "- Log Entries (Last 10):"
     ])
 
     for entry in log_entries[-10:]:
@@ -293,84 +288,80 @@ def generate_report(
         "- PD/RO Comments: [Pending]",
         "",
         "## 12. Recommendations",
-        "- Repair potholes potholes in high-traffic areas",
+        "- Repair 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""- 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')'}`)",
+        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_{timestamp}.mp4`",
+        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, mode'w), as) as file:
-            file.write("\n".join(report_content))
+        with open(report_path, 'w') as f:
+            f.write("\n".join(report_content))
         log_entries.append(f"Report saved at: {report_path}")
         return report_path
     except Exception as e:
-        log_entries.append(f"Error: Failed to to save report): {str(e)}")
+        log_entries.append(f"Error: Failed to save report: {str(e)}")
         return ""
-)
 
-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
+def process_video(video, resize_width=1920, resize_height=1080, frame_skip=10):
+    global frame_count, last_metrics, detected_counts, detected_issues, gps_coordinates, log_entries
     frame_count = 0
     detected_counts.clear()
     detected_issues.clear()
     gps_coordinates.clear()
-    output_log_entries.clear()
-    last_metrics = {})
+    log_entries.clear()
+    last_metrics = {}
 
     if video is None:
         log_entries.append("Error: No video uploaded")
-        return None, None, None, [], None, None, None)
+        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 videos file")
-        return None, json.dumps({"),error": "Could not open video file"}, indent=2), None, [], None, None, None)
+        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))
-        width = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        input_resolution = frame_width * height
-        f = FPS
+    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_PRO_PROF_COUNT)
-        log_entries.append(f"Input video: {frame_width}x{height} at {fps} FPS,, {total_frames} frames")
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    log_entries.append(f"Input video: {frame_width}x{frame_height} at {fps} FPS, {total_frames} frames")
 
-        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
+    out_width, out_height = resize_width, resize_height
+    output_path = os.path.join(OUTPUT_DIR, "processed_output.mp4")
+    out = cv2.VideoWriter(output_path, cv2.VideoWriter_fourcc(*'XVID'), fps, (out_width, out_height))
     if not out.isOpened():
         log_entries.append("Error: Failed to initialize video writer")
         cap.release()
-        return None, json.dumps({"error": "Video writer failed"}), None, [], None, None, None)
+        return None, json.dumps({"error": "Video writer failed"}, indent=2), "\n".join(log_entries), [], 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_frame_detected_frame = None
-    disk_space_threshold = 1024 * 1024 * 1024  # 1GB minimum disk space
+    output_frame_count = 0
+    last_annotated_frame = None
+    disk_space_threshold = 1024 * 1024 * 1024
 
     while True:
         ret, frame = cap.read()
@@ -382,8 +373,7 @@ def process_video(input_video, resize_width=1920, resize_height=1080, frame_skip
         processed_frames += 1
         frame_start = time.time()
 
-        # Check disk space
-        if os.statvfs(os.path.dirname(output_path)).f_frsize() * os.statvfs().f_bavail < disk_space_threshold:
+        if os.statvfs(os.path.dirname(output_path)).f_frsize * os.statvfs(os.path.dirname(output_path)).f_bavail < disk_space_threshold:
             log_entries.append("Error: Insufficient disk space")
             break
 
@@ -393,18 +383,18 @@ def process_video(input_video, resize_width=1920, resize_height=1080, frame_skip
         if not check_image_quality(frame, input_resolution):
             continue
 
-        inference_time = time.time()
-        results = model(frame, verbose=False, conf=0.5, threshold=0.7)
+        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_time) * 1000)
+        inference_times.append((time.time() - inference_start) * 1000)
 
         frame_timestamp = frame_count / fps if fps > 0 else 0
-        timestamp_str = f"{int(frame_timestamp / 60):02d}:{int(frame_timestamp % 60):02d}"
+        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.time()
+        io_start = time.time()
         frame_detections = []
         for detection in results[0].boxes:
             cls = int(detection.cls)
@@ -419,7 +409,7 @@ def process_video(input_video, resize_width=1920, resize_height=1080, frame_skip
                     "gps": gps_coord,
                     "timestamp": timestamp_str,
                     "frame": frame_count,
-                    "path": os.path.join(CAPTURED_FRAMES_DIR, f"detected_frame_{frame_count:06d}.jpg")
+                    "path": os.path.join(CAPTURED_FRAMES_DIR, f"detected_{frame_count:06d}.jpg")
                 }
                 frame_detections.append(detection_data)
                 log_entries.append(f"Frame {frame_count} at {timestamp_str}: Detected {label} with confidence {conf:.2f}")
@@ -427,23 +417,23 @@ def process_video(input_video, resize_width=1920, resize_height=1080, frame_skip
         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_{frame_count:06d}.jpg")
+                captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"detected_{frame_count:06d}.jpg")
                 if cv2.imwrite(captured_frame_path, annotated_frame):
                     if write_geotag(captured_frame_path, gps_coord):
                         detected_issues.append(captured_frame_path)
                         if len(detected_issues) > MAX_IMAGES:
-                            os.remove(detected_issues.pop(0))  # Remove oldest image
+                            os.remove(detected_issues.pop(0))
                     else:
                         log_entries.append(f"Frame {frame_count}: Geotagging failed")
                 else:
                     log_entries.append(f"Error: Failed to save frame at {captured_frame_path}")
                 write_flight_log(frame_count, gps_coord, timestamp_str)
 
-        io_times.append((time.time() - io_start_time) * 1000)
+        io_times.append((time.time() - io_start) * 1000)
 
         out.write(annotated_frame)
         output_frame_count += 1
-        last_detected_frame = annotated_frame
+        last_annotated_frame = annotated_frame
         if frame_skip > 1:
             for _ in range(frame_skip - 1):
                 out.write(annotated_frame)
@@ -460,8 +450,8 @@ def process_video(input_video, resize_width=1920, resize_height=1080, frame_skip
             log_entries.append("Error: Processing timeout after 600 seconds")
             break
 
-    while output_frame_count < total_frames and last_detected_frame is not None:
-        out.write(last_detected_frame)
+    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)
@@ -469,7 +459,6 @@ def process_video(input_video, resize_width=1920, resize_height=1080, frame_skip
     out.release()
     cap.release()
 
-    # Verify output video
     cap = cv2.VideoCapture(output_path)
     if not cap.isOpened():
         log_entries.append("Error: Failed to open output video for verification")
@@ -523,38 +512,34 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="orange")) as iface:
             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")
+            skip_slider = gr.Slider(1, 20, value=10, label="Frame Skip", step=1)
+            process_btn = gr.Button("Process Video", variant="primary")
         with gr.Column(scale=1):
-            metrics_output = gr.Textbox(label="", lines=5, interactive=False)
-    )
+            metrics_output = gr.Textbox(label="Detection Metrics", lines=5, interactive=False)
     with gr.Row():
-        output_video = gr.Video(label="Processed Video")
-        issue_frame_gallery = gr.Gallery(label="Detected Issues", columns=4, height="auto", object_fit="fit"contain")
+        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_frame = gr.Image(label="Detection Trend")
-        map_frame = gr.Image(label="Issue Locations")
-    )
+        chart_output = gr.Image(label="Detection Trend")
+        map_output = gr.Image(label="Issue Locations Map")
     with gr.Row():
-        logs_frame = gr.Textbox(label="Logs", lines=5, interactive=False)
+        logs_output = gr.Textbox(label="Logs", lines=5, interactive=False)
     with gr.Row():
-        )
         gr.Markdown("## Download Results")
-    )
     with gr.Row():
-        zip_output_downloaded = gr.File(label="Download All Outputs")
+        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=[
-            output_video,
+            video_output,
             metrics_output,
-            logs_frame_output,
-            issue_frame_dgallery,
-            chart_frame_doutput,
-            maps_frame_doutput,
-            zip_output_downloads
+            logs_output,
+            issue_gallery,
+            chart_output,
+            map_output,
+            output_zip_download
         ]
     )