Localization with a saved map

Run Simple navigation first — it saves a map named example-map. This example loads that map by name and starts the navigation engine in localization mode.

Python

"""Localization example — loads example-map saved by navigation-simple."""

import time

from olo import Client
from olo.platform import NavigationMode, NavigationObservedState, Pose2D

EXAMPLE_MAP_NAME = "example-map"


with Client() as client:
    configs = client.platform.navigation.get_configs(NavigationMode.LOCALIZATION)
    if not configs:
        raise RuntimeError("No navigation configs support localization mode")
    config = configs[0]

    maps = list(client.platform.navigation.list_maps())
    map_info = next((m for m in maps if m.name == EXAMPLE_MAP_NAME), None)
    if map_info is None:
        raise RuntimeError(f"Map {EXAMPLE_MAP_NAME!r} not found — run navigation-simple.py first")
    print(f"Using navigation config: {config.name = }, {config.id = }")
    print(f"Using navigation map: {map_info.name = } [{map_info.id = }]")

    # Start localization
    client.platform.navigation.start(
        mode=NavigationMode.LOCALIZATION,
        config_id=config.id,
        map_id=map_info.id,
        initial_pose=Pose2D(x=0.0, y=0.0, yaw=0.0),
    )

    # Wait until the navigation engine is ready
    last_state = None
    deadline = time.time() + 60
    while time.time() < deadline:
        info = client.platform.navigation.deployment()
        state = info.observed.state if info.observed else None
        if state != last_state:
            print(f"Navigation engine: {state}")
            last_state = state
        if state == NavigationObservedState.READY:
            break
        if state == NavigationObservedState.FAILED:
            raise RuntimeError(f"Navigation failed to launch: {info.observed.error_message}")
        time.sleep(2)
    else:
        raise TimeoutError(f"Navigation engine did not become ready within 60s (last state: {last_state})")

    # Fetch the loaded map from the robot
    robot = client.robot()
    grid = robot.navigation.get_map()
    print(f"Loaded map: {grid.width}x{grid.height} resolution={grid.resolution:.2f} m")

TypeScript

/** Localization example — loads `example-map` saved by navigation-simple.ts. */

import { connect } from "olo/web";

const EXAMPLE_MAP_NAME = "example-map";

const client = connect();

const configs = await client.platform.navigation.getConfigs("localization");
if (configs.length === 0) {
  throw new Error("No navigation configs support localization mode");
}
const config = configs[0];

const maps = await client.platform.navigation.listMaps();
const mapInfo = maps.find((m) => m.name === EXAMPLE_MAP_NAME);
if (!mapInfo) {
  throw new Error(`Map "${EXAMPLE_MAP_NAME}" not found — run navigation-simple.ts first`);
}
console.log(`Using navigation config: name=${config.name}, id=${config.id}`);
console.log(`Using navigation map: name=${mapInfo.name} [id=${mapInfo.id}]`);

// Start localization
await client.platform.navigation.start({
  mode: "localization",
  configId: config.id,
  mapId: mapInfo.id,
  initialPose: { x: 0, y: 0, yaw: 0 },
});

// Wait until the navigation engine is ready
let lastState: string | undefined;
const deadline = Date.now() + 60_000;
while (Date.now() < deadline) {
  const info = await client.platform.navigation.deployment();
  const state = info.observed?.state;
  if (state !== lastState) {
    console.log(`Navigation engine: ${state}`);
    lastState = state;
  }
  if (state === "ready") break;
  if (state === "failed") {
    throw new Error(`Navigation failed to launch: ${info.observed?.errorMessage}`);
  }
  await new Promise((r) => setTimeout(r, 2000));
}
if (lastState !== "ready") {
  throw new Error(`Navigation engine did not become ready within 60s (last state: ${lastState})`);
}

// Fetch the loaded map from the robot
const robot = await client.robot();
const grid = await robot.navigation.getMap();
console.log(`Loaded map: ${grid.width}x${grid.height} resolution=${grid.resolution.toFixed(2)} m`);