update

InfiniDepth/utils/hf_demo_utils.py

@@ -12,9 +12,8 @@ from huggingface_hub import hf_hub_download
 
 from .inference_utils import (
     build_scaled_intrinsics_matrix,
-    has_missing_intrinsics,
     prepare_metric_depth_inputs,
-    resolve_camera_intrinsics,
+    resolve_camera_intrinsics_for_inference,
     resolve_output_size_from_mode,
 )
 from .io_utils import depth2pcd, depth_to_disparity
@@ -143,9 +142,29 @@ class DemoResult:
     rgb: np.ndarray
     depth_source_label: str
     output_size: tuple[int, int]
+    intrinsics_source_label: str
     used_default_intrinsics: bool
 
 
+@dataclass
+class GPUInferenceResult:
+    """Raw GPU inference outputs, all transferred to CPU numpy arrays."""
+    pred_depthmap_np: np.ndarray
+    query_coord_np: np.ndarray
+    pred_depth_np: np.ndarray
+    image_tensor_np: np.ndarray
+    depth_source_label: str
+    intrinsics_source_label: str
+    h_out: int
+    w_out: int
+    org_h: int
+    org_w: int
+    fx_out: float
+    fy_out: float
+    cx_out: float
+    cy_out: float
+
+
 class ModelCache:
     def __init__(self):
         self._cache: dict[tuple[str, str], Any] = {}
@@ -207,10 +226,18 @@ def _resolve_depth_inputs(
     input_size: tuple[int, int],
     image: torch.Tensor,
     device: torch.device,
-) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, str]:
+) -> tuple[
+    torch.Tensor,
+    torch.Tensor,
+    torch.Tensor,
+    torch.Tensor,
+    str,
+    str,
+    Optional[tuple[float, float, float, float]],
+]:
     input_depth_path = depth_path if depth_path else None
     moge2_pretrained = resolve_moge2_pretrained()
