What is SLAM?

SLAM or Simultaneous Localization and Mapping refers to a technology that allows an autonomous mobile robot to concurrently build a map of an unknown environment while tracking its own location within it. With the help of LiDAR sensors and camera, SLAM performs two main functions:

• Localization: Involves determining the robot’s position and orientation within the environment.
• Mapping: Process of creating a representation of the surrounding.

One of the main challenges for Autonomous Mobile Robot localization and mapping is that both are interrelated. A map is essential for accurate localization and knowing one’s location is critical to build an accurate map. SLAM algorithms can address this by updating the environmental map and the robot’s position in real-time, based on the sensor data received. SLAM has enabled multiple applications in the field of robotics, autonomous vehicles, augmented reality, virtual reality, and drones.

SLAM Architecture

A typical SLAM workflow has two stages—front end and back-end. The data from various sensors like LiDAR and cameras work as an input to SLAM’s front-end that is responsible for immediate processing, including feature extraction and matching, data processing, building sub-maps, and motion estimation. This helps in determining the agent’s current position. The position information along with other processed data is then fed into the back end that focuses on global consistency and long-term accuracy. The back end works on performing functions like loop closures and scan matching to recognize the revisited locations, graph optimization using frameworks, and global map optimization to refine the entire map and trajectory, ultimately producing a coherent map for the environment.

Key Challenges in SLAM Implementation

• Large Scale and Long-term: Maintaining accurate maps and real-time robot position over long periods and large areas is difficult. A small estimation error can add over time as a robot explores a large area or works for extended periods of time, resulting in significant drift and irregularities in the map.
• Processing Time for Each Frame: The SLAM system must process data faster or at the same rate as the new data is received to function in real-time. A lag between the robot’s actual and estimated states can be crucial for autonomous navigation.
• Odometry Drift: It refers to the accumulation of errors in the robot’s estimated position over time. This occurs because odometry relies on sensor data integration (like wheel encoder counts or visual data) to track movement, and these sensors can be imperfect, leading to errors that progressively worsen as the robot travels.
• Environmental Variations: Extreme changes in light, temperature, and surroundings.
• Kidnapped Robot Problem: This is a classic SLAM challenge where the robot is suddenly and unexpectedly relocated to an unknown position within an already mapped environment without its knowledge.
• Dynamic Obstacle: Existence of moving objects in the surrounding, such as cars, pedestrians, and other robots.

To address the above-mentioned challenges, developers need to focus on reducing the processing time of new sensor data points by SLAM via hardware acceleration. There are also cutting-edge algorithms developed to handle these complexities. One example is Real-Time Appearance-based Mapping, or RTMAP. It is an open-source framework that is well known for its strong loop closure mechanism and real-time capabilities, both of which are essential for long-term consistency. It has various important features that make it versatile and efficient including:

• Multi-sensor Integration: RTMAP can handle data from multiple sensors including stereo cameras, 3D LiDARs, and odometry.
• Appearance-based Approach: It uses visual information or appearance of place for tasks like identifying previously visited locations that are essential for reliable localization.
• Robust localization is guaranteed by its design, even in difficult or dynamic environments.
• 2D/3D occupancy map generation: RTMAP can generate 2D and 3D occupancy maps that offer comprehensive volumetric or grid-based depiction.
• Multi-session Mapping: It directly addresses the kidnapped robot problem by enabling the system to re-localize itself, following an unplanned relocation or to combine maps from various exploration sessions.
• Being Robotics Operating System (ROS) compatible makes it easy to integrate into already developed robotic platforms.

RTMAP Architecture

A typical RTMAP workflow starts synchronization of raw data from various sensors by time stamp to guarantee consistency. Short-term memory or STM processes instantaneous sensory data and creates local map segments or features of the current environment with synchronized input. To correct-accumulate positional drift, a critical component called loop closure and proximity detection continuously compares recent data from STM with historical data kept in long–term memory/LTM to identify revisited locations. 

Graph optimization fine-tunes all estimated robot poles and map elements for global consistency. Lastly, these optimized elements are combined by global map assembling to create a solid, logical representation of the surrounding, frequently produced as an occupancy grid map, to allow efficient re-localization and loop closure over a long period of time. The LTM acts as a persistent repository, effectively storing historical map data.

RTMAP framework can be divided into two parts—front-end and back-end. The front-end can be illustrated as a strategic point within the RTMAP framework where parallel processing can significantly enhance performance, encompass the synchronization of raw sensor data, and subsequently process with short-term memory. It is noted as computationally heavy as it is responsible for initial data processing, feature extraction, segmentation, clustering, and local map generation.

It is often a bottleneck due to the intense parallel computation required. Especially when dealing with dense point cloud data. By targeting these front-end operations for the Graphic Processing Unit (GPU) acceleration, the system can achieve faster throughput that is critical for maintaining real-time performance in demanding SLAM applications.

While the back-end can be illustrated as the blocks comprising of loop closure and proximity detection, graph optimization, and global map assembling, all supported by the long-term memory. These back-end modules are primarily responsible for ensuring global map consistency, correcting accumulated errors over time, recognizing revisited locations, and efficiently storing and retrieving historical map data. While these tasks are critical for map accuracy and global integrity, these generally involve less fine-grained massive data to be parallelly computed or offloaded to the GPU compared to initial sensor processing.

Therefore, the primary focus for implementing the GPU acceleration is concentrated on the front-end of the pipeline, especially targeting the short-term memory module. Where the most intensive pound frame operation, such as dense point cloud processing, feature extraction occurs and exhibits significant data parallelism, making them ideal candidates for leveraging the GPU’s capability to achieve substantial real-time throughput gains.

What is GPU Acceleration?

GPU acceleration is a technique that leverages the parallel processing capabilities of GPUs to enhance the performance of applications. GPU acceleration is imperative for SLAM due to the pervasive data parallelism within its computational primitives. Tasks such as high-throughput feature descriptor computation, per-pixel/per-point segmentation, and large-scale non-linear optimization are efficiently mapped to the GPU’s SIMD architecture, enabling the requisite real-time throughput.

The developer needs to choose a suitable parallel programming model like CUDA, OpenCL, OpenACC, or OpenMP that involves offloading kernels to the GPU, requiring efficient host-to-device memory transfer and optimizing memory access patterns leveraging vendor-optimized libraries for heavy computational needs and minimum communication for real-time performance.

As shown in the block diagram, compute intensive parallelizable tasks, a small part of application code, are offloaded to GPU’s many cores for fast processing. The rest of the sequential CPU code is handled by the CPU’s few powerful cores, both results combined to yield the final production or application output, illustrating how specialized parallel processing on the GPU accelerates overall performance.

With a strong focus on AMR and machine vision solutions, eInfochips has developed multiple benchmarking Proof of Concepts (PoC) across different platforms and frameworks to help our clients with the best possible solution for their end application. To know more, please reach out marketing@einfochips.com.