Crate mapping_algorithms

mapping-rs

A SLAM ecosystem for Rust

⚠️ Unstable API ⚠️

Warning: this crate is in early development, breaking API changes are to be expected.

Usage

Add this to your Cargo.toml:

[dependencies]
mapping-algorithms = { git = "https://github.com/EmilyMatt/mapping-rs.git" }
mapping-suites = { git = "https://github.com/EmilyMatt/mapping-rs.git" }

Features

no_std support

While the std feature is enabled by default, these crates were designed with no_std support in mind,
provided that a memory allocator is configured (these crate do use the alloc crate).

It can be easily achieved like so:

[dependencies.mapping-algorithms]
default-features = false

[dependencies.mapping-suites]
default-features = false

tracing

These crates provides profiling and instrumentation insight via the tracing crate.

To use it, simply enable the tracing feature in your Cargo.toml, and use your choice of a subscriber. Note that different functions have different tracing levels.

Since each and every function is instrumented, be sure to remember the overhead for enabling tracing.

pregenerated

These crates heavily rely on generics, and suffers severe performance penalties in debug
(We strive to be very fast in release though).

For this purpose, a pregenerated feature exists, which provides access to public pre-generated functions for most use cases and types.
This is recommended for most users, and allows bypassing the generics overhead.

Usage:

In your Cargo.toml:

# Enables the pregenerated feature (This is enabled by default)
[dependencies.mapping-algorithms]
features = ["pregenerated"]

# Compiles these crates with max optimizations
[profile.dev.package.mapping-algorithms]
opt-level = 3

[profile.dev.package.mapping-suites]
opt-level = 3

Code example:

// Instead of doing this:
let res = icp::icp::<f32, 2 > (...); // Uses generics, uses your project's optimization level

// Do this(Runs much faster):
let res = icp::single_precision::icp_2d(...); // Is a regular function, uses the crate's optimization level

The pregenerated macro is enabled by default.

Contributing

If you would like to contribute, we welcome your contributions. Please be sure to check out our CONTRIBUTING.md

Modules

• ackermann
  Implementation of an Ackerman vehicle steering model.
• bresenham
  Implementations of Bresenham line algorithms.
• haversine
  Implementation of the Haversine formula, which calculate the distance and bearing between two points
• icp
  An Iterative Closest Point algorithm, useful in matching Point Clouds. Contains a 2D implementation when using the 2d feature, and a 3D implementation when using the 3d feature.
• kd_tree
  A K-Dimensional Tree data structure, useful for various geo-spatial computations.
• pathfinding
  A Collection of pathfinding algorithms
• point_in_convex_hull
  Implementation of a Point-In-Convex-Hull algorithm, for both the singular and plural cases.
• point_in_polygon
  Implementations of a Point-In-Polygon algorithm for both the singular and plural cases.
• types
  A module containing common and interfacing structs and types.
• utils
  Various utility functions that are commonly used by these algorithms.