fixed overflow

inference.py

@@ -354,6 +354,7 @@ def run_depth_inference(
     output_video_path: str,
     max_frames: Optional[int] = None,
     depth_estimator_name: str = "depth_pro",
+    first_frame_depth_path: Optional[str] = None,
     job_id: Optional[str] = None,
 ) -> str:
     """
@@ -364,6 +365,7 @@ def run_depth_inference(
         output_video_path: Path to write depth visualization video
         max_frames: Optional frame limit for testing
         depth_estimator_name: Depth estimator to use (default: depth_pro)
+        first_frame_depth_path: Optional path to save the first depth visualization frame
         job_id: Optional job ID for cancellation support
 
     Returns:
@@ -388,6 +390,12 @@ def run_depth_inference(
     write_video(processed_frames, output_video_path, fps=fps, width=width, height=height)
     logging.info("Depth video written to: %s", output_video_path)
 
+    if first_frame_depth_path and processed_frames:
+        import cv2
+
+        if not cv2.imwrite(first_frame_depth_path, processed_frames[0]):
+            logging.warning("Failed to write first frame depth image to: %s", first_frame_depth_path)
+
     return output_video_path
 
 
@@ -442,6 +450,7 @@ def process_frames_depth(
         global_min = 0.0
         global_max = 1.0
     else:
+        valid_depths = valid_depths.astype(np.float64, copy=False)
         global_min = float(np.percentile(valid_depths, 1))  # 1st percentile to clip outliers
         global_max = float(np.percentile(valid_depths, 99))  # 99th percentile
 
@@ -493,9 +502,19 @@ def colorize_depth_map(
     """
     import cv2
 
-    # Replace NaN/inf with min value for visualization
     depth_clean = np.copy(depth_map)
-    depth_clean[~np.isfinite(depth_clean)] = global_min
+    finite_mask = np.isfinite(depth_clean)
+    if not np.isfinite(global_min) or not np.isfinite(global_max):
+        if finite_mask.any():
+            local_depths = depth_clean[finite_mask].astype(np.float64, copy=False)
+            global_min = float(np.percentile(local_depths, 1))
+            global_max = float(np.percentile(local_depths, 99))
+        else:
+            global_min = 0.0
+            global_max = 1.0
+
+    # Replace NaN/inf with min value for visualization
+    depth_clean[~finite_mask] = global_min
 
     if global_max - global_min < 1e-6:  # Handle uniform depth
         depth_norm = np.zeros_like(depth_clean, dtype=np.uint8)

jobs/background.py

@@ -5,7 +5,7 @@ from datetime import datetime
 import torch
 
 from jobs.models import JobStatus
-from jobs.storage import get_job_storage, get_depth_output_path
+from jobs.storage import get_job_storage, get_depth_output_path, get_first_frame_depth_path
 from inference import run_inference, run_segmentation, run_depth_inference
 
 
@@ -51,6 +51,7 @@ async def process_video_async(job_id: str) -> None:
                 str(get_depth_output_path(job_id)),
                 None,  # max_frames
                 job.depth_estimator_name,
+                str(get_first_frame_depth_path(job_id)),
                 job_id,
             )
             logging.info("Depth estimation completed for job %s", job_id)