-    gt_depth, prompt_depth, gt_depth_mask, used_input_depth = prepare_metric_depth_inputs(
+    gt_depth, prompt_depth, gt_depth_mask, used_input_depth, moge2_intrinsics = prepare_metric_depth_inputs(
         input_depth_path=input_depth_path,
         input_size=input_size,
         image=image,
@@ -220,7 +247,7 @@ def _resolve_depth_inputs(
     )
     prompt_mask = prompt_depth > 0
     depth_source_label = "uploaded depth" if used_input_depth else "MoGe-2 prior"
-    return gt_depth, prompt_depth, gt_depth_mask, prompt_mask, depth_source_label
+    return gt_depth, prompt_depth, gt_depth_mask, prompt_mask, depth_source_label, moge2_pretrained, moge2_intrinsics
 
 
 def _colorize_predicted_depth(pred_depthmap: torch.Tensor) -> np.ndarray:
@@ -357,7 +384,7 @@ def run_single_image_demo(
     if model_type == "InfiniDepth_DC":
         assert depth_path is not None and os.path.exists(depth_path), "InfiniDepth_DC requires a valid input depth map for depth completion. Please provide --input_depth_path."
 
-    gt_depth, prompt_depth, gt_depth_mask, prompt_mask, depth_source_label = _resolve_depth_inputs(
+    gt_depth, prompt_depth, gt_depth_mask, prompt_mask, depth_source_label, moge2_pretrained, moge2_intrinsics = _resolve_depth_inputs(
         depth_path=depth_path,
         input_size=input_size,
         image=image,
@@ -392,7 +419,18 @@ def run_single_image_demo(
     depth_vis = _colorize_predicted_depth(pred_depthmap)
     _report_stage(stage_callback, "demo:depth_colorized")
 
-    fx, fy, cx, cy = resolve_camera_intrinsics(fx_org, fy_org, cx_org, cy_org, org_h, org_w)
+    fx, fy, cx, cy, intrinsics_source_label = resolve_camera_intrinsics_for_inference(
+        fx_org=fx_org,
+        fy_org=fy_org,
+        cx_org=cx_org,
+        cy_org=cy_org,
+        org_h=org_h,
+        org_w=org_w,
+        image=image,
+        moge2_pretrained=moge2_pretrained,
+        moge2_intrinsics=moge2_intrinsics,
+    )
+    Log.info(f"Camera intrinsics source resolved: {intrinsics_source_label}")
     fx_out, fy_out, cx_out, cy_out, _ = build_scaled_intrinsics_matrix(
         fx_org=fx,
         fy_org=fy,
@@ -434,5 +472,186 @@ def run_single_image_demo(
         rgb=rgb,
         depth_source_label=depth_source_label,
         output_size=(h_out, w_out),
-        used_default_intrinsics=has_missing_intrinsics(fx_org, fy_org, cx_org, cy_org),
+        intrinsics_source_label=intrinsics_source_label,
+        used_default_intrinsics=intrinsics_source_label == "default",
+    )
+
+
+def run_gpu_inference(
+    image_np: np.ndarray,
+    depth_path: Optional[str],
+    model_type: str,
+    input_size_text: str,
+    output_resolution_mode: str,
+    upsample_ratio: int,
+    fx_org: Optional[float] = None,
+    fy_org: Optional[float] = None,
+    cx_org: Optional[float] = None,
+    cy_org: Optional[float] = None,
+    model_cache: Optional[ModelCache] = None,
+    stage_callback: Optional[Callable[[str], None]] = None,
+) -> GPUInferenceResult:
+    """Run only GPU-intensive inference. All outputs are moved to CPU numpy before return.
+
+    This is designed for HuggingFace ZeroGPU where GPU time is limited: only the actual
+    CUDA work (MoGe-2, model inference, intrinsics estimation) runs here. CPU-heavy
+    post-processing (colorization, point cloud, file I/O) should happen outside the
+    ``@spaces.GPU`` decorated caller.
+    """
+    image_shape = tuple(int(d) for d in image_np.shape) if image_np is not None else None
+    _report_stage(stage_callback, "gpu:start")
+    Log.info(
+        f"run_gpu_inference: model_type={model_type}, input_size={input_size_text}, "
+        f"output_resolution_mode={output_resolution_mode}, upsample_ratio={upsample_ratio}, "
+        f"has_depth={bool(depth_path)}, image_shape={image_shape}, "
+        f"cuda_available={torch.cuda.is_available()}"
+    )
+    if not torch.cuda.is_available():
+        raise RuntimeError(
+            "No CUDA GPU is available. If using Hugging Face ZeroGPU, "
+            "decorate the Gradio inference function with @spaces.GPU and enable queue()."
+        )
+
+    input_size = _parse_image_size(input_size_text)
+    if upsample_ratio < 1 or upsample_ratio > 8:
+        raise ValueError("upsample_ratio must be in [1, 8]")
+    output_size = input_size
+    device = torch.device("cuda")
+
+    _debug = os.getenv("INFINIDEPTH_DEBUG_GPU", "0") == "1"
+
+    image, org_h, org_w = _prepare_image_tensor(image_np, input_size, device)
+    _report_stage(stage_callback, "gpu:image_prepared")
+    if _debug:
+        torch.cuda.synchronize()
+        Log.info(f"[GPU-DEBUG] image_prepared: GPU mem allocated={torch.cuda.memory_allocated(device) / 1e6:.1f}MB")
+
+    h_in, w_in = input_size
+    h_out, w_out = resolve_output_size_from_mode(
+        output_resolution_mode=output_resolution_mode,
+        org_h=org_h, org_w=org_w, h=h_in, w=w_in,
+        output_size=output_size, upsample_ratio=upsample_ratio,
+    )
+
+    if model_type == "InfiniDepth_DC":
+        assert depth_path is not None and os.path.exists(depth_path), \
+            "InfiniDepth_DC requires a valid input depth map for depth completion."
+
+    _report_stage(stage_callback, "gpu:resolving_depth")
+    gt_depth, prompt_depth, gt_depth_mask, prompt_mask, depth_source_label, moge2_pretrained, moge2_intrinsics = \
+        _resolve_depth_inputs(depth_path=depth_path, input_size=input_size, image=image, device=device)
+    if _debug:
+        torch.cuda.synchronize()
+        Log.info(f"[GPU-DEBUG] depth_resolved: GPU mem allocated={torch.cuda.memory_allocated(device) / 1e6:.1f}MB")
+    _report_stage(stage_callback, f"gpu:depth_resolved source={depth_source_label}")
+    Log.info(f"Depth source resolved: {depth_source_label}")
+
+    gt = depth_to_disparity(gt_depth)
+    prompt = depth_to_disparity(prompt_depth)
+    prompt_mask = prompt > 0
+
+    ckpt_path = resolve_checkpoint_path(model_type)
+    model_cache = model_cache or ModelCache()
+    model = model_cache.get(model_type=model_type, model_path=ckpt_path)
+    if _debug:
+        torch.cuda.synchronize()
+        Log.info(f"[GPU-DEBUG] model_loaded: GPU mem allocated={torch.cuda.memory_allocated(device) / 1e6:.1f}MB")
+    _report_stage(stage_callback, "gpu:model_loaded")
+
+    query_2d_uniform_coord = make_2d_uniform_coord((h_out, w_out)).unsqueeze(0).to(device)
+    _report_stage(stage_callback, "gpu:inference_started")
+    pred_depth, _ = model.inference(
+        image=image, query_coord=query_2d_uniform_coord,
+        gt_depth=gt, gt_depth_mask=gt_depth_mask,
+        prompt_depth=prompt, prompt_mask=prompt_mask,
+    )
+    if _debug:
+        torch.cuda.synchronize()
+        Log.info(f"[GPU-DEBUG] inference_finished: GPU mem allocated={torch.cuda.memory_allocated(device) / 1e6:.1f}MB")
+    _report_stage(stage_callback, "gpu:inference_finished")
+    Log.info(f"Model inference completed: output_size={h_out}x{w_out}")
+
+    pred_depthmap = pred_depth.permute(0, 2, 1).reshape(1, 1, h_out, w_out)
+
+    fx, fy, cx, cy, intrinsics_source_label = resolve_camera_intrinsics_for_inference(
+        fx_org=fx_org, fy_org=fy_org, cx_org=cx_org, cy_org=cy_org,
+        org_h=org_h, org_w=org_w, image=image,
+        moge2_pretrained=moge2_pretrained, moge2_intrinsics=moge2_intrinsics,
+    )
+    Log.info(f"Camera intrinsics source: {intrinsics_source_label}")
+    fx_out, fy_out, cx_out, cy_out, _ = build_scaled_intrinsics_matrix(
+        fx_org=fx, fy_org=fy, cx_org=cx, cy_org=cy,
+        org_h=org_h, org_w=org_w, h=h_in, w=w_in, device=device,
+    )
+
+    # Transfer all GPU tensors to CPU numpy before returning
+    _report_stage(stage_callback, "gpu:transferring_to_cpu")
+    result = GPUInferenceResult(
+        pred_depthmap_np=pred_depthmap[0, 0].detach().cpu().numpy().astype(np.float32),
+        query_coord_np=query_2d_uniform_coord.detach().cpu().numpy().astype(np.float32),
+        pred_depth_np=pred_depth.detach().cpu().numpy().astype(np.float32),
+        image_tensor_np=image.detach().cpu().numpy().astype(np.float32),
+        depth_source_label=depth_source_label,
+        intrinsics_source_label=intrinsics_source_label,
+        h_out=h_out, w_out=w_out,
+        org_h=org_h, org_w=org_w,
+        fx_out=float(fx_out), fy_out=float(fy_out),
+        cx_out=float(cx_out), cy_out=float(cy_out),
+    )
+    _report_stage(stage_callback, "gpu:complete")
+    return result
+
+
+def postprocess_gpu_result(
+    gpu_result: GPUInferenceResult,
+    max_points_preview: int,
+    stage_callback: Optional[Callable[[str], None]] = None,
+) -> DemoResult:
+    """CPU-only post-processing: colorize depth, build point cloud, save artifacts.
+
+    This does not require a GPU and should be called *outside* the ``@spaces.GPU``
+    decorated function to avoid consuming ZeroGPU quota.
+    """
+    _report_stage(stage_callback, "post:start")
+
+    # Colorize depth (CPU tensors are fine here)
+    pred_depthmap_t = torch.from_numpy(gpu_result.pred_depthmap_np).unsqueeze(0).unsqueeze(0)
+    depth_vis = _colorize_predicted_depth(pred_depthmap_t)
+    _report_stage(stage_callback, "post:depth_colorized")
+
+    # Save depth numpy
+    output_dir = tempfile.mkdtemp(prefix="infinidepth_post_")
+    depth_npy_path = os.path.join(output_dir, "depth.npy")
+    np.save(depth_npy_path, gpu_result.pred_depthmap_np)
+
+    # Build and save point cloud (open3d, CPU-only)
+    ply_path = os.path.join(output_dir, "point_cloud.ply")
+    query_coord_t = torch.from_numpy(gpu_result.query_coord_np)
+    pred_depth_t = torch.from_numpy(gpu_result.pred_depth_np)
+    image_t = torch.from_numpy(gpu_result.image_tensor_np)
+
+    xyz, rgb = _build_and_save_point_cloud(
+        query_coord=query_coord_t,
+        pred_depth=pred_depth_t,
+        rgb_image=image_t,
+        fx=gpu_result.fx_out, fy=gpu_result.fy_out,
+        cx=gpu_result.cx_out, cy=gpu_result.cy_out,
+        output_path=ply_path,
+        max_points_preview=int(max_points_preview),
+    )
+    _report_stage(stage_callback, "post:pointcloud_saved")
+    Log.info(
+        f"Post-processing done: depth_npy={depth_npy_path}, ply={ply_path}, preview_points={xyz.shape[0]}"
+    )
+
+    return DemoResult(
+        depth_vis=depth_vis,
+        depth_npy_path=depth_npy_path,
+        ply_path=ply_path,
+        xyz=xyz,
+        rgb=rgb,
+        depth_source_label=gpu_result.depth_source_label,
+        output_size=(gpu_result.h_out, gpu_result.w_out),
+        intrinsics_source_label=gpu_result.intrinsics_source_label,
+        used_default_intrinsics=gpu_result.intrinsics_source_label == "default",
     )

InfiniDepth/utils/inference_utils.py

@@ -9,7 +9,10 @@ import torch.nn.functional as F
 import open3d as o3d
 
 from .io_utils import load_depth
-from .moge_utils import estimate_metric_depth_with_moge2
+from .moge_utils import (
+    estimate_camera_intrinsics_with_moge2,
+    estimate_metric_depth_and_intrinsics_with_moge2,
+)
 from .vis_utils import build_sky_model, run_skyseg
 
 
@@ -37,15 +40,23 @@ def resolve_camera_intrinsics(
     cy_org: Optional[float],
     org_h: int,
     org_w: int,
+    fallback_intrinsics: Optional[tuple[float, float, float, float]] = None,
 ) -> tuple[float, float, float, float]:
     default_focal = float(max(org_h, org_w))
     default_cx = float(org_w) / 2.0
     default_cy = float(org_h) / 2.0
 
-    fx = float(fx_org) if fx_org is not None else default_focal
-    fy = float(fy_org) if fy_org is not None else default_focal
-    cx = float(cx_org) if cx_org is not None else default_cx
-    cy = float(cy_org) if cy_org is not None else default_cy
+    fallback_fx, fallback_fy, fallback_cx, fallback_cy = fallback_intrinsics or (
+        default_focal,
+        default_focal,
+        default_cx,
+        default_cy,
+    )
+
+    fx = float(fx_org) if fx_org is not None else float(fallback_fx)
+    fy = float(fy_org) if fy_org is not None else float(fallback_fy)
+    cx = float(cx_org) if cx_org is not None else float(fallback_cx)
+    cy = float(cy_org) if cy_org is not None else float(fallback_cy)
     return fx, fy, cx, cy
 
 
@@ -100,7 +111,7 @@ def prepare_metric_depth_inputs(
     moge2_pretrained: str,
     depth_load_kwargs: Optional[dict] = None,
     moge2_kwargs: Optional[dict] = None,
-) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, bool]:
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, bool, Optional[tuple[float, float, float, float]]]:
     depth_load_kwargs = depth_load_kwargs or {}
     moge2_kwargs = moge2_kwargs or {}
 
@@ -113,9 +124,9 @@ def prepare_metric_depth_inputs(
         gt_depth = gt_depth.to(device)
         prompt_depth = prompt_depth.to(device)
         gt_depth_mask = gt_depth_mask.to(device)
-        return gt_depth, prompt_depth, gt_depth_mask, True
+        return gt_depth, prompt_depth, gt_depth_mask, True, None
 
-    pred_depth, gt_depth_mask = estimate_metric_depth_with_moge2(
+    pred_depth, gt_depth_mask, moge2_intrinsics = estimate_metric_depth_and_intrinsics_with_moge2(
         image=image,
         pretrained_model_name_or_path=moge2_pretrained,
         **moge2_kwargs,
@@ -123,7 +134,59 @@ def prepare_metric_depth_inputs(
     gt_depth = pred_depth.clone().to(device)
     prompt_depth = pred_depth.clone().to(device)
     gt_depth_mask = gt_depth_mask.to(device)
-    return gt_depth, prompt_depth, gt_depth_mask, False
+    return gt_depth, prompt_depth, gt_depth_mask, False, moge2_intrinsics
+
+
+def resolve_camera_intrinsics_for_inference(
+    fx_org: Optional[float],
+    fy_org: Optional[float],
+    cx_org: Optional[float],
+    cy_org: Optional[float],
+    org_h: int,
+    org_w: int,
+    image: torch.Tensor,
+    moge2_pretrained: str,
+    moge2_intrinsics: Optional[tuple[float, float, float, float]] = None,
+) -> tuple[float, float, float, float, str]:
+    intrinsics_source = "custom"
+    fallback_intrinsics = None
+
+    if has_missing_intrinsics(fx_org, fy_org, cx_org, cy_org):
+        if moge2_intrinsics is None:
+            try:
+                moge2_intrinsics = estimate_camera_intrinsics_with_moge2(
+                    image=image,
+                    pretrained_model_name_or_path=moge2_pretrained,
+                )
+            except Exception as exc:
+                print(f"[Warning] Failed to estimate intrinsics with MoGe-2: {exc}")
+
+        if moge2_intrinsics is not None:
+            _, _, h, w = image.shape
+            fallback_intrinsics = scale_intrinsics(
+                fx=moge2_intrinsics[0],
+                fy=moge2_intrinsics[1],
+                cx=moge2_intrinsics[2],
+                cy=moge2_intrinsics[3],
+                org_h=h,
+                org_w=w,
+                h=org_h,
+                w=org_w,
+            )
+            intrinsics_source = "MoGe-2 estimate"
+        else:
+            intrinsics_source = "default"
+
+    fx, fy, cx, cy = resolve_camera_intrinsics(
+        fx_org=fx_org,
+        fy_org=fy_org,
+        cx_org=cx_org,
+        cy_org=cy_org,
+        org_h=org_h,
+        org_w=org_w,
+        fallback_intrinsics=fallback_intrinsics,
+    )
+    return fx, fy, cx, cy, intrinsics_source
 
 
 def build_scaled_intrinsics_matrix(
@@ -298,4 +361,4 @@ def build_camera_matrices(
         device=device,
     ).unsqueeze(0).expand(batch, -1, -1)
     extrinsics = torch.eye(4, dtype=torch.float32, device=device).unsqueeze(0).expand(batch, -1, -1)
-    return fx, fy, cx, cy, intrinsics, extrinsics
+    return fx, fy, cx, cy, intrinsics, extrinsics

InfiniDepth/utils/moge_utils.py

@@ -35,19 +35,40 @@ def _squeeze_hw(tensor: torch.Tensor, name: str) -> torch.Tensor:
     raise ValueError(f"Unexpected {name} shape from MoGe-2: {tuple(tensor.shape)}")
 
 
+def _squeeze_33(tensor: torch.Tensor, name: str) -> torch.Tensor:
+    if tensor.ndim == 2 and tensor.shape == (3, 3):
+        return tensor
+    if tensor.ndim == 3 and tensor.shape[0] == 1 and tensor.shape[1:] == (3, 3):
+        return tensor[0]
+    raise ValueError(f"Unexpected {name} shape from MoGe-2: {tuple(tensor.shape)}")
+
+
+def _normalized_intrinsics_to_pixel_intrinsics(
+    intrinsics: torch.Tensor,
+    height: int,
+    width: int,
+) -> tuple[float, float, float, float]:
+    intrinsics = _squeeze_33(intrinsics, "intrinsics")
+    fx = float(intrinsics[0, 0].item() * width)
+    fy = float(intrinsics[1, 1].item() * height)
+    cx = float(intrinsics[0, 2].item() * width - 0.5)
+    cy = float(intrinsics[1, 2].item() * height - 0.5)
+    return fx, fy, cx, cy
+
+
 @torch.no_grad()
-def estimate_metric_depth_with_moge2(
+def estimate_metric_depth_and_intrinsics_with_moge2(
     image: torch.Tensor,
     pretrained_model_name_or_path: str = "Ruicheng/moge-2-vitl-normal",
-) -> tuple[torch.Tensor, torch.Tensor]:
-    """Run MoGe-2 and return dense pred depth + valid mask in [1,1,H,W]."""
+) -> tuple[torch.Tensor, torch.Tensor, Optional[tuple[float, float, float, float]]]:
+    """Run MoGe-2 and return dense pred depth, valid mask, and optional pixel intrinsics."""
     if image.ndim != 4 or image.shape[0] != 1 or image.shape[1] != 3:
         raise ValueError(f"Expected image shape [1,3,H,W], got {tuple(image.shape)}")
 
     device = image.device
     model = _get_moge2_model(pretrained_model_name_or_path, device)
 
-    output = model.infer(image[0],apply_mask=True)
+    output = model.infer(image[0], apply_mask=True)
     if "depth" not in output:
         raise KeyError("MoGe-2 output missing key 'depth'.")
 
@@ -63,4 +84,42 @@ def estimate_metric_depth_with_moge2(
     valid_mask = mask_hw & torch.isfinite(depth_hw) & (depth_hw > 0)
     pred_depth = depth_hw * valid_mask.to(depth_hw.dtype)
 
-    return pred_depth.unsqueeze(0).unsqueeze(0), valid_mask.to(torch.float32).unsqueeze(0).unsqueeze(0)
+    moge2_intrinsics = None
+    output_intrinsics = output.get("intrinsics")
+    if output_intrinsics is not None:
+        height, width = image.shape[-2:]
+        moge2_intrinsics = _normalized_intrinsics_to_pixel_intrinsics(
+            output_intrinsics.to(device=device, dtype=torch.float32),
+            height=height,
+            width=width,
+        )
+
+    return (
+        pred_depth.unsqueeze(0).unsqueeze(0),
+        valid_mask.to(torch.float32).unsqueeze(0).unsqueeze(0),
+        moge2_intrinsics,
+    )
+
+
+@torch.no_grad()
+def estimate_metric_depth_with_moge2(
+    image: torch.Tensor,
+    pretrained_model_name_or_path: str = "Ruicheng/moge-2-vitl-normal",
+) -> tuple[torch.Tensor, torch.Tensor]:
+    pred_depth, valid_mask, _ = estimate_metric_depth_and_intrinsics_with_moge2(
+        image=image,
+        pretrained_model_name_or_path=pretrained_model_name_or_path,
+    )
+    return pred_depth, valid_mask
+
+
+@torch.no_grad()
+def estimate_camera_intrinsics_with_moge2(
+    image: torch.Tensor,
+    pretrained_model_name_or_path: str = "Ruicheng/moge-2-vitl-normal",
+) -> Optional[tuple[float, float, float, float]]:
+    _, _, intrinsics = estimate_metric_depth_and_intrinsics_with_moge2(
+        image=image,
+        pretrained_model_name_or_path=pretrained_model_name_or_path,
+    )
+    return intrinsics

app.py

@@ -23,7 +23,7 @@ import gradio as gr
 import numpy as np
 from PIL import Image
 
-from InfiniDepth.utils.hf_demo_utils import ModelCache, prepare_runtime_assets, run_single_image_demo
+from InfiniDepth.utils.hf_demo_utils import ModelCache, prepare_runtime_assets, run_gpu_inference, postprocess_gpu_result
 from InfiniDepth.utils.logger import Log
 
 try:
@@ -231,21 +231,22 @@ def _export_glb_from_points(xyz: np.ndarray, rgb: np.ndarray, output_path: Path)
     cloud.export(output_path.as_posix())
 
 
-def _run_demo_impl(
+@spaces.GPU(duration=120)
+def run_demo_gpu(
     image: np.ndarray,
     depth_file,
     model_type: str,
     input_size: str,
     output_resolution_mode: str,
     upsample_ratio: int,
-    max_points_preview: int,
     fx_org: Optional[float],
     fy_org: Optional[float],
     cx_org: Optional[float],
     cy_org: Optional[float],
     trace_path: str,
 ):
-    _append_trace(trace_path, "worker:entered _run_demo_impl")
+    """GPU-only inference. Returns a GPUInferenceResult with all data on CPU."""
+    _append_trace(trace_path, "worker:entered run_demo_gpu")
     if image is None:
         raise ValueError("Input RGB image is required")
 
@@ -253,15 +254,13 @@ def _run_demo_impl(
     if depth_file is not None:
         depth_path = depth_file if isinstance(depth_file, str) else depth_file.name
 
-    _append_trace(trace_path, f"worker:run_single_image_demo depth_path={depth_path}")
-    result = run_single_image_demo(
+    return run_gpu_inference(
         image_np=image,
         depth_path=depth_path,
         model_type=model_type,
         input_size_text=input_size,
         output_resolution_mode=output_resolution_mode,
         upsample_ratio=int(upsample_ratio),
-        max_points_preview=int(max_points_preview),
         fx_org=_none_if_invalid(fx_org),
         fy_org=_none_if_invalid(fy_org),
         cx_org=_none_if_invalid(cx_org),
@@ -269,68 +268,6 @@ def _run_demo_impl(
         model_cache=MODEL_CACHE,
         stage_callback=lambda stage: _append_trace(trace_path, stage),
     )
-    _append_trace(trace_path, "worker:prepare_output_dir")
-    output_dir = _prepare_output_dir()
-    glb_path = output_dir / "pointcloud.glb"
-    ply_path = output_dir / "pointcloud.ply"
-    depth_vis_path = output_dir / "depth_colorized.png"
-
-    _append_trace(trace_path, "worker:export_glb")
-    _export_glb_from_points(result.xyz, result.rgb, glb_path)
-    if os.path.exists(result.ply_path):
-        shutil.copy2(result.ply_path, ply_path)
-    depth_vis_uint8 = result.depth_vis if result.depth_vis.dtype == np.uint8 else result.depth_vis.astype(np.uint8)
-    Image.fromarray(depth_vis_uint8).save(depth_vis_path)
-
-    depth_npy_path = output_dir / "depth.npy"
-    if os.path.exists(result.depth_npy_path):
-        shutil.copy2(result.depth_npy_path, depth_npy_path)
-
-    download_files = [glb_path.as_posix(), depth_vis_path.as_posix()]
-    if depth_npy_path.exists():
-        download_files.append(depth_npy_path.as_posix())
-    if ply_path.exists():
-        download_files.append(ply_path.as_posix())
-
-    status = (
-        f"Done. Output depth: {result.output_size[0]}x{result.output_size[1]}. "
-        f"Depth source: {result.depth_source_label}. "
-        f"Preview points: {result.xyz.shape[0]}. "
-        f"Camera intrinsics: {'default' if result.used_default_intrinsics else 'custom'}."
-    )
-    _append_trace(trace_path, "worker:completed")
-    return result.depth_vis, glb_path.as_posix(), download_files, status
-
-
-@spaces.GPU(duration=180)
-def run_demo_gpu(
-    image: np.ndarray,
-    depth_file,
-    model_type: str,
-    input_size: str,
-    output_resolution_mode: str,
-    upsample_ratio: int,
-    max_points_preview: int,
-    fx_org: Optional[float],
-    fy_org: Optional[float],
-    cx_org: Optional[float],
-    cy_org: Optional[float],
-    trace_path: str,
-):
-    return _run_demo_impl(
-        image=image,
-        depth_file=depth_file,
-        model_type=model_type,
-        input_size=input_size,
-        output_resolution_mode=output_resolution_mode,
-        upsample_ratio=upsample_ratio,
-        max_points_preview=max_points_preview,
-        fx_org=fx_org,
-        fy_org=fy_org,
-        cx_org=cx_org,
-        cy_org=cy_org,
-        trace_path=trace_path,
-    )
 
 
 def run_demo(
@@ -360,32 +297,88 @@ def run_demo(
         f"depth_path={depth_path}, image_shape={image_shape}"
     )
     try:
-        result = run_demo_gpu(
+        # --- GPU-only inference (consumes ZeroGPU quota) ---
+        gpu_result = run_demo_gpu(
             image=image,
             depth_file=depth_file,
             model_type=model_type,
             input_size=input_size,
             output_resolution_mode=output_resolution_mode,
             upsample_ratio=upsample_ratio,
-            max_points_preview=max_points_preview,
             fx_org=fx_org,
             fy_org=fy_org,
             cx_org=cx_org,
             cy_org=cy_org,
             trace_path=trace_path,
         )
-        status_text = result[3] if isinstance(result, tuple) and len(result) == 4 else "Done."
-        Log.info(f"[{request_id}] run_demo success: {status_text}")
-        return result
+        _append_trace(trace_path, "ui:gpu_done, starting cpu postprocess")
+
+        # --- CPU post-processing (no GPU quota consumed) ---
+        result = postprocess_gpu_result(
+            gpu_result=gpu_result,
+            max_points_preview=int(max_points_preview),
+            stage_callback=lambda stage: _append_trace(trace_path, stage),
+        )
+        _append_trace(trace_path, "ui:postprocess_done, exporting files")
+
+        # --- File export ---
+        output_dir = _prepare_output_dir()
+        glb_path = output_dir / "pointcloud.glb"
+        ply_path = output_dir / "pointcloud.ply"
+        depth_vis_path = output_dir / "depth_colorized.png"
+
+        _export_glb_from_points(result.xyz, result.rgb, glb_path)
+        if os.path.exists(result.ply_path):
+            shutil.copy2(result.ply_path, ply_path)
+        depth_vis_uint8 = result.depth_vis if result.depth_vis.dtype == np.uint8 else result.depth_vis.astype(np.uint8)
+        Image.fromarray(depth_vis_uint8).save(depth_vis_path)
+
+        depth_npy_path = output_dir / "depth.npy"
+        if os.path.exists(result.depth_npy_path):
+            shutil.copy2(result.depth_npy_path, depth_npy_path)
+
+        download_files = [glb_path.as_posix(), depth_vis_path.as_posix()]
+        if depth_npy_path.exists():
+            download_files.append(depth_npy_path.as_posix())
+        if ply_path.exists():
+            download_files.append(ply_path.as_posix())
+
+        status = (
+            f"Done. Output depth: {result.output_size[0]}x{result.output_size[1]}. "
+            f"Depth source: {result.depth_source_label}. "
+            f"Preview points: {result.xyz.shape[0]}. "
+            f"Camera intrinsics: {result.intrinsics_source_label}."
+        )
+        _append_trace(trace_path, "ui:completed")
+        Log.info(f"[{request_id}] run_demo success: {status}")
+        return result.depth_vis, glb_path.as_posix(), download_files, status
     except Exception as exc:
         error_trace = traceback.format_exc()
         trace_summary = _read_trace(trace_path)
         Log.exception(f"[{request_id}] run_demo failed")
-        error_message = f"Error [{request_id}]: {exc}"
+
+        # Classify the error for clearer diagnostics
+        exc_type = type(exc).__name__
+        exc_module = type(exc).__module__ or ""
+        is_zerogpu_error = "spaces" in exc_module or "ZeroGPU" in str(exc) or "GPU task aborted" in str(exc)
+        if is_zerogpu_error:
+            error_message = (
+                f"[{request_id}] ZeroGPU error: {exc}\n\n"
+                "This is a HuggingFace ZeroGPU scheduling issue, not an inference bug.\n"
+                "Possible causes:\n"
+                "  - GPU quota exhausted (wait for quota to reset)\n"
+                "  - GPU task was preempted/aborted (try again)\n"
+                "  - duration too high for remaining quota"
+            )
+        else:
+            error_message = f"Error [{request_id}] ({exc_type}): {exc}"
+
         if trace_summary:
             error_message = f"{error_message}\n\nLast worker stages:\n{trace_summary}"
         if os.getenv("INFINIDEPTH_SHOW_TRACEBACK", "0") == "1":
             error_message = f"{error_message}\n\n{error_trace}"
+        # Always log full traceback to server logs (visible in HF Space Logs tab)
+        Log.error(f"[{request_id}] Full traceback:\n{error_trace}")
         return None, None, [], error_message
 
 
@@ -449,6 +442,7 @@ with gr.Blocks(title="InfiniDepth Demo", theme=gr.themes.Soft(), css=CUSTOM_CSS,
             run_button = gr.Button("Generate Depth + 3D", variant="primary", elem_id="run-btn")
             gr.Markdown(
                 "Tips: when a depth map is uploaded it will be used automatically, otherwise the demo falls back to MoGe-2. "
+                "If camera intrinsics are missing, the demo first tries MoGe-2 estimates before image-size defaults. "
                 "Use lower preview points for faster 3D interaction."
             )