MetricTrail: File List

MetricTrail: File List

At a Glance

Item Value
Repository nvidia/MetricTrail
Publisher guide NVIDIA: models and licenses
Published 2026-11-05
License nvidia-open-model-license
Formats PyTorch (pth)
Source type Primary source (the publisher itself)

Values determined by this site’s code when the information was collected. Dates are JST.

Overview

NVIDIA has released MetricTrail 1.0, a model that estimates camera motion trajectories and frame-by-frame absolute metric depth from long RGB image sequences. This model is a tool developed for research into visual odometry (VO) and 3D spatial reconstruction.

It accepts chronologically ordered RGB image sequences and camera parameters (or optionally, synchronized left-right stereo image sequences) as input, and outputs per-frame camera trajectories, estimated camera intrinsic parameters, and frame-level metric depth and masks.

Specifications

The main specifications and configuration of the released MetricTrail are as follows:

  • Parameter Count: The DINO-DPVO checkpoint contains 3,425,860 (3.43 million) trainable parameters (100 FP32 weight/bias tensors). This excludes the frozen DINOv3 backbone, external MoGe-2 depth models, etc.
  • Architecture: A trainable recurrent visual odometry configuration combining features from a frozen visual foundation model (DINOv3-S/16), a frozen MoGe-2 metric depth provider, DPVO’s sparse patch-matching network, and trainable residual feature fusion adapters. It includes explicit bundle adjustment (BA).
  • Input Specifications: Chronologically ordered RGB image sequences (PNG format or KITTI NPZ format uint8 [N,3,H,W]) and camera parameters. Depending on the configuration, an inventory of at least 16 images is required.
  • Output Specifications: Camera trajectories c2w and inverse transformation w2c (shape [N,4,4]), camera intrinsic parameters intrinsics (shape [N,4]), cached metric depth (FP32 [N,H,W], in meters), and provider masks (uint8 [N,H,W]).
  • Inference Resolution Settings: 280 x 504 is used for Canonical KITTI and VBR configurations, 378 x 518 for Oxford, and 434 x 574 for 7Scenes evaluation.
  • License and Terms of Use: Released exclusively for research and development purposes.

Performance

These are the benchmark evaluation results published in the model card. Trajectory accuracy (Average ATE: Absolute Trajectory Error) and 3D reconstruction evaluation scores across multiple datasets are shown.

Trajectory Accuracy (Average ATE)

Benchmark / configuration Average ATE
KITTI Odometry, RGB-only calibration, without LC 14.05 m
KITTI Odometry, RGB-only calibration, with LC 9.78 m
KITTI Odometry, supplied intrinsics, with LC 7.39 m
KITTI Odometry, calibrated stereo, with LC 3.00 m
Oxford Spires, RGB-only calibration, without / with LC 1.77 / 1.77 m
VBR, RGB-only calibration with revisit focal refinement, without / with LC 16.36 / 10.88 m
7Scenes, RGB-only calibration, local / with global BA 6.7 / 6.3 cm
TUM RGB-D, RGB-only calibration, local / global BA / global BA plus refinement 8.4 / 4.9 / 4.4 cm
TUM RGB-D, supplied intrinsics, local / global BA / global BA plus refinement 7.5 / 4.1 / 3.7 cm
LaMAria, RGB-only calibration / supplied intrinsics 8.73 / 8.58 m
Wild-SLAM MoCap, RGB-only calibration / supplied intrinsics 2.70 / 1.65 cm

3D Reconstruction Evaluation

Benchmark CD (m, lower is better) F1 (%, higher is better) Threshold
7Scenes 0.04 97.60 0.25 m
TUM-Dynamic 0.13 89.58 0.25 m
Oxford Spires 0.98 95.12 4 m

Looking at the evaluation results, accuracy tends to improve significantly when combining external camera intrinsics (supplied intrinsics), synchronized stereo (calibrated stereo), loop closure (LC), and global BA. For example, in KITTI Odometry, the average ATE is 14.05 m with RGB-only calibration without LC, but the error improves to 3.00 m when using calibrated stereo combined with LC. While it achieves excellent estimation accuracy in the centimeter range for indoor environments like 7Scenes, TUM RGB-D, and Wild-SLAM MoCap (which includes moving objects), accuracy differences based on scene scale and conditions are observed, such as meter-level errors in environments with long travel distances like VBR or outdoor scenes like LaMAria.

Strengths and Use Cases

MetricTrail specializes in high-precision recovery of camera motion trajectories and frame-by-frame absolute metric depth from long video sequences. It is designed for research into 3D spatial reconstruction, SLAM, and visual odometry (VO) technologies in the fields of computer vision, graphics, simulation, and robotics.

