# ATE vs RPE Trajectory Metrics: Understanding the Difference in SLAM Evaluation

> Understand ATE vs RPE trajectory metrics for SLAM evaluation. Discover how ATE measures global accuracy and RPE assesses local consistency for robust system performance analysis.

- Repository: [Robbyant/lingbot-map](https://github.com/Robbyant/lingbot-map)
- Tags: deep-dive
- Published: 2026-07-02

---

**TLDR:** **ATE measures global trajectory accuracy after Sim(3) alignment, while RPE measures local consistency between consecutive frames, providing complementary insights into SLAM system performance.**

The LingBot-Map repository implements both ATE (Absolute Trajectory Error) and RPE (Relative Pose Error) metrics in [`benchmark/benchmark/evaluation/trajectory.py`](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/benchmark/evaluation/trajectory.py) to evaluate camera-pose estimates. Understanding the difference between these trajectory metrics is essential for diagnosing whether errors stem from global drift or local inconsistency in visual odometry pipelines.

## What is ATE (Absolute Trajectory Error)?

**Absolute Trajectory Error (ATE)** measures the global deviation of an estimated trajectory from ground truth after an optimal **Sim(3)** alignment (translation, rotation, and scale). It provides a single scalar value that reflects the overall accuracy of the entire trajectory.

In [`benchmark/benchmark/evaluation/trajectory.py`](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/benchmark/evaluation/trajectory.py), the implementation uses the **evo** library to compute ATE:

```python

# Sim(3) alignment occurs here

traj_est_aligned.align(...)

# ATE calculation using absolute pose error (APE)

evo.main_ape.ape(traj_ref, traj_est_aligned, 
                 pose_relation=PoseRelation.translation_part)

```

The RMSE of the translation part is returned as the `ate` metric【/cache/repos/github.com/Robbyant/lingbot-map/main/benchmark/benchmark/evaluation/trajectory.py#L79-L89】. This global alignment compensates for any initial pose or scale differences, isolating the pure trajectory shape error.

## What is RPE (Relative Pose Error)?

**Relative Pose Error (RPE)** measures local drift between successive frames, quantifying how well the relative motion between frame *i* and frame *i + Δ* is reproduced. Unlike ATE, RPE evaluates short-term consistency independent of global alignment.

The LingBot-Map implementation splits RPE into two components:

- **Rotation error**: Computed using `evo.main_rpe.rpe` with `pose_relation=PoseRelation.rotation_angle_deg`【/cache/repos/github.com/Robbyant/lingbot-map/main/benchmark/benchmark/evaluation/trajectory.py#L90-L98】
- **Translation error**: Computed using `evo.main_rpe.rpe` with `pose_relation=PoseRelation.translation_part`【/cache/repos/github.com/Robbyant/lingbot-map/main/benchmark/benchmark/evaluation/trajectory.py#L104-L112】

Both calculations use `delta=1` to evaluate only adjacent frames, respecting the same alignment settings as ATE when `self.align` is enabled.

## Why Both Metrics Matter Together

While **ATE** tells you *how far* the reconstructed path deviates from the true path after the best possible similarity transform, **RPE** reveals *how consistently* the algorithm predicts motion between neighboring frames.

A low ATE can mask significant local drift if the global alignment absorbs errors. Conversely, high RPE indicates frame-to-frame instability that could cause jitter or failure in applications requiring smooth motion. Together, they provide a comprehensive diagnostic: ATE for overall accuracy, RPE for local stability.

## Practical Implementation in LingBot-Map

The repository provides the `TrajectoryEvaluator` class to streamline metric computation. Below is a minimal example demonstrating how to calculate both ATE and RPE trajectory metrics:

```python
from pathlib import Path
from lingbot_map.utils.load_fn import BSSLoader
from benchmark.benchmark.evaluation.trajectory import TrajectoryEvaluator

# Prepare loaders for ground-truth and predicted trajectories

gt_loader = BSSLoader(Path("data/ground_truth"))
pred_loader = BSSLoader(Path("outputs/my_method"))

# Create evaluator with Sim(3) alignment enabled

evaluator = TrajectoryEvaluator(align=True, correct_scale=True)

# Run evaluation - returns dict with ATE & RPE values

metrics = evaluator.evaluate(gt_loader, pred_loader)

print("Absolute Trajectory Error (ATE):", metrics["ate"])
print("Relative Pose Error - translation:", metrics["rpe_trans"])
print("Relative Pose Error - rotation (deg):", metrics["rpe_rot"])

```

The same class generates trajectory visualizations:

```python
evaluator.save_visualization(
    gt_loader,
    pred_loader,
    output_dir=Path("results/vis")
)

```

These code paths exercise the exact `evo` library calls that compute ATE and RPE, as defined in the repository's [`pyproject.toml`](https://github.com/Robbyant/lingbot-map/blob/main/pyproject.toml) dependencies.

## Summary

- **ATE** measures global trajectory accuracy after optimal Sim(3) alignment, returning a single RMSE value for the translation component.
- **RPE** evaluates local consistency between adjacent frames (`delta=1`), split into separate rotation (degrees) and translation (meters) components.
- The LingBot-Map implementation relies on the **evo** library, wrapping `evo.main_ape.ape` for ATE and `evo.main_rpe.rpe` for RPE.
- Use **ATE** to assess overall SLAM accuracy and **RPE** to diagnose frame-to-frame drift and short-term stability.
- Both metrics are accessible through the `TrajectoryEvaluator` class in [`benchmark/benchmark/evaluation/trajectory.py`](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/benchmark/evaluation/trajectory.py).

## Frequently Asked Questions

### When should I prioritize ATE over RPE?

Use **ATE** when you need to evaluate the final map quality or global path accuracy, such as in large-scale mapping or autonomous navigation where the end-to-end path accuracy matters more than intermediate wobbles. ATE is the standard metric for benchmark leaderboards comparing SLAM systems.

### What does delta=1 mean in RPE calculation?

The `delta=1` parameter specifies that RPE calculates error between consecutive frames only (frame *i* and frame *i+1*). Larger delta values would compare frames separated by multiple time steps, which is useful for analyzing drift over specific temporal windows or distances.

### How does Sim(3) alignment affect ATE results?

Sim(3) alignment (similarity transform) optimizes the 7 degrees of freedom (translation, rotation, scale) to best fit the estimated trajectory to ground truth before computing error. This removes initialization errors and scale ambiguities, ensuring ATE measures only the intrinsic trajectory shape accuracy rather than global coordinate system differences.

### Can RPE detect errors that ATE misses?

Yes. **RPE** can reveal local drift, jitter, or scale inconsistencies that get absorbed by the global alignment in ATE. For example, if a SLAM system oscillates around the true path but returns to the correct end position, ATE might appear low while RPE exposes the frame-to-frame instability.