Repository files navigation

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 withOMPL andFCL. 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 withKompass for creating navigation stacks inROS2. For detailed usage documentation, check Kompassdocs.

• Install Kompass Core 🛠️
• Check thePackage Overview
• To use Kompass Core on your robot with ROS2, check theKompass framework 🚀

• 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, includingAdaptiveCPP and install the latest version of kompass-core from source. It is good practice to read thescript first.

• On Ubuntu versions >= 22.04, install dependencies by running the following:

sudo apt-get install libompl-dev libfcl-dev

• Then install kompass-core as follows:

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.

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

The package includes modules for mapping, control, trajectory planning, and vision-based tracking algorithms, withGPU acceleration support and Python bindings viananobind.

• Includes a rich set of optimized C++ control strategies implementations and their python wrappers.
• SupportsGPU-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.

• Implements efficient local mapping and occupancy grid generation algorithms, with configuration support for various laser models and grid resolution settings.
• SupportsGPU-accelerated mapping for real-time performance.

• Provides collision checking utilities and critical zone detection to ensure safe navigation, including both CPU and GPU implementations.
• Logger utilities for runtime diagnostics.
• Linear state-space Kalman filter implementation for state estimation (C++).
• Spline interpolation utilities for path control.

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

Includes wrappers and integrations with external planning and collision libraries:

• FCL (Flexible Collision Library)

• OMPL (Open Motion Planning Library)

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

Kompass Core has been developed in collaboration betweenAutomatika Robotics andInria. Contributions from the community are most welcome.