Update app.py

app.py

@@ -5,39 +5,48 @@ import cv2
 import gradio as gr
 import numpy as np
 import matplotlib.cm as cm
-import matplotlib
+import matplotlib  # New import for the updated colormap API
 import subprocess
 
 from video_depth_anything.video_depth import VideoDepthAnything
 from utils.dc_utils import read_video_frames, save_video
 from huggingface_hub import hf_hub_download
 
+# Examples for the Gradio Demo.
+# Each example now contains 8 parameters:
+# [video_path, max_len, target_fps, max_res, stitch, grayscale, convert_from_color, blur]
 examples = [
-    ['assets/example_videos/octopus_01.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/chicken_01.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/gorilla_01.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/davis_rollercoaster.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/Tokyo-Walk_rgb.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/4158877-uhd_3840_2160_30fps_rgb.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/4511004-uhd_3840_2160_24fps_rgb.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/1753029-hd_1920_1080_30fps.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/davis_burnout.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/example_5473765-l.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/Istanbul-26920.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/obj_1.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
-    ['assets/example_videos/sheep_cut1.mp4', -1, -1, 1280, True, True, True, 0.3, 1],
+    ['assets/example_videos/octopus_01.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/chicken_01.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/gorilla_01.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/davis_rollercoaster.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/Tokyo-Walk_rgb.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/4158877-uhd_3840_2160_30fps_rgb.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/4511004-uhd_3840_2160_24fps_rgb.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/1753029-hd_1920_1080_30fps.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/davis_burnout.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/example_5473765-l.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/Istanbul-26920.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/obj_1.mp4', -1, -1, 1280, True, True, True, 0.3],
+    ['assets/example_videos/sheep_cut1.mp4', -1, -1, 1280, True, True, True, 0.3],
 ]
 
+# Use GPU if available; otherwise, use CPU.
 DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
 
+# Model configuration for different encoder variants.
 model_configs = {
     'vits': {'encoder': 'vits', 'features': 64, 'out_channels': [48, 96, 192, 384]},
     'vitl': {'encoder': 'vitl', 'features': 256, 'out_channels': [256, 512, 1024, 1024]},
 }
-encoder2name = {'vits': 'Small', 'vitl': 'Large'}
+encoder2name = {
+    'vits': 'Small',
+    'vitl': 'Large',
+}
 encoder = 'vitl'
 model_name = encoder2name[encoder]
 
+# Initialize the model.
 video_depth_anything = VideoDepthAnything(**model_configs[encoder])
 filepath = hf_hub_download(
     repo_id=f"depth-anything/Video-Depth-Anything-{model_name}",
@@ -51,27 +60,6 @@ title = "# Video Depth Anything + RGBD sbs output"
 description = """Official demo for **Video Depth Anything** + RGBD sbs output for viewing with Looking Glass Factory displays.
 Please refer to our [paper](https://arxiv.org/abs/2501.12375), [project page](https://videodepthanything.github.io/), and [github](https://github.com/DepthAnything/Video-Depth-Anything) for more details."""
 
-def estimate_duration(input_video_path, repeat_factor):
-    try:
-        cmd = [
-            "ffprobe", "-v", "error",
-            "-select_streams", "v:0",
-            "-show_entries", "format=duration",
-            "-of", "default=noprint_wrappers=1:nokey=1",
-            input_video_path
-        ]
-        result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-        duration = float(result.stdout.strip())
-        final_duration = duration * repeat_factor
-        return f"📏 Final RGBD video duration: ~{int(final_duration)} seconds"
-    except Exception:
-        return "⚠️ Unable to estimate duration."
-
-def update_duration_preview(video_file, repeat_factor):
-    if video_file is None:
-        return "Final video duration: N/A"
-    return estimate_duration(video_file, repeat_factor)
-
 def infer_video_depth(
     input_video: str,
     max_len: int = -1,
@@ -81,27 +69,108 @@ def infer_video_depth(
     grayscale: bool = True,
     convert_from_color: bool = True,
     blur: float = 0.3,
-    repeat_rgbd: int = 1,
     output_dir: str = './outputs',
     input_size: int = 518,
 ):
-    ...  # Der restliche Code bleibt gleich
+    # 1. Read input video frames for inference (downscaled to max_res).
+    frames, target_fps = read_video_frames(input_video, max_len, target_fps, max_res)
+    # 2. Perform depth inference using the model.
+    depths, fps = video_depth_anything.infer_video_depth(frames, target_fps, input_size=input_size, device=DEVICE)
+
+    video_name = os.path.basename(input_video)
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Save the preprocessed (RGB) video and the generated depth visualization.
+    processed_video_path = os.path.join(output_dir, os.path.splitext(video_name)[0] + '_src.mp4')
+    depth_vis_path = os.path.join(output_dir, os.path.splitext(video_name)[0] + '_vis.mp4')
+    save_video(frames, processed_video_path, fps=fps)
+    save_video(depths, depth_vis_path, fps=fps, is_depths=True)
+
+    stitched_video_path = None
+    if stitch:
+        # For stitching: read the original video in full resolution (without downscaling).
+        full_frames, _ = read_video_frames(input_video, max_len, target_fps, max_res=-1)
+        # For each frame, create a visual depth image from the inferenced depths.
+        d_min, d_max = depths.min(), depths.max()
+        stitched_frames = []
+        for i in range(min(len(full_frames), len(depths))):
+            rgb_full = full_frames[i]  # Full-resolution RGB frame.
+            depth_frame = depths[i]
+            # Normalize the depth frame to the range [0, 255].
+            depth_norm = ((depth_frame - d_min) / (d_max - d_min) * 255).astype(np.uint8)
+            # Generate depth visualization:
+            if grayscale:
+                if convert_from_color:
+                    # First, generate a color depth image using the inferno colormap,
+                    # then convert that color image to grayscale.
+                    cmap = matplotlib.colormaps.get_cmap("inferno")
+                    depth_color = (cmap(depth_norm / 255.0)[..., :3] * 255).astype(np.uint8)
+                    depth_gray = cv2.cvtColor(depth_color, cv2.COLOR_RGB2GRAY)
+                    depth_vis = np.stack([depth_gray] * 3, axis=-1)
+                else:
+                    # Directly generate a grayscale image from the normalized depth values.
+                    depth_vis = np.stack([depth_norm] * 3, axis=-1)
+            else:
+                # Generate a color depth image using the inferno colormap.
+                cmap = matplotlib.colormaps.get_cmap("inferno")
+                depth_vis = (cmap(depth_norm / 255.0)[..., :3] * 255).astype(np.uint8)
+            # Apply Gaussian blur if requested.
+            if blur > 0:
+                kernel_size = int(blur * 20) * 2 + 1  # Ensures an odd kernel size.
+                depth_vis = cv2.GaussianBlur(depth_vis, (kernel_size, kernel_size), 0)
+            # Resize the depth visualization to match the full-resolution RGB frame.
+            H_full, W_full = rgb_full.shape[:2]
+            depth_vis_resized = cv2.resize(depth_vis, (W_full, H_full))
+            # Concatenate the full-resolution RGB frame (left) and the resized depth visualization (right).
+            stitched = cv2.hconcat([rgb_full, depth_vis_resized])
+            stitched_frames.append(stitched)
+        stitched_frames = np.array(stitched_frames)
+        # Use only the first 20 characters of the base name for the output filename and append '_RGBD.mp4'
+        base_name = os.path.splitext(video_name)[0]
+        short_name = base_name[:20]
+        stitched_video_path = os.path.join(output_dir, short_name + '_RGBD.mp4')
+        save_video(stitched_frames, stitched_video_path, fps=fps)
+        
+        # Merge audio from the input video into the stitched video using ffmpeg.
+        temp_audio_path = stitched_video_path.replace('_RGBD.mp4', '_RGBD_audio.mp4')
+        cmd = [
+            "ffmpeg",
+            "-y",
+            "-i", stitched_video_path,
+            "-i", input_video,
+            "-c:v", "copy",
+            "-c:a", "aac",
+            "-map", "0:v:0",
+            "-map", "1:a:0?",
+            "-shortest",
+            temp_audio_path
+        ]
+        subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        os.replace(temp_audio_path, stitched_video_path)
+
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    # Return the preprocessed RGB video, depth visualization, and (if created) the stitched video.
+    return [processed_video_path, depth_vis_path, stitched_video_path]
 
 def construct_demo():
     with gr.Blocks(analytics_enabled=False) as demo:
         gr.Markdown(title)
         gr.Markdown(description)
         gr.Markdown("### If you find this work useful, please help ⭐ the [Github Repo](https://github.com/DepthAnything/Video-Depth-Anything). Thanks for your attention!")
-
+        
         with gr.Row(equal_height=True):
             with gr.Column(scale=1):
+                # Video input component for file upload.
                 input_video = gr.Video(label="Input Video")
             with gr.Column(scale=2):
                 with gr.Row(equal_height=True):
-                    processed_video = gr.Video(label="Preprocessed Video", interactive=False, autoplay=True, loop=True, show_share_button=True)
-                    depth_vis_video = gr.Video(label="Generated Depth Video", interactive=False, autoplay=True, loop=True, show_share_button=True)
-                    stitched_video = gr.Video(label="Stitched RGBD Video", interactive=False, autoplay=True, loop=True, show_share_button=True)
-
+                    processed_video = gr.Video(label="Preprocessed Video", interactive=False, autoplay=True, loop=True, show_share_button=True, scale=5)
+                    depth_vis_video = gr.Video(label="Generated Depth Video", interactive=False, autoplay=True, loop=True, show_share_button=True, scale=5)
+                    stitched_video = gr.Video(label="Stitched RGBD Video", interactive=False, autoplay=True, loop=True, show_share_button=True, scale=5)
+                    
         with gr.Row(equal_height=True):
             with gr.Column(scale=1):
                 with gr.Accordion("Advanced Settings", open=False):
@@ -112,33 +181,28 @@ def construct_demo():
                     grayscale_option = gr.Checkbox(label="Output Depth as Grayscale", value=True)
                     convert_from_color_option = gr.Checkbox(label="Convert Grayscale from Color", value=True)
                     blur_slider = gr.Slider(minimum=0, maximum=1, step=0.01, label="Depth Blur (can reduce edge artifacts on display)", value=0.3)
-                    repeat_rgbd_slider = gr.Slider(label="Repeat RGBD Video (Times)", minimum=1, maximum=20, value=1, step=1)
-                    duration_preview = gr.Markdown("Final video duration: N/A", visible=True)
                 generate_btn = gr.Button("Generate")
             with gr.Column(scale=2):
                 pass
-
+        
         gr.Examples(
             examples=examples,
-            inputs=[input_video, max_len, target_fps, max_res, stitch_option, grayscale_option, convert_from_color_option, blur_slider, repeat_rgbd_slider],
+            inputs=[input_video, max_len, target_fps, max_res, stitch_option, grayscale_option, convert_from_color_option, blur_slider],
             outputs=[processed_video, depth_vis_video, stitched_video],
             fn=infer_video_depth,
             cache_examples=False,
             cache_mode="lazy",
         )
-
-        input_video.change(fn=update_duration_preview, inputs=[input_video, repeat_rgbd_slider], outputs=[duration_preview])
-        repeat_rgbd_slider.change(fn=update_duration_preview, inputs=[input_video, repeat_rgbd_slider], outputs=[duration_preview])
-
+        
         generate_btn.click(
             fn=infer_video_depth,
-            inputs=[input_video, max_len, target_fps, max_res, stitch_option, grayscale_option, convert_from_color_option, blur_slider, repeat_rgbd_slider],
+            inputs=[input_video, max_len, target_fps, max_res, stitch_option, grayscale_option, convert_from_color_option, blur_slider],
             outputs=[processed_video, depth_vis_video, stitched_video],
         )
-
+    
     return demo
 
 if __name__ == "__main__":
     demo = construct_demo()
-    demo.queue()
-    demo.launch(share=True, ssr=False)
+    demo.queue()  # Enable asynchronous processing.
+    demo.launch(share=True)