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

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.

- 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.

- 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.

- 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:

# 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

- 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.

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, 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.

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, indoor.yaml, and outdoor_drive.yaml). According to the source code in demo_render/batch_demo.py and the conceptual implementation in 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 (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 file at lines 503‑509 in the Robbyant/lingbot‑map repository. Example configurations are provided in demo_render/config/default.yaml and the other preset files.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}