Update app.py

app.py

@@ -42,20 +42,6 @@ model = YOLO('./data/best.pt').to(device)
 if device == "cuda":
     model.half()
 
-def zip_directory(folder_path: str, zip_path: str) -> str:
-    try:
-        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
-            for root, _, files in os.walk(folder_path):
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    arcname = os.path.relpath(file_path, folder_path)
-                    zipf.write(file_path, os.path.join(os.path.basename(folder_path), arcname))
-        return zip_path
-    except Exception as e:
-        logging.error(f"Failed to zip {folder_path}: {str(e)}")
-        log_entries.append(f"Error: Failed to zip {folder_path}: {str(e)}")
-        return ""
-
 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:
@@ -63,27 +49,26 @@ def zip_all_outputs(report_path: str, video_path: str, chart_path: str, map_path
             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.basename(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.basename(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.basename(map_path))
-            for root, _, files in os.walk(CAPTURED_FRAMES_DIR):
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    zipf.write(file_path, os.path.join("captured_frames", file))
+                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:
-        logging.error(f"Failed to create output ZIP: {str(e)}")
-        log_entries.append(f"Error: Failed to create output ZIP: {str(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, "map_temp.png")
+    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")
@@ -110,7 +95,6 @@ def write_geotag(image_path: str, gps_coord: List[float]) -> bool:
         piexif.insert(piexif.dump(exif_dict), image_path)
         return True
     except Exception as e:
-        logging.error(f"Failed to geotag {image_path}: {str(e)}")
         log_entries.append(f"Error: Failed to geotag {image_path}: {str(e)}")
         return False
 
@@ -123,7 +107,6 @@ def write_flight_log(frame_count: int, gps_coord: List[float], timestamp: str) -
             writer.writerow([frame_count, timestamp, gps_coord[0], gps_coord[1], 5.0, 12, 60])
         return log_path
     except Exception as e:
-        logging.error(f"Failed to write flight log {log_path}: {str(e)}")
         log_entries.append(f"Error: Failed to write flight log {log_path}: {str(e)}")
         return ""
 
@@ -156,7 +139,7 @@ def generate_line_chart() -> Optional[str]:
     plt.ylabel("Count")
     plt.grid(True)
     plt.tight_layout()
-    chart_path = os.path.join(OUTPUT_DIR, "chart_temp.png")
+    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
@@ -179,7 +162,9 @@ def generate_report(
     inference_times: List[float],
     io_times: List[float]
 ) -> str:
+    log_entries.append("Generating report...")
     report_path = os.path.join(OUTPUT_DIR, f"drone_analysis_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md")
+    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
     report_content = [
         "# NHAI Drone Survey Analysis Report",
         "",
@@ -229,14 +214,24 @@ def generate_report(
         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",
-        f"- Average Resize Time: {sum(resize_times)/len(resize_times):.2f} ms",
-        f"- Average Inference Time: {sum(inference_times)/len(inference_times):.2f} ms",
-        f"- Average I/O Time: {sum(io_times)/len(io_times):.2f} ms",
+        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.",
         "",
-        "## 5. Geotagged Images",
+        "## 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`).",
+        "",
+        "## 6. Geotagged Images",
         f"- Total Images: {len(detected_issues)}",
         f"- Storage: Data Lake `/project_xyz/images/{datetime.now().strftime('%Y-%m-%d')}`",
         "",
@@ -244,14 +239,14 @@ def generate_report(
         "|-------|------------|----------------|-----------|------------|------------|"
     ])
 
-    for detection in all_detections:
+    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} | {detection['path']} |"
+            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'])} |"
         )
 
     report_content.extend([
         "",
-        "## 6. Flight Logs",
+        "## 7. Flight Logs",
         f"- Total Logs: {len(detected_issues)}",
         f"- Storage: Data Lake `/project_xyz/flight_logs/{datetime.now().strftime('%Y-%m-%d')}`",
         "",
@@ -259,27 +254,27 @@ def generate_report(
         "|-------|-----------|----------|-----------|-------------|------------|--------------|----------|"
     ])
 
-    for detection in all_detections:
-        log_path = os.path.join(FLIGHT_LOG_DIR, f"flight_log_{detection['frame']:06d}.csv")
+    for detection in all_detections[:100]:
+        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} |"
         )
 
     report_content.extend([
         "",
-        "## 7. Processed Video",
-        f"- Path: `/project_xyz/videos/processed_output_{datetime.now().strftime('%Y%m%d')}.mp4`",
+        "## 8. Processed Video",
+        f"- Path: outputs/processed_output.mp4",
         f"- Frames: {output_frames}",
         f"- FPS: {output_fps:.2f}",
         f"- Duration: {output_duration:.2f} seconds",
         "",
-        "## 8. 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`",
+        "## 9. Visualizations",
+        f"- Detection Trend Chart: outputs/chart_{timestamp}.png",
+        f"- Issue Locations Map: outputs/map_{timestamp}.png",
         "",
-        "## 9. Processing Timestamps",
+        "## 10. Processing Timestamps",
         f"- Total Processing Time: {total_time:.2f} seconds",
-        f"- Log Entries (Last 10):"
+        "- Log Entries (Last 10):"
     ])
 
     for entry in log_entries[-10:]:
@@ -287,16 +282,16 @@ def generate_report(
 
     report_content.extend([
         "",
-        "## 10. Stakeholder Validation",
+        "## 11. Stakeholder Validation",
         "- AE/IE Comments: [Pending]",
         "- PD/RO Comments: [Pending]",
         "",
-        "## 11. Recommendations",
+        "## 12. Recommendations",
         "- Repair potholes in high-traffic segments.",
         "- Seal cracks to prevent degradation.",
         "- Schedule follow-up survey.",
         "",
-        "## 12. Data Lake References",
+        "## 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`",
@@ -306,10 +301,9 @@ def generate_report(
     try:
         with open(report_path, 'w') as f:
             f.write("\n".join(report_content))
-        logging.info(f"Report saved: {report_path}")
+        log_entries.append(f"Report saved: {report_path}")
         return report_path
     except Exception as e:
-        logging.error(f"Failed to save report: {str(e)}")
         log_entries.append(f"Error: Failed to save report: {str(e)}")
         return ""
 
@@ -324,14 +318,13 @@ 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
 
+    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")
-        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
 
     frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
@@ -339,13 +332,13 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
     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")
-        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
 
@@ -404,7 +397,6 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
                     "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}")
-                logging.info(f"Frame {frame_count} at {timestamp_str}: Detected {label} with confidence {conf:.2f}")
 
         if frame_detections:
             detection_frame_count += 1
@@ -413,15 +405,14 @@ 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)
-                        if len(detected_issues) > 100:
+                        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}")
-                    logging.error(f"Failed to save {captured_frame_path}")
+                flight_log_path = write_flight_log(frame_count, gps_coord, timestamp_str)
 
-        flight_log_path = write_flight_log(frame_count, gps_coord, timestamp_str)
         io_times.append((time.time() - io_start) * 1000)
 
         out.write(annotated_frame)
@@ -441,7 +432,6 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
 
         if time.time() - start_time > 600:
             log_entries.append("Error: Processing timeout after 600 seconds")
-            logging.error("Processing timeout after 600 seconds")
             break
 
     while output_frame_count < total_frames and last_annotated_frame is not None:
@@ -461,8 +451,8 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
 
     total_time = time.time() - start_time
     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("Generating chart and map...")
     chart_path = generate_line_chart()
     map_path = generate_map(gps_coordinates[-5:], all_detections)
 
@@ -485,8 +475,10 @@ def process_video(video, resize_width=4000, resize_height=3000, frame_skip=5):
         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),