Depth Anything 3 튜토리얼: 사진 한 장을 움직이는 3D 영상으로

bash -c "apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y git wget ffmpeg libgl1 libglib2.0-0 && pip install jupyterlab && jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root --ServerApp.token='' --ServerApp.password=''"

!cd /workspace && git clone -q https://github.com/ByteDance-Seed/Depth-Anything-3.git
!cd /workspace/Depth-Anything-3 && pip install -q -e . addict

import torch, numpy
from depth_anything_3.api import DepthAnything3
print(torch.__version__, numpy.__version__, torch.cuda.get_device_name(0))

import os, time, torch, numpy as np, cv2
from depth_anything_3.api import DepthAnything3

os.makedirs("depth", exist_ok=True)
model = DepthAnything3.from_pretrained("depth-anything/DA3MONO-LARGE").to("cuda").eval()

for name in ["cheonggyecheon", "bukchon", "street"]:
    t = time.time()
    pred = model.inference([f"photos/{name}.jpg"], process_res=1008)
    d = pred.depth[0]                                   # (H, W) float32, 값이 클수록 멀다
    np.save(f"depth/{name}.npy", d)
    inv = 1.0 / np.clip(d, 1e-6, None)                  # 가까울수록 큰 값으로 변환
    v = (inv - inv.min()) / (inv.max() - inv.min())
    cv2.imwrite(f"depth/{name}.png", cv2.applyColorMap((v * 255).astype("uint8"), cv2.COLORMAP_INFERNO))
    print(name, d.shape, f"{time.time() - t:.2f}s")

"""사진 + 깊이 지도 -> 패럴랙스(2.5D) 영상.
usage: python parallax.py photo.jpg depth.npy out.mp4 [--no-inpaint]"""
import sys, time, subprocess, numpy as np, cv2
photo, depth_path, out = sys.argv[1:4]
inpaint = "--no-inpaint" not in sys.argv
W = 1280; FPS = 30; SEC = 4; LAYERS = 24
AMP_X, AMP_Y, ZOOM = 0.035, 0.012, 0.06            # 이동 폭(화면 비율), 확대 비율

img = cv2.imread(photo)
H = round(img.shape[0] * W / img.shape[1] / 2) * 2
img = cv2.resize(img, (W, H), interpolation=cv2.INTER_AREA)
d = np.load(depth_path).astype(np.float32)
disp = 1.0 / np.clip(d, 1e-6, None)                 # 가까울수록 큰 값
disp = cv2.resize(disp, (W, H), interpolation=cv2.INTER_LINEAR)
lo, hi = np.percentile(disp, 2), np.percentile(disp, 98)
disp = np.clip((disp - lo) / (hi - lo + 1e-9), 0, 1)
disp = cv2.medianBlur((disp * 255).astype(np.uint8), 5).astype(np.float32) / 255
edges = np.linspace(0, 1, LAYERS + 1)
layer_id = np.clip(np.digitize(disp, edges) - 1, 0, LAYERS - 1)
cx, cy = W / 2, H / 2

ff = subprocess.Popen(["ffmpeg","-y","-loglevel","error","-f","rawvideo","-pix_fmt","bgr24","-s",f"{W}x{H}","-r",str(FPS),"-i","-",
                       "-c:v","libx264","-preset","veryfast","-crf","20","-pix_fmt","yuv420p","-movflags","+faststart",out], stdin=subprocess.PIPE)
t0 = time.time(); hole_ratio = []
for f in range(FPS * SEC):
    ph = 2 * np.pi * f / (FPS * SEC)
    dx, dy, z = AMP_X * W * np.sin(ph), AMP_Y * H * np.sin(2 * ph), ZOOM * (0.5 - 0.5 * np.cos(ph))
    canvas = np.zeros_like(img); filled = np.zeros((H, W), np.uint8)
    for k in range(LAYERS):                          # 먼 층부터 그려서 가까운 층이 덮도록
        m = (layer_id == k).astype(np.uint8)
        if not m.any(): continue
        dk = (edges[k] + edges[k + 1]) / 2
        s = 1 + z * dk
        M = np.float32([[s, 0, (1 - s) * cx + dx * dk], [0, s, (1 - s) * cy + dy * dk]])
        wi = cv2.warpAffine(img, M, (W, H), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT)
        wm = cv2.warpAffine(m, M, (W, H), flags=cv2.INTER_NEAREST)
        canvas[wm > 0] = wi[wm > 0]; filled |= wm
    holes = (filled == 0).astype(np.uint8)
    hole_ratio.append(holes.mean())
    if inpaint and holes.any():
        canvas = cv2.inpaint(canvas, cv2.dilate(holes, np.ones((3, 3), np.uint8)), 3, cv2.INPAINT_TELEA)
    ff.stdin.write(canvas.tobytes())
ff.stdin.close(); ff.wait()
print(f"frames={FPS*SEC} size={W}x{H} render={time.time()-t0:.1f}s holes_avg={100*np.mean(hole_ratio):.2f}% holes_max={100*np.max(hole_ratio):.2f}%")

!python parallax.py photos/bukchon.jpg depth/bukchon.npy bukchon_parallax.mp4
!python parallax.py photos/bukchon.jpg depth/bukchon.npy bukchon_noinpaint.mp4 --no-inpaint