Kompass Core

Kompass Core is a high-performance, GPU-accelerated library for motion planning, mapping, and control in robot navigation systems. The core algorithms are implemented in C++ with seamless Python bindings. It also implements third party integrations with OMPL and FCL. The Kompass philosophy is to be blazzingly fast and highly reliable, by implementing GPGPU supported parallelized algorithms which are agnostic to underlying hardware. Thus Kompass Core can be run on CPUs or GPUs from a wide variety of vendors, making it easy for robot hardware manufacturers to switch underlying compute architecture without overhauling their software stack.

This package is developed to be used with Kompass for creating navigation stacks in ROS2. For detailed usage documentation, check Kompass docs.

• Install Kompass Core 🛠️
• Check the Package Overview
• See Benchmarking Results for different platforms
• To use Kompass Core on your robot with ROS2, check the Kompass framework 🚀

Installation

Install with GPU Support (Recommended)

• To install kompass-core with GPU support, on any Ubuntu 20+ (including Jetpack) based machine, you can simply run the following:

curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash

This script will install all relevant dependencies, including AdaptiveCPP and install the latest version of kompass-core from source. It is good practice to read the script first.

Installing with pip (CPU only)

pip install kompass-core

Wheels are available on Pypi for linux x86_64 and aarch64 architectures. Please note that the version available on Pypi does not support GPU acceleration yet.

Installation Contents

The following three packages will become available once kompass-core is installed.

• kompass_cpp: Core C++ library for control, collision checking, and mapping algorithms.
• kompass_core: Python bindings for Kompass core C++ library with front-end classes for configuration and high-level logic.
• omplpy: Bespoke python bindings for the Open Motion Planning Library (OMPL).

Package Overview

The package includes modules for mapping, control, trajectory planning, and vision-based tracking algorithms, with GPU acceleration support and Python bindings via nanobind.

Control Module

• Includes a rich set of optimized C++ control strategies implementations and their python wrappers.
• Supports GPU-accelerated trajectory sampling and cost evaluation with customizable weights for sampling based controllers.
• Internally implements feature-based bounding box tracking and depth detection for enhanced vision-based tracking control.

Mapping Module

• Implements efficient local mapping and occupancy grid generation algorithms, with configuration support for various scan models and grid resolution settings.
• Supports GPU-accelerated mapping for real-time performance.
• Fuses point clouds from multiple 3D sensors into a single occupancy grid with per-sensor free-space carving.

Utilities Module

• Provides collision checking utilities and critical zone detection to ensure safe navigation, including both CPU and GPU implementations. Critical zone checking fuses point clouds from multiple 3D sensors into one safety decision (minimum factor across sensors).
• Logger utilities for runtime diagnostics.
• Linear state-space Kalman filter implementation for state estimation (C++).
• Spline interpolation utilities for path control.

Data Types and Models Modules

• Rich set of data types to represent paths, trajectories, controls, velocities, bounding boxes and various sensor data.
• Strongly-typed parameters and configuration classes to enable flexible tuning.
• Robot models and motion kinematics, supporting differential, omni-directional, and Ackermann robots. Along with geometry definitions, control limits and simulation-ready state representations.

Third Party Modules

Includes wrappers and integrations with external planning and collision libraries:

• FCL (Flexible Collision Library)

• OMPL (Open Motion Planning Library)

Benchmarking Results

The plots below visualize the performance differences across platforms for various components of the navigation stack. The Logarithmic Scale plot is essential for comparing CPU vs. GPU performance where differences can be orders of magnitude large. See the benchmarking details for how these plots were generated and what tasks were measured.

1. Performance (Logarithmic Scale)

Note: This chart excludes runs where power monitoring was active to ensure timing accuracy.

2. Power Consumption & Efficiency

Note: Efficiency is calculated as Operations per Joule (Throughput / Watts). Higher is better.

Copyright

The code in this distribution is Copyright (c) 2024 Automatika Robotics unless explicitly indicated otherwise.

Kompass Core is made available under the MIT license. Details can be found in the LICENSE file.

Contributions

Kompass Core has been developed in collaboration between Automatika Robotics and Inria. Contributions from the community are most welcome.