Probabilistic Robot Localization Tutorial

Introduction to Probabilistic Localization in Robotics

Probabilistic localization is a cornerstone of modern robotics, enabling robots to estimate their position in an environment despite sensor noise and uncertainty. In this tutorial, we'll explore the concepts behind CDA 4621 Lab 4, focusing on how to use landmarks and normal probabilities to localize a robot within a 5x5 grid. Whether you're building a self-driving car or a robot vacuum, these principles are essential for robust navigation. Think of it like a GPS for indoor robots—but using landmarks like colored cylinders instead of satellites.

Setting Up the Global Reference Frame and Grid

In Webots 2023b with the FAIRIS robot, the arena is divided into a 5x5 grid of 1-meter cells. The global reference frame has the positive y-axis pointing North, positive x-axis East, and the origin at the center. Each cell is numbered from 1 to 25. At each corner of the arena, there's a colored cylinder (yellow, red, blue, green) that serves as a landmark. These landmarks are crucial for localization because they provide fixed reference points.

To navigate, your robot must understand its position relative to these landmarks. For example, if the robot detects a red cylinder to its north and a blue cylinder to its east, it can narrow down which grid cell it occupies. This is similar to how a TikTok trend might use color-coded filters to identify locations—except here, it's about precise coordinates.

Grid Cell Numbering and Wall Configuration

Each grid cell has a wall configuration represented as a 25x4 matrix with WNES (West, North, East, South) entries. You'll need to implement a data structure to store whether each cell has walls in these directions. For instance, a cell with a wall on its north side would have 'W' for north and 'O' for others. This helps the robot plan paths and avoid obstacles.

# Example wall configuration matrix (first 5 cells)
wall_config = [
    ['O', 'W', 'O', 'O'],  # Cell 1
    ['O', 'W', 'O', 'O'],  # Cell 2
    ['O', 'W', 'O', 'O'],  # Cell 3
    ['O', 'W', 'O', 'O'],  # Cell 4
    ['O', 'W', 'O', 'O'],  # Cell 5
    # ... up to 25 cells
]

Sensor Integration for Localization

To estimate position, the robot uses four sensors: encoders, compass, lidar, and camera with object recognition. Each provides unique data:

Encoders: Track wheel rotation to estimate displacement and orientation changes.
Compass: Provides heading relative to the world frame (degrees from east).
Lidar: 360-degree range measurements for obstacle detection and mapping.
Camera with Object Recognition: Identifies colored cylinders (landmarks) for visual localization.

Combining these sensors is like how a gaming AI uses multiple inputs to determine its position on a map—except here, the map is a physical grid.

Localization Using Landmarks and Normal Probabilities

The core of this lab is using distance measurements to landmarks to compute the probability of being in each grid cell. For each cell, you compare the measured distance to a landmark (DR-Li) with the precomputed distance from the cell's center to that landmark (DCN-Li). The likelihood is calculated using a normal (Gaussian) probability density function.

Normal Probability Calculation

The formula for the normal probability density is:

f(s) = (1 / sqrt(2 * pi * sigma^2)) * exp(-(s - mu)^2 / (2 * sigma^2))

Where:

s: Precomputed distance from grid cell to landmark
mu: Measured distance from robot to landmark
sigma: Standard deviation (measurement noise)

Implement this in Python:

import math

def calculate_normdist(s, mu, sigma):
    """
    Calculate normal probability density.
    """
    coefficient = 1 / (math.sqrt(2 * math.pi * sigma**2))
    exponent = -((s - mu)**2) / (2 * sigma**2)
    return coefficient * math.exp(exponent)

Combining Probabilities from Multiple Landmarks

Since there are four landmarks, you'll compute the probability for each cell given all observations. Multiply the probabilities from each landmark (assuming independence) to get the overall likelihood for that cell. Then normalize across all cells to get a probability distribution.

def compute_cell_probabilities(measured_distances, landmark_distances, sigma):
    """
    measured_distances: dict mapping landmark_id to measured distance
    landmark_distances: 2D list [cell][landmark_id] of precomputed distances
    sigma: standard deviation
    Returns: list of probabilities for each cell (0-indexed)
    """
    num_cells = len(landmark_distances)
    probs = [1.0] * num_cells
    for cell in range(num_cells):
        for lid, mu in measured_distances.items():
            s = landmark_distances[cell][lid]
            probs[cell] *= calculate_normdist(s, mu, sigma)
    # Normalize
    total = sum(probs)
    return [p / total for p in probs]

Practical Example: Localizing in the Grid

Imagine your robot is at an unknown position. It measures distances to the yellow and blue cylinders: 2.5 m to yellow, 3.1 m to blue. Using the precomputed distances for each cell, you compute probabilities. The cell with the highest probability is your estimated location. This is similar to how an AI app might triangulate your position using Wi-Fi signals—but here, it's based on color-coded landmarks.

For instance, if the robot is in cell 13 (center), the distances to the four corners might be around 2.83 m each. If actual measurements match closely, cell 13 will have a high probability.

Integrating Sensor Data for Robust Estimation

To make localization robust, combine encoder and compass data with landmark observations. Use encoders to predict motion (odometry) and then correct with landmark measurements—a classic Kalman filter approach. In this lab, you'll implement a simpler version: after each movement, update probabilities using the motion model (e.g., convolution with a Gaussian kernel) and then incorporate new landmark observations.

Handling Noise and Uncertainty

Sensor noise is inevitable. Set sigma based on expected error: for lidar, maybe 0.1 m; for camera-based distance estimation, 0.2 m. You can tune these values experimentally. Remember, higher sigma spreads probability wider, making the robot less certain.

Tips for Success in Lab 4

Start by implementing the wall configuration matrix and verifying it matches the arena.
Test your normal probability function with known values to ensure correctness.
Use the compass to align the robot's heading before measuring distances to landmarks.
Visualize probabilities by printing the grid with percentages—this helps debug.

Pro tip: In Webots, you can use the supervisor API to get ground truth position for testing, but for the final submission, your robot must rely only on sensors.

Connecting to Real-World Trends

Probabilistic localization is used in autonomous delivery robots (like those from Starship Technologies) and even in AI-powered warehouse robots (e.g., Amazon's Proteus). The same math underlies GPS localization in your smartphone. As of June 2026, new AI models are using similar probabilistic methods to navigate virtual environments in gaming, like in the latest open-world games where NPCs use landmark-based navigation.

Conclusion

By mastering probabilistic localization with landmarks, you're building skills that are directly applicable to modern robotics and AI. This lab gives you hands-on experience with sensor fusion, probability theory, and grid-based navigation—all essential for careers in robotics, autonomous vehicles, and smart systems. Good luck, and remember to test each component step by step!