📟 PaGeR-Metric-Depth Model Card

PaGeR-Metric-Depth is the depth-only, metric-scale variant of PaGeR released with our paper:

• Paper: Unified Panoramic Geometry Estimation via Multi-View Foundation Models — arXiv:2605.26368

From a single equirectangular (ERP) panorama, it produces a metric depth map in metres in a single forward pass — directly from the depth head, without a separate scale head. There is no SI-depth-plus-scale composition step: the single output already lives in metres, and no indoor/outdoor routing is applied at inference time.

If you instead want both scale-invariant depth and metric depth from the same panorama (plus surface normals and a sky mask), use the unified prs-eth/PaGeR checkpoint, which predicts SI depth with a dense head and recovers metric depth by multiplying it with a single global scale predicted by a parallel indoor/outdoor scale head.

You can also browse the rest of our PaGeR HF collection or try the interactive demo.

Model Details

• Developed by: Vukasin Bozic, Isidora Slavkovic, Dominik Narnhofer, Nando Metzger, Denis Rozumny, Konrad Schindler, Nikolai Kalischek.
• Model type: Feed-forward, multi-view foundation-model adaptation for single-image panoramic metric depth estimation.
• Backbone: Depth Anything 3 (da3-giant, ViT-Giant), repurposed for cubemap-based multi-view processing of the panorama.
• Inputs: A single ERP panorama, internally projected onto a 6-face cubemap at 504 px per face.
• Output: Metric depth in metres at panoramic resolution, predicted directly by a single depth head (no SI depth + scale-head decomposition, no indoor/outdoor routing).
• Resolution: Designed for high-resolution ERP inputs, up to 3K.
• License: CC BY-NC 4.0 — academic / non-commercial use only. The released weights are derivative works of the Depth Anything 3 da3-giant backbone, released by ByteDance under CC BY-NC 4.0, and inherit that restriction. Commercial use is not permitted.
• Resources for more information: Project Website, Paper, Code.

Other released checkpoints

Checkpoint	Hugging Face id	Depth	Normals	Sky
PaGeR (unified, recommended)	prs-eth/PaGeR	✅	✅	✅
PaGeR-Metric-Depth (this card)	prs-eth/PaGeR-metric-depth	✅ (metric)
PaGeR-Normals	prs-eth/PaGeR-normals		✅

Usage

A minimal Python snippet that runs the depth-only model on a single panorama and produces metric depth in one forward pass. The snippet assumes you have cloned the repository and pip install -e . ed it, so that src.pager is importable; checkpoint weights and config are streamed from the Hub on first use.

import matplotlib.pyplot as plt
import numpy as np
import torch
from huggingface_hub import hf_hub_download
from omegaconf import OmegaConf
from PIL import Image

from src.pager import Pager
from src.utils.geometry_utils import erp_to_cubemap
from src.utils.utils import prepare_depth_for_logging

checkpoint = "prs-eth/PaGeR-metric-depth"
device = torch.device("cuda")

# 1. Load the model config from the Hub and instantiate Pager.
config_path = hf_hub_download(repo_id=checkpoint, filename="config.yaml")
cfg = OmegaConf.load(config_path)

pager = Pager(checkpoint, cfg=cfg, device=device)
pager.get_intrinsics_extrinsics(image_size=cfg.face_size, fov=getattr(cfg, "cube_fov", 90.0))
pager.model.to(device).eval()

# 2. Load a panorama and project it to the 6-face cubemap PaGeR consumes.
panorama = np.array(Image.open("assets/examples/apartment_synth.jpg").convert("RGB")) / 255.0
panorama = torch.from_numpy(panorama).permute(2, 0, 1).float() * 2 - 1
rgb_cubemap = erp_to_cubemap(panorama, face_w=cfg.face_size,
                             fov=getattr(cfg, "cube_fov", 90.0)).unsqueeze(0).to(device)

# 3. Run one forward pass. The depth head is the only head in this
#    checkpoint, and its output is already in metres — no scale-head
#    composition and no indoor / outdoor routing.
with torch.inference_mode():
    pred = pager(rgb_cubemap, dtype=torch.float16)

# 4. Convert the raw depth output into an ERP-resolution metric depth array.
#    ``sky_mask=None`` because this checkpoint has no sky head, so unbounded
#    regions are left as predicted instead of being filled to ``MAX_DEPTH``.
cmap = plt.get_cmap("Spectral")
H, W = panorama.shape[-2:]
depth_metric, depth_viz = prepare_depth_for_logging(
    pager, pred["depth"][0], None, (H, W), cmap,
)

depth_metric is a (1, H, W) float32 array of metric depth (metres) at the input panorama resolution; depth_viz is the uint8 Spectral-coloured preview. If you also need sky filling, surface normals, or scale-invariant depth from the same model, use the unified prs-eth/PaGeR checkpoint instead. See the GitHub repository for the full CLI (inference.py), evaluation scripts, the Gradio demo (app.py), and the point-cloud exporter.

Citation

If you use this checkpoint in your work, please cite:

@article{bozic2026pager,
  title   = {Unified Panoramic Geometry Estimation via Multi-View Foundation Models},
  author  = {Bozic, Vukasin and Slavkovic, Isidora and Narnhofer, Dominik and
             Metzger, Nando and Rozumny, Denis and Schindler, Konrad and
             Kalischek, Nikolai},
  journal = {arXiv preprint arXiv:2605.26368},
  year    = {2026}
}