threaded vdeo processing, report building..

backend/engine.py

@@ -20,11 +20,50 @@ def _point_to_segment_dist(px, py, ax, ay, bx, by):
     return np.linalg.norm(P - (A + t * AB))
 
 
+import threading
+import queue
+
 # Lightweight drawing colors (BGR for OpenCV)
 _CLR_BOX = (230, 180, 50)     # teal-ish
 _CLR_LINE = (80, 220, 100)    # green
 _CLR_TEXT_BG = (30, 30, 30)   # dark bg for text
 
+class ThreadedVideoWriter:
+    def __init__(self, path, fps, size):
+        self.path = path
+        self.fps = fps
+        self.size = size
+        self.queue = queue.Queue(maxsize=128)
+        self.stopped = False
+        self.writer = cv2.VideoWriter(path, cv2.VideoWriter_fourcc(*"mp4v"), fps, size)
+        self.thread = threading.Thread(target=self._run, daemon=True)
+        self.thread.start()
+
+    def _run(self):
+        while not self.stopped or not self.queue.empty():
+            try:
+                frame = self.queue.get(timeout=1.0)
+                if frame is not None:
+                    self.writer.write(frame)
+                self.queue.task_done()
+            except queue.Empty:
+                continue
+        self.writer.release()
+        print(f"[BACKEND] Threaded writer finished: {self.path}")
+
+    def write(self, frame):
+        if not self.stopped:
+            try:
+                # If queue is full, we might want to wait or drop, but here we'll wait 
+                # to ensure the export video is complete and accurate.
+                self.queue.put(frame.copy())
+            except Exception as e:
+                print(f"[BACKEND] Writer queue error: {e}")
+
+    def stop(self):
+        self.stopped = True
+        self.thread.join()
+
 
 def _draw_annotations(frame, boxes, ids, clses, line_pts, options):
     """Draw bounding boxes, track IDs, and counting line on frame in-place."""
@@ -91,8 +130,7 @@ def run(model, video_path, line, config, on_frame, save_annotated=False, annotat
         os.makedirs(annotated_dir, exist_ok=True)
         annotated_path = os.path.join(annotated_dir, f"annotated_{os.path.basename(video_path)}.mp4")
         writer_fps = max(1.0, fps / stride)
-        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-        writer = cv2.VideoWriter(annotated_path, fourcc, writer_fps, (out_w, out_h))
+        writer = ThreadedVideoWriter(annotated_path, writer_fps, (out_w, out_h))
 
     prev_side = {}
     counted_ids = set()
@@ -112,7 +150,7 @@ def run(model, video_path, line, config, on_frame, save_annotated=False, annotat
     results = model.track(
         source=video_path,
         tracker="bytetrack.yaml",
-        imgsz=736,    # MUST match OpenVINO export imgsz
+        imgsz=640,    # Optimized from 736 for real-time performance on CPU
         conf=config.get("conf", 0.12),
         iou=config.get("iou", 0.6),
         vid_stride=stride,
@@ -210,7 +248,7 @@ def run(model, video_path, line, config, on_frame, save_annotated=False, annotat
         on_frame(update)
 
     if writer is not None:
-        writer.release()
+        writer.stop()
 
     processing_time = round(time.time() - start, 2)
     actual_fps = round(total / processing_time, 2) if processing_time > 0 else 0

backend/server.py

@@ -5,6 +5,7 @@ import asyncio
 import tempfile
 import shutil
 from pathlib import Path
+import zipfile
 
 import cv2
 from fastapi import FastAPI, WebSocket, UploadFile, File
@@ -134,6 +135,7 @@ def get_report(video_id: str, name: str):
         media = "application/pdf"
     elif name.endswith(".mp4"):
         media = "video/mp4"
+
     return FileResponse(str(path), media_type=media)
 
 
@@ -146,29 +148,35 @@ def download_all_reports(video_id: str):
         return Response(content=f"Report directory not found for {video_id}", status_code=404)
     
     try:
-        # Create zip in temp dir
-        zip_base = REPORT_DIR / f"bundle_{video_id}"
-        if os.path.exists(f"{zip_base}.zip"):
-            os.remove(f"{zip_base}.zip")
+        zip_filename = f"bundle_{video_id}.zip"
+        zip_path = REPORT_DIR / zip_filename
+        
+        if zip_path.exists():
+            zip_path.unlink()
             
-        print(f"[BACKEND] Archiving {base_path} to {zip_base}.zip")
-        shutil.make_archive(str(zip_base), 'zip', str(base_path))
+        print(f"[BACKEND] Creating ZIP: {zip_path}")
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for root, _, files in os.walk(base_path):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, base_path)
+                    zipf.write(file_path, arcname)
         
-        final_zip = Path(f"{zip_base}.zip")
-        if not final_zip.exists():
+        if not zip_path.exists():
              raise Exception("Zip file was not created")
              
         original_name = video_info.get(video_id, "UrbanFlow_Analysis")
         safe_name = "".join(x for x in original_name if x.isalnum() or x in "._-").rsplit(".", 1)[0]
         
-        print(f"[BACKEND] Serving ZIP: {final_zip}")
+        print(f"[BACKEND] Serving ZIP: {zip_path}")
         return FileResponse(
-            str(final_zip), 
+            str(zip_path), 
             media_type="application/zip", 
-            filename=f"{safe_name}_reports.zip"
+            filename=f"{safe_name}_UrbanFlow.zip"
         )
     except Exception as e:
-        print(f"[BACKEND] ZIP Error: {str(e)}")
+        import traceback
+        print(f"[BACKEND] ZIP Error: {str(e)}\n{traceback.format_exc()}")
         return Response(content=str(e), status_code=500)