# Difference Between Follow, Birdeye, Static, and Pivot Camera Modes in LingBot‑Map

> Understand the differences between follow, birdeye, static, and pivot camera modes in LingBot-Map. Learn how each mode calculates camera position and target from your trajectory.

- Repository: [Robbyant/lingbot-map](https://github.com/Robbyant/lingbot-map)
- Tags: how-to-guide
- Published: 2026-07-26

---

**LingBot‑Map’s offline renderer supports four distinct camera modes—follow, birdeye, static, and pivot—that determine how the virtual eye‑position and look‑at target are calculated from the input trajectory.**

The LingBot‑Map repository provides an offline trajectory renderer that generates cinematic camera paths from YAML configuration files. Understanding the **difference between follow, birdeye, static, and pivot camera modes** is essential for crafting everything from chase sequences to overview shots. Each mode implements a specific mathematical model for deriving the camera’s eye position and look‑at vector relative to the scene’s trajectory data.

## Follow Mode: The Chase Camera

**Follow** mode creates a chase camera that trails the input trajectory while keeping the vehicle or sensor near the center of the frame. This mode applies relative offsets to the current pose using the scene’s scale as a reference unit.

The renderer calculates the eye position by offsetting backward and upward from the trajectory pose:

```

eye = pose + back_offset·forward + up_offset·up
lookat = pose + look_offset·forward

```

The `back_offset`, `up_offset`, and `look_offset` parameters are expressed as fractions of the scene scale. An optional `smooth_window` parameter applies a low‑pass filter to the trajectory before computing offsets, reducing jitter in handheld or noisy datasets.

```yaml
- mode: follow
  frames: [0, 1500]
  back_offset: 0.3
  up_offset: 0.08
  look_offset: 0.4
  smooth_window: 30

```

This mode is implemented in the renderer’s camera‑path construction logic, where it samples the smoothed trajectory and applies the offset vectors frame‑by‑frame.

## Birdeye Mode: Top‑Down Reveal

**Birdeye** mode lifts the camera vertically to produce a top‑down view of the entire scene. Unlike follow mode, the camera does not move laterally; it remains fixed horizontally while the eye height scales with the scene dimensions.

The eye height is computed as:

```

eye_height = reveal_height_mult × scene_scale

```

The look‑at point remains anchored at the trajectory’s center, creating a static overhead perspective perfect for hero shots or map overviews. This mode requires only the `reveal_height_mult` parameter.

```yaml
- mode: birdeye
  frames: [1500, 1800]
  reveal_height_mult: 2.5

```

## Static Mode: Fixed Viewpoint

**Static** mode locks both the eye position and look‑at target to their values at the segment’s start frame. The renderer samples the input pose once at the first frame of the segment and maintains constant vectors for the entire duration.

```yaml
- mode: static
  frames: [1800, 2100]

```

Use this mode for cut‑scenes where the camera must remain absolutely fixed, or when transitioning between dynamic segments without introducing motion.

## Pivot Mode: Orbiting Look‑At

**Pivot** mode keeps the eye position fixed (as in static mode) but updates the look‑at target each frame to track the current trajectory pose. This creates the effect of the camera pivoting around a fixed observation point while the subject moves through the scene.

The eye is sampled from the first frame of the segment, while the look‑at vector is recalculated every frame to point at the current pose:

```python

# Conceptual implementation based on lingbot_map/render/camera_path.py

eye = first_frame_pose[:3, 3]  # Fixed

lookat = current_pose[:3, 3]   # Updates per frame

```

```yaml
- mode: pivot
  frames: [2100, -1]

```

## Configuring Multi‑Segment Camera Paths

You can chain these modes in a single YAML configuration to create complex cinematic sequences. The `transition` parameter controls how many frames the renderer blends between adjacent segments.

```yaml
camera:
  fov: 60.0
  transition: 30
  segments:
    - mode: follow
      frames: [0, 1500]
      back_offset: 0.3
      up_offset: 0.08
      look_offset: 0.4
      smooth_window: 30

    - mode: birdeye
      frames: [1500, 1800]
      reveal_height_mult: 2.5

    - mode: static
      frames: [1800, 2100]

    - mode: pivot
      frames: [2100, -1]

```

## Command‑Line Overrides

When running [`demo_render/batch_demo.py`](https://github.com/Robbyant/lingbot-map/blob/main/demo_render/batch_demo.py), you can override the YAML configuration to force a specific mode for the entire video duration. This is useful for quick testing without modifying config files.

```bash
python demo_render/batch_demo.py \
  --video_path demo.mp4 \
  --output_folder out/ \
  --config demo_render/config/default.yaml \
  --camera_mode pivot

```

## Implementation Details

The camera mode logic resides in the renderer module that parses YAML configurations from `demo_render/config/*.yaml` (including [`default.yaml`](https://github.com/Robbyant/lingbot-map/blob/main/default.yaml), [`indoor.yaml`](https://github.com/Robbyant/lingbot-map/blob/main/indoor.yaml), and [`outdoor_drive.yaml`](https://github.com/Robbyant/lingbot-map/blob/main/outdoor_drive.yaml)). According to the source code in [`demo_render/batch_demo.py`](https://github.com/Robbyant/lingbot-map/blob/main/demo_render/batch_demo.py) and the conceptual implementation in [`lingbot_map/render/camera_path.py`](https://github.com/Robbyant/lingbot-map/blob/main/lingbot_map/render/camera_path.py), the renderer branches on the `mode` field and applies the corresponding mathematics:

- **Follow** uses offset vectors relative to the current pose
- **Birdeye** calculates a fixed height based on scene scale
- **Static** and **Pivot** both sample the initial pose, differing only in whether the look‑at target updates per frame

All four modes share underlying data structures (timestamps, poses, and optional offsets) but differ in **when** and **how** the eye and look‑at vectors are updated. The official documentation in [`README.md`](https://github.com/Robbyant/lingbot-map/blob/main/README.md) (lines 503‑509) defines the tunable fields for each mode.

## Summary

- **Follow** creates a chase camera with configurable backward/upward offsets and optional trajectory smoothing.
- **Birdeye** generates a static top‑down view using a height multiplier relative to scene scale.
- **Static** locks both eye and look‑at to the segment’s starting pose for fixed viewpoints.
- **Pivot** maintains a fixed eye position while sweeping the look‑at target along the trajectory.

## Frequently Asked Questions

### What is the difference between follow and pivot camera modes?

**Follow** moves the camera eye along the trajectory with configurable offsets, while **pivot** keeps the eye fixed at the segment’s start position and only rotates the look‑at target to track the trajectory. Follow creates a moving chase view, whereas pivot creates an orbit‑around effect.

### How do I set the camera height in birdeye mode?

Set the `reveal_height_mult` parameter in the YAML segment configuration. The renderer multiplies this value by the scene scale to determine the absolute eye height above the trajectory center.

### Can I combine multiple camera modes in a single video?

Yes. Define multiple segments in the YAML `camera.segments` array, each with its own `mode` and `frames` range. Use the `transition` parameter to specify how many frames to blend between segments for smooth cuts.

### Where are the camera mode parameters documented?

The parameters are documented in the [`README.md`](https://github.com/Robbyant/lingbot-map/blob/main/README.md) file at lines 503‑509 in the Robbyant/lingbot‑map repository. Example configurations are provided in [`demo_render/config/default.yaml`](https://github.com/Robbyant/lingbot-map/blob/main/demo_render/config/default.yaml) and the other preset files.