Specifically, the following research applications are envisioned:

  • Camera Motion Estimation and 3D Reconstruction in Long Videos: Suitable for research into estimating consistent camera trajectories and metric depth from long, continuous image sequences. The internal DPVO frame buffer has a default capacity of 32,768 frames, making it capable of handling large-scale sequences of thousands to tens of thousands of frames.
  • Comparative Verification of Diverse Camera Configurations: It supports multiple setups, including pre-calibrated monocular cameras, an RGB-only mode that estimates camera intrinsics from image sequences alone, and synchronized parallel stereo cameras, allowing for accuracy comparisons and behavioral verification under different input conditions.
  • Processing Diverse Real-World Indoor and Outdoor Data: It has a track record of verification in a wide range of environments, such as vehicle driving data like KITTI, indoor handheld camera data like 7Scenes and TUM RGB-D, outdoor pedestrian data like Oxford Spires, and scenes containing dynamic objects like Wild-SLAM MoCap.
  • Integrated Research on Monocular Metric Depth and Sparse Optimization: It allows for the verification of hybrid optimization methods that utilize the output of an independent monocular depth estimation model (MoGe-2) as geometric initial values and soft constraints, while maintaining multi-view consistency through local bundle adjustment.

Note that the MetricTrail CLI outputs camera trajectory data (NPZ format) and frame-by-frame metric depth and masks (RAW/JSON cache) directly; it does not have the functionality to output dense point cloud data or polygon meshes directly to files. To perform 3D shape reconstruction, a separate post-processing pipeline is required to back-project using the output camera trajectories, depth maps, and camera intrinsics. Additionally, the range where depth estimation is considered valid is limited to 0.2–500m in the camera Z-axis direction; tracking will stop if a frame consists only of values outside this range or invalid values.

For training, a total of 240,000 clips (15 frames each) sampled from five synthetic simulation and game datasets—TartanAir, TartanGround, CarlaOcc, LightwheelOcc, and OmniWorld-Game—were used, and fine-tuning was performed only in synthetic environments that do not contain personal information of real individuals.

Distributed Files

Weight files published in nvidia/MetricTrail, listed by this site from the Hugging Face API. Sizes are the actual file sizes.

File Size
dino_dpvo.pth 14MB

How to Get It

MetricTrail’s source code and related files are available in the nvidia/MetricTrail repository on Hugging Face.

The distribution format and steps required for execution are as follows:

  • Repository Structure and Weight Acquisition: The source repository itself does not contain the model weight files. The pre-trained DINO-DPVO checkpoint (dino_dpvo_multidataset15k.pth, PyTorch format) is provided separately on Hugging Face. When using it, place the downloaded weight file in ckpt/dino_dpvo_multidataset15k.pth or specify the path in paths.dino_dpvo_checkpoint within the configuration file.
  • External Model Dependencies: You must also individually download and prepare the DINOv3 used as a frozen backbone (dinov3_vits16_pretrain_lvd1689m-08c60483.pth), MoGe-2 for metric depth estimation (Ruicheng/moge-2-vitl), and any necessary external models for calibration such as RoMa.
  • Supported Environment: The documented operating environment is Linux x86_64, Python 3.10, PyTorch 2.5.1, and CUDA 12.4. Additional libraries such as xformers, yacs, OpenCV, Pillow, and SciPy are required. Verification is documented using NVIDIA Ampere generation (A100) hardware, and a CUDA-capable GPU is required to run the tracking pipeline.
  • Building Custom CUDA Extensions: Since the distribution does not include pre-compiled binaries, you must build the three DPVO CUDA extensions (cuda_corr, cuda_ba, and lietorch_backends) from source within the inference environment before running tracking. Building requires a compatible C++ compiler, the CUDA toolkit including nvcc, and Eigen 3.4.0 header files.
  • Execution Command: The main tracking process is executed with the following command (defaults to cuda:0):
    bash PYTHONNOUSERSITE=1 python -m metrictrail.cli --config <path_to_config_file> If performing optional Loop Correction, prepare a candidate pair JSON generated by an external tool and execute the dedicated CLI that runs on the CPU: bash python -m metrictrail.lc_cli --config <path_to_config_file> --case <case_name> --candidate-file <path_to_candidate_json> --candidate-sha256 <sha256_of_candidate_file>

Can You Run It Locally?

The publisher distributes this model as PyTorch (pth).

License — nvidia-open-model-license: A custom license from the publisher. Check the original terms directly, including whether commercial use is permitted.

Compiled by this site’s code from the published formats and the license field. License summaries are not legal advice — check the publisher’s original terms before relying on them.

Our Own Measurements

Measurements We Did Not Take

We have not confirmed that this site meets the commercial-use terms of this model’s license (nvidia-open-model-license). Because this site carries advertising, we did not run the model (no CPU run, answers, quantization comparison, conversion or generation).

Related Articles

What to Read Next

Sources