Package: dedrunk Architecture: arm64 Version: 0.1.1-1 Priority: optional Section: science Maintainer: stelzo Installed-Size: 15248 Depends: libc6 (>= 2.35) Filename: pool/main/jammy/dedrunk_0.1.1-1_arm64.deb Size: 4661324 MD5sum: 2a862a20a60766ea85fdd08b6db9cf35 SHA1: fda6c988364504412163fcaf58accd0b78a6ce06 SHA256: b3ac8a8a2bfb25655548540ace702cbbfcca52758fb735a265022f479060e4fc SHA512: 843f7f2f4b12fed29c217b16f20e77f6ea1700b6bcc56685f8416daeff674faf531af125ccd8ade154183c3cd3efa9c74d3f97ff093d17144d6a4e932a0bde06 Homepage: https://codeberg.org/stelzo/dedrunk Description: Kalibr IMU calibration from MCAP recordings. # dedrunk . Getting your IMU sober again: Kalibr calibration from MCAP recordings. . A command-line front end for the [imu-calib](https://codeberg.com/stelzo/imu-calib) crate for IMU intrinsics and extrinsics with Lidar implementing [Zhu, Ren and Zhang, "Robust Real-time LiDAR-inertial Initialization", IROS 2022](https://arxiv.org/pdf/2202.11006). . ## Install . ```bash # Install from source: cargo install dedrunk . # or, for a prebuilt binary with binstall: cargo binstall dedrunk . # PyPI pip install dedrunk-cli . # Arch Linux yay -S dedrunk-bin . # Homebrew on MacOS brew install uos/tools/dedrunk ``` . ## Usage . ### Noise parameters . Record at least three hours somewhere undisturbed, away from vibration. . ```bash dedrunk noise recording.mcap ``` . ### Scale, misalignment and biases . Record the sensor held still in at least nine well-spread orientations, rotating about a different axis between each one. Start at rest — the first seconds measure the noise floor that tells a hold from a move. . ```bash dedrunk intrinsics recording.mcap ``` . The stationary stretches are found automatically; there is nothing to mark up. . Guidelines for a good calibration: - **Spread the orientations out.** Twelve attitudes covering all octants beats twelve small tilts. Nine is the minimum for the full model. (For only the six axis-aligned faces, set `intrinsics.accel_model = "scale-bias"`). - **Rotate about a different axis each time.** If every move is about the same axis, the gyroscope fit fails and `dedrunk` reports bias only. . Check the printed residuals: `accelerometer rms` should be near the sensor's own noise level (a few mm/s² for a decent MEMS part), and `gyroscope rms` well under a degree. . ### Where the IMU sits relative to the LiDAR . Recovers the rigid transform between a LiDAR and an IMU, plus the clock offset, gravity direction and both biases, from a recording of the two moving together. Follows [Zhu, Ren and Zhang, "Robust Real-time LiDAR-inertial Initialization", IROS 2022](https://arxiv.org/pdf/2202.11006). . Needs a LiDAR-only trajectory. Poses from LiDAR-inertial odometry already assumed an extrinsic, so feeding those back returns the assumption: . ```bash pelorus offline recording.mcap -c pelorus.rl -o imu.lidar_only=true --output-rosbag lidar_traj dedrunk extrinsics lidar_traj --imu-bag recording.mcap ``` . #### What to record . The motion decides what the tool can measure. There is no substitute for a good calibration dance: . - **Rotation**: Rotate the platform about all three axes (roll, pitch, yaw). A single axis leaves the rotation about it unconstrained. - **Translation (lever arm)**: The lever arm is only observable during rotation. Rotate briskly; slow turns contribute almost nothing. - **Gravity and Bias**: To separate gravity from accelerometer bias, the platform must tilt significantly. A robot that only yaws on flat ground cannot measure its vertical translation offset. . In practice: . - Pick the platform up if you can and rotate it about all three axes. Two minutes of that beats an hour of driving. - Rotate briskly. - Keep enough structure in view for the LiDAR odometry to track. - Stay still for the first few seconds. - If the platform cannot leave the ground, record anyway: `dedrunk` will report what it *could* measure and clearly state what it couldn't. . Read the observability report before trusting the numbers: . ``` gravity: [+0.723, +0.239, -6.267] m/s^2 (|g| = 6.313) residuals: acceleration 4.126 m/s^2 attitude spread: 2.1° (separates gravity from accel bias) angular excitation (rms, Lidar frame): [0.030, 0.037, 0.143] rad/s warning: the fitted gravity is 6.31 m/s^2 against an expected 9.81, off by 36%. ... warning: the platform's attitude varies by only 2.1° over the recording, so gravity and the accelerometer bias cannot be told apart ... ``` . A `|g|` far from 9.81 means the translation, gravity, and bias are unobservable in this recording. The rotation and time offset come from the gyroscope alone and remain valid. . The result is also printed as a ready-to-paste `imu.from_lidar_transform` block for pelorus. . ### Combine and use . ```bash dedrunk merge imu.yaml imu0.yaml --output calibration.yaml dedrunk show calibration.yaml ``` . `dedrunk topics recording.mcap` lists the IMU topics in a bag, for when `input.topic` has to be set explicitly. . Then online, with [imu-calib](https://github.com/stelzo/imu-calib): . ```rust let intrinsics = ImuIntrinsics::from_kalibr_yaml("calibration.yaml")?; let corrector = intrinsics.corrector()?; // build once let (accel, gyro) = corrector.correct(raw_accel, raw_gyro); ``` . ## Shell completions . Run `dedrunk completions` to detect the current shell and install completions for the current user. Pass a shell explicitly, such as `dedrunk completions bash`, to print a completion script for packaging or a system-wide installation instead. . ## Configuration . ```bash dedrunk config generate recommended > dedrunk.rl # the settings most runs touch dedrunk config generate full > dedrunk.rl # every setting, annotated dedrunk config verify dedrunk.rl dedrunk intrinsics recording.mcap --config dedrunk.rl ``` . Single settings can be overridden with `-o KEY=VALUE`, repeatable. The value is Ratslang, units and all: . ```bash dedrunk intrinsics recording.mcap \ -o input.topic='"/imu/data_raw"' \ -o intrinsics.static.min_hold=2s \ -o intrinsics.gravity=9.8127 \ -O my-imu.yaml ``` . ### License . Licensed under either of Apache License, Version 2.0 or MIT license at your option. .
. Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions. Package: libpelorus-cuda12-6-dev Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 46 Depends: libpelorus-cuda12-6 ( = 0.0.9 ) Filename: pool/main/jammy/libpelorus-cuda12-6-dev_0.0.9-1_arm64.deb Size: 8908 MD5sum: 053a1eca6b5397662660c72c9f95d195 SHA1: 2b1bc00e5b2d04bc55c87fd501b49382050f886e SHA256: c45f15bfe805ce0f8e3924e332bc89121c2fe4572b7395d2f0aa9e854b6bafd9 SHA512: 271ca2bd6dbe185efc3b4ce2d0c629218a584c54349450002a59be3b3355dcf83da06b56e8c27383bd93e92271d04f7c972c25f4448530ef2c966f9b54bb7954 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. Package: libpelorus-cuda12-6 Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 66860 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/libpelorus-cuda12-6_0.0.9-1_arm64.deb Size: 10369360 MD5sum: 23d02fb6bed58dfac538d6a5facdb1a1 SHA1: d0c97cf67ccef1e208990f814ca4c18ba850e8fa SHA256: a58a13168f1ba871d0f74304076ac1ea280429c5d99ede48c4bebab5912a9ef1 SHA512: d4b4809b6c1313e0a1418e09b1d2c62012c4102d2701280c6743f5e998b9bc8be949018deb4f73ecdd3cafb26c5e478e026145ceb88ef4ee7e1acba8cc29f3a8 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. # pelorus_c . C library bindings for Pelorus. . ## Building and Installation . ### CMake . The library can be built and installed using CMake: . ```bash cd pelorus_c mkdir build && cd build cmake .. make sudo make install ``` . #### CMake Options . - `PELORUS_BUILD_SHARED` - Build shared library (default: ON) - `PELORUS_BUILD_STATIC` - Build static library (default: ON) - `PELORUS_BUILD_EXAMPLES` - Build C/C++ examples (default: OFF) - `PELORUS_INSTALL` - Install library and headers (default: ON) . #### Feature Flags . - `PELORUS_FEATURE_RAYON` - Enable Rayon CPU parallelism (default: ON) - `PELORUS_FEATURE_METAL` - Enable Metal acceleration (default: OFF) - `PELORUS_FEATURE_CUDA` - Enable CUDA acceleration (default: OFF) - `PELORUS_FEATURE_VULKAN` - Enable Vulkan acceleration (default: OFF) - `PELORUS_FEATURE_NO_IMU_SYNC` - Disable IMU synchronization (default: OFF) - `PELORUS_FEATURE_LARGE_PROCESSING_QUEUE` - Use larger internal processing queues (default: OFF) . Select at most one GPU backend. Metal is available on macOS. CUDA requires a supported NVIDIA CUDA installation. Vulkan requires a compatible Vulkan device and driver. If no GPU backend is selected, Pelorus uses the CPU backend. . Example with CUDA: . ```bash cmake .. -DPELORUS_FEATURE_CUDA=ON ``` . ### Using Cargo (Direct) . You can also build directly with Cargo: . ```bash cargo build --package pelorus_c --release . # Select one GPU backend when needed: cargo build --package pelorus_c --release --features cuda cargo build --package pelorus_c --release --features vulkan cargo build --package pelorus_c --release --features metal ``` . ## Using the Library . ### In CMake Projects . After installation, use `find_package`: . ```cmake find_package(pelorus REQUIRED) add_executable(my_app main.c) target_link_libraries(my_app pelorus::pelorus) ``` . See [examples/CMAKE_USAGE.md](examples/CMAKE_USAGE.md) for more details. . ### With pkg-config . ```bash gcc my_app.c $(pkg-config --cflags --libs pelorus) -o my_app ``` . ### C++ Wrapper . A modern C++ wrapper is available in `pelorus.hpp`. . ```cpp #include #include . int main() { pelorus::Pelorus pelorus; . // Add measurements pelorus::ImuMsg imu; // ... fill IMU data ... pelorus.add_imu(imu); . // Receive odometry auto res = pelorus.try_recv(); if (res.status == pelorus::Pelorus::STATUS_OK) { const auto &odom = res.odom; std::cout << "Position: " << odom.position()[0] << "\n"; } . return 0; } ``` . ### PCL Integration . For projects using the Point Cloud Library (PCL): . ```cpp #include #include #include . pelorus::Pelorus pelorus; . // Convert and add PCL cloud to Pelorus pcl::PointCloud::Ptr cloud( new pcl::PointCloud()); // ... fill cloud ... pelorus::pcl::add_pointcloud(pelorus, cloud, timestamp_sec, timestamp_nsec); . // Get result auto result = pelorus.recv(); if (result.status == pelorus::Pelorus::STATUS_OK) { auto result_cloud = result.odom.get_cloud_pcl::Ptr>(); . // Or use the standalone function auto result_cloud2 = pelorus::pcl_helpers::to_pcl_cloud( result.odom.points(), result.odom.num_points()); } ``` . ### Eigen3 Integration . For projects using Eigen for transformations: . ```cpp #include #include . pelorus::Pelorus pelorus; auto result = pelorus.recv(); if (result.status == pelorus::Pelorus::STATUS_OK) { const auto &odom = result.odom; . // Get odometry as a transformation matrix Eigen::Isometry3d transform = pelorus::eigen::to_transform(odom); . // Transform a point from sensor to world coordinates Eigen::Vector3d point_sensor(1.0, 0.0, 0.0); Eigen::Vector3d point_world = transform * point_sensor; . // Get all odometry data as Eigen types auto state = pelorus::eigen::OdometryState::from_pelorus(odom); std::cout << "Position: " << state.transform.translation().transpose() << "\n"; std::cout << "Velocity: " << state.linear_velocity.transpose() << "\n"; std::cout << "Accelerometer bias: " << state.accel_bias.transpose() << "\n"; std::cout << "Gyroscope bias: " << state.gyro_bias.transpose() << "\n"; . // Extract individual components Eigen::Vector3d position = pelorus::eigen::to_position(odom.position()); Eigen::Quaterniond orientation = pelorus::eigen::to_quaternion(odom.orientation()); Eigen::Matrix pose_cov = pelorus::eigen::get_pose_covariance(*odom.get()); } ``` . ## Configuration . The library uses `.rl` configuration files: . ```c // Use custom configuration file to override defaults for your setup struct PelorusHandle* pelorus = pelorus_create("/path/to/my_config.rl"); . // Or: configure creation-time behavior without editing the on-disk .rl pelorus_create_options opts = PELORUS_CREATE_OPTIONS_DEFAULT; opts.config_path = "/path/to/my_config.rl"; // opts.device_specific_pointcloud2 = 0; // disable device-specific interpretation struct PelorusHandle* pelorus2 = pelorus_create_with_options(&opts); ``` . You can generate a default config file with: . ```bash pelorus config generate recommended > my_config.rl . # Or generate the complete default configuration: pelorus config generate full > my_config.rl ``` . All parameters (map resolution, IMU covariances, Lidar vendor, filtering options, etc.) are configurable. . ## API Design . Pelorus provides three ways to receive odometry results: . Bias-aware callers can use `pelorus_try_recv_with_bias()`, `pelorus_recv_with_bias()`, or `pelorus_set_callback_with_bias()`. These additive APIs return `pelorus_imu_bias` without changing the layout of the existing `pelorus_odometry` structure. The C++ wrapper uses these APIs automatically and exposes `Odometry::accel_bias()` and `Odometry::gyro_bias()`. . ### 1. Non-blocking (Polling) Use `pelorus_try_recv()` for non-blocking checks: ```c pelorus_odometry odom; int status = pelorus_try_recv(pelorus, &odom); if (status == PELORUS_STATUS_OK) { // Process odometry pelorus_free_odometry(&odom); } else if (status == PELORUS_STATUS_NO_DATA) { // No data available yet } else if (status == PELORUS_STATUS_CALLBACK_SET) { // Callback mode is active; polling APIs are unavailable } ``` . ### 2. Blocking (Synchronous) Use `pelorus_recv()` to wait for results: ```c pelorus_odometry odom; int status = pelorus_recv(pelorus, &odom); // Blocks until data available if (status == PELORUS_STATUS_OK) { // Process odometry pelorus_free_odometry(&odom); } else if (status == PELORUS_STATUS_CALLBACK_SET) { // Callback mode is active; cannot use blocking APIs } ``` . ### 3. Callback (Asynchronous) Use `pelorus_set_callback()` for event-driven processing: ```c void odometry_callback(const pelorus_odometry *odom, void *user_data) { // Process odometry (called from background thread) // No need to call pelorus_free_odometry() - handled automatically } . // Register callback pelorus_set_callback(pelorus, odometry_callback, user_data); . // Disable callback pelorus_set_callback(pelorus, NULL, NULL); ``` . **Note**: When using callbacks, `pelorus_try_recv()` and `pelorus_recv()` will not receive data. Callbacks and polling/blocking APIs are mutually exclusive. . ## Examples . See the `examples/` directory for complete usage examples: . - `async_callback.c` - Callback-based asynchronous example - `sync_blocking.c` - Synchronous blocking example - `sync_blocking_pcl_eigen.cpp` - C++ wrapper example with optional PCL/Eigen support - `eigen_example.cpp` - Eigen conversion example . Build and run examples: ```bash cd examples make ./async_callback ./sync_blocking ``` . ### Raw point helpers . If you already have raw point buffers (similar to the Python numpy input), you can avoid building a full `pelorus_pointcloud2` and instead call one of: . - `pelorus_add_points_xyzt_f32(...)` for Nx4 `[x,y,z,t]` (`t` is ns offset, cast to `uint32_t`) - `pelorus_add_points_xyzit_f32(...)` for Nx5 `[x,y,z,intensity,t]` . All of these are internally converted into a PointCloud2 with `x,y,z,intensity,t` fields. . ## Threading Model . The API is designed to be simple from the caller's perspective: - `pelorus_add_imu()`, `pelorus_add_odom()`, and `pelorus_add_pointcloud()` return immediately - Processing happens asynchronously in background threads - `pelorus_try_recv()` is non-blocking and returns immediately - `pelorus_recv()` blocks until data is available - Callbacks are invoked from a background thread . ## Memory Management . - Results from `pelorus_try_recv()` and `pelorus_recv()` must be freed with `pelorus_free_odometry()` - Callback results are automatically freed after the callback returns - The `PelorusHandle` must be destroyed with `pelorus_destroy()` . ## Timestamp semantics . Pelorus uses two timestamp levels: . 1. **IMU/Odom timestamps** (`timestamp_sec` + `timestamp_nanosec`) - Absolute timestamps (typically epoch / ROS time) used for synchronization. . 2. **Lidar timestamps** - `pelorus_pointcloud2.header_timestamp_sec/nanosec`: absolute reference time for the scan. - Per-point field `t` (if provided): `uint32` **nanoseconds offset**, **non-negative** and **forward in time** relative to the scan header timestamp. . The effective point time is: . `point_time_abs = header_time_abs + (t * 1e-9)` . ### Pelorus expects a simplified, single-row (unstructured) little-endian `PointCloud2`. . Interpretation of per-point timing depends on the parsing mode: . - When Pelorus uses *device-specific* parsing (the default), field meanings — including any `t` field — are interpreted according to the vendor/device configuration and may vary. - When using the generic parsing path (`device_specific_pointcloud2 == false`), Pelorus expects `t` to be a **non-negative** (`uint32`) nanoseconds offset relative to the scan header timestamp. . For generic point input, prefer `pelorus_add_points_xyzt_f32()` or `pelorus_add_points_xyzit_f32()`. . ## License . Dual-licensed under MIT and Apache 2.0, consistent with the Pelorus project. Package: libpelorus-cuda12-8-dev Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 46 Depends: libpelorus-cuda12-8 ( = 0.0.9 ) Filename: pool/main/jammy/libpelorus-cuda12-8-dev_0.0.9-1_arm64.deb Size: 8908 MD5sum: d972c05da8044dc11aabdc928534e3b8 SHA1: 415fb47a44de3c59e856c5264e819567b7aa1e26 SHA256: e8fb95dfacdc87e8a261a7e672d6a7a907853f29b820378a1cf375a4c0e2f7d5 SHA512: a919c5d6b9f1e957022c71a739ac431b01abf541a8dd2db8abc0480f03bdbf8ed90ae609c9045e201d47a70d58e8c3aa751a3ac310dc5b013f886fc54990957d Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. Package: libpelorus-cuda12-8 Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 66860 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/libpelorus-cuda12-8_0.0.9-1_arm64.deb Size: 10369024 MD5sum: cdd8cfc8fad5792fcd63987d47dbb3b5 SHA1: 3af8c1ffc5354b90f778e46be2fc2bc777b4dc94 SHA256: ff26c609a3eac98d43c3834a0fb175c97e8f09f969a6ccb44871584f2b7b356c SHA512: 7ba07cfe94ce488cf8e0aba9423c260153f5853a7e31f62c0a3978933f28e2d2fcfb9158d0121ffe81f29d8a11c1d6874f1392737d11c2e68898e27a0eacb864 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. # pelorus_c . C library bindings for Pelorus. . ## Building and Installation . ### CMake . The library can be built and installed using CMake: . ```bash cd pelorus_c mkdir build && cd build cmake .. make sudo make install ``` . #### CMake Options . - `PELORUS_BUILD_SHARED` - Build shared library (default: ON) - `PELORUS_BUILD_STATIC` - Build static library (default: ON) - `PELORUS_BUILD_EXAMPLES` - Build C/C++ examples (default: OFF) - `PELORUS_INSTALL` - Install library and headers (default: ON) . #### Feature Flags . - `PELORUS_FEATURE_RAYON` - Enable Rayon CPU parallelism (default: ON) - `PELORUS_FEATURE_METAL` - Enable Metal acceleration (default: OFF) - `PELORUS_FEATURE_CUDA` - Enable CUDA acceleration (default: OFF) - `PELORUS_FEATURE_VULKAN` - Enable Vulkan acceleration (default: OFF) - `PELORUS_FEATURE_NO_IMU_SYNC` - Disable IMU synchronization (default: OFF) - `PELORUS_FEATURE_LARGE_PROCESSING_QUEUE` - Use larger internal processing queues (default: OFF) . Select at most one GPU backend. Metal is available on macOS. CUDA requires a supported NVIDIA CUDA installation. Vulkan requires a compatible Vulkan device and driver. If no GPU backend is selected, Pelorus uses the CPU backend. . Example with CUDA: . ```bash cmake .. -DPELORUS_FEATURE_CUDA=ON ``` . ### Using Cargo (Direct) . You can also build directly with Cargo: . ```bash cargo build --package pelorus_c --release . # Select one GPU backend when needed: cargo build --package pelorus_c --release --features cuda cargo build --package pelorus_c --release --features vulkan cargo build --package pelorus_c --release --features metal ``` . ## Using the Library . ### In CMake Projects . After installation, use `find_package`: . ```cmake find_package(pelorus REQUIRED) add_executable(my_app main.c) target_link_libraries(my_app pelorus::pelorus) ``` . See [examples/CMAKE_USAGE.md](examples/CMAKE_USAGE.md) for more details. . ### With pkg-config . ```bash gcc my_app.c $(pkg-config --cflags --libs pelorus) -o my_app ``` . ### C++ Wrapper . A modern C++ wrapper is available in `pelorus.hpp`. . ```cpp #include #include . int main() { pelorus::Pelorus pelorus; . // Add measurements pelorus::ImuMsg imu; // ... fill IMU data ... pelorus.add_imu(imu); . // Receive odometry auto res = pelorus.try_recv(); if (res.status == pelorus::Pelorus::STATUS_OK) { const auto &odom = res.odom; std::cout << "Position: " << odom.position()[0] << "\n"; } . return 0; } ``` . ### PCL Integration . For projects using the Point Cloud Library (PCL): . ```cpp #include #include #include . pelorus::Pelorus pelorus; . // Convert and add PCL cloud to Pelorus pcl::PointCloud::Ptr cloud( new pcl::PointCloud()); // ... fill cloud ... pelorus::pcl::add_pointcloud(pelorus, cloud, timestamp_sec, timestamp_nsec); . // Get result auto result = pelorus.recv(); if (result.status == pelorus::Pelorus::STATUS_OK) { auto result_cloud = result.odom.get_cloud_pcl::Ptr>(); . // Or use the standalone function auto result_cloud2 = pelorus::pcl_helpers::to_pcl_cloud( result.odom.points(), result.odom.num_points()); } ``` . ### Eigen3 Integration . For projects using Eigen for transformations: . ```cpp #include #include . pelorus::Pelorus pelorus; auto result = pelorus.recv(); if (result.status == pelorus::Pelorus::STATUS_OK) { const auto &odom = result.odom; . // Get odometry as a transformation matrix Eigen::Isometry3d transform = pelorus::eigen::to_transform(odom); . // Transform a point from sensor to world coordinates Eigen::Vector3d point_sensor(1.0, 0.0, 0.0); Eigen::Vector3d point_world = transform * point_sensor; . // Get all odometry data as Eigen types auto state = pelorus::eigen::OdometryState::from_pelorus(odom); std::cout << "Position: " << state.transform.translation().transpose() << "\n"; std::cout << "Velocity: " << state.linear_velocity.transpose() << "\n"; std::cout << "Accelerometer bias: " << state.accel_bias.transpose() << "\n"; std::cout << "Gyroscope bias: " << state.gyro_bias.transpose() << "\n"; . // Extract individual components Eigen::Vector3d position = pelorus::eigen::to_position(odom.position()); Eigen::Quaterniond orientation = pelorus::eigen::to_quaternion(odom.orientation()); Eigen::Matrix pose_cov = pelorus::eigen::get_pose_covariance(*odom.get()); } ``` . ## Configuration . The library uses `.rl` configuration files: . ```c // Use custom configuration file to override defaults for your setup struct PelorusHandle* pelorus = pelorus_create("/path/to/my_config.rl"); . // Or: configure creation-time behavior without editing the on-disk .rl pelorus_create_options opts = PELORUS_CREATE_OPTIONS_DEFAULT; opts.config_path = "/path/to/my_config.rl"; // opts.device_specific_pointcloud2 = 0; // disable device-specific interpretation struct PelorusHandle* pelorus2 = pelorus_create_with_options(&opts); ``` . You can generate a default config file with: . ```bash pelorus config generate recommended > my_config.rl . # Or generate the complete default configuration: pelorus config generate full > my_config.rl ``` . All parameters (map resolution, IMU covariances, Lidar vendor, filtering options, etc.) are configurable. . ## API Design . Pelorus provides three ways to receive odometry results: . Bias-aware callers can use `pelorus_try_recv_with_bias()`, `pelorus_recv_with_bias()`, or `pelorus_set_callback_with_bias()`. These additive APIs return `pelorus_imu_bias` without changing the layout of the existing `pelorus_odometry` structure. The C++ wrapper uses these APIs automatically and exposes `Odometry::accel_bias()` and `Odometry::gyro_bias()`. . ### 1. Non-blocking (Polling) Use `pelorus_try_recv()` for non-blocking checks: ```c pelorus_odometry odom; int status = pelorus_try_recv(pelorus, &odom); if (status == PELORUS_STATUS_OK) { // Process odometry pelorus_free_odometry(&odom); } else if (status == PELORUS_STATUS_NO_DATA) { // No data available yet } else if (status == PELORUS_STATUS_CALLBACK_SET) { // Callback mode is active; polling APIs are unavailable } ``` . ### 2. Blocking (Synchronous) Use `pelorus_recv()` to wait for results: ```c pelorus_odometry odom; int status = pelorus_recv(pelorus, &odom); // Blocks until data available if (status == PELORUS_STATUS_OK) { // Process odometry pelorus_free_odometry(&odom); } else if (status == PELORUS_STATUS_CALLBACK_SET) { // Callback mode is active; cannot use blocking APIs } ``` . ### 3. Callback (Asynchronous) Use `pelorus_set_callback()` for event-driven processing: ```c void odometry_callback(const pelorus_odometry *odom, void *user_data) { // Process odometry (called from background thread) // No need to call pelorus_free_odometry() - handled automatically } . // Register callback pelorus_set_callback(pelorus, odometry_callback, user_data); . // Disable callback pelorus_set_callback(pelorus, NULL, NULL); ``` . **Note**: When using callbacks, `pelorus_try_recv()` and `pelorus_recv()` will not receive data. Callbacks and polling/blocking APIs are mutually exclusive. . ## Examples . See the `examples/` directory for complete usage examples: . - `async_callback.c` - Callback-based asynchronous example - `sync_blocking.c` - Synchronous blocking example - `sync_blocking_pcl_eigen.cpp` - C++ wrapper example with optional PCL/Eigen support - `eigen_example.cpp` - Eigen conversion example . Build and run examples: ```bash cd examples make ./async_callback ./sync_blocking ``` . ### Raw point helpers . If you already have raw point buffers (similar to the Python numpy input), you can avoid building a full `pelorus_pointcloud2` and instead call one of: . - `pelorus_add_points_xyzt_f32(...)` for Nx4 `[x,y,z,t]` (`t` is ns offset, cast to `uint32_t`) - `pelorus_add_points_xyzit_f32(...)` for Nx5 `[x,y,z,intensity,t]` . All of these are internally converted into a PointCloud2 with `x,y,z,intensity,t` fields. . ## Threading Model . The API is designed to be simple from the caller's perspective: - `pelorus_add_imu()`, `pelorus_add_odom()`, and `pelorus_add_pointcloud()` return immediately - Processing happens asynchronously in background threads - `pelorus_try_recv()` is non-blocking and returns immediately - `pelorus_recv()` blocks until data is available - Callbacks are invoked from a background thread . ## Memory Management . - Results from `pelorus_try_recv()` and `pelorus_recv()` must be freed with `pelorus_free_odometry()` - Callback results are automatically freed after the callback returns - The `PelorusHandle` must be destroyed with `pelorus_destroy()` . ## Timestamp semantics . Pelorus uses two timestamp levels: . 1. **IMU/Odom timestamps** (`timestamp_sec` + `timestamp_nanosec`) - Absolute timestamps (typically epoch / ROS time) used for synchronization. . 2. **Lidar timestamps** - `pelorus_pointcloud2.header_timestamp_sec/nanosec`: absolute reference time for the scan. - Per-point field `t` (if provided): `uint32` **nanoseconds offset**, **non-negative** and **forward in time** relative to the scan header timestamp. . The effective point time is: . `point_time_abs = header_time_abs + (t * 1e-9)` . ### Pelorus expects a simplified, single-row (unstructured) little-endian `PointCloud2`. . Interpretation of per-point timing depends on the parsing mode: . - When Pelorus uses *device-specific* parsing (the default), field meanings — including any `t` field — are interpreted according to the vendor/device configuration and may vary. - When using the generic parsing path (`device_specific_pointcloud2 == false`), Pelorus expects `t` to be a **non-negative** (`uint32`) nanoseconds offset relative to the scan header timestamp. . For generic point input, prefer `pelorus_add_points_xyzt_f32()` or `pelorus_add_points_xyzit_f32()`. . ## License . Dual-licensed under MIT and Apache 2.0, consistent with the Pelorus project. Package: libpelorus-cuda13-1-dev Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 46 Depends: libpelorus-cuda13-1 ( = 0.0.9 ) Filename: pool/main/jammy/libpelorus-cuda13-1-dev_0.0.9-1_arm64.deb Size: 8908 MD5sum: aaebfc2cb8be4a477ed6efffde870975 SHA1: d4ca1e2481bbab7d30438f90933fe4bd2d3f9097 SHA256: 09f0a71d9456c77f8bc29018bd0be71e8883ec06164c7245680c8732cbff8e68 SHA512: 29fefbb3106f5d78a6366d4b7ac0a450c82600a88f0295640c62fc9d61f4788a5db75a89861e87a2b023c01860d96354b9b02e766f3930a1902ac702e1695fb9 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. Package: libpelorus-cuda13-1 Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 66860 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/libpelorus-cuda13-1_0.0.9-1_arm64.deb Size: 10369472 MD5sum: 4e8f15d05641b71d897c67046e6740ba SHA1: 80c90ab663b66ffecf50fc60ebb68756adbfebcf SHA256: b099b9dff6ad54cc28eb26acbd53f224b89de53360bcc48ae16153eda60e15eb SHA512: e017e73454ba1a10e28d8fe0e9ca6778fdb266761b56cb3620f55a676f11c5b0a49f7b851d83a76110bea522101f54ba4dea25a2c50321e220c42fb5044813ea Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. # pelorus_c . C library bindings for Pelorus. . ## Building and Installation . ### CMake . The library can be built and installed using CMake: . ```bash cd pelorus_c mkdir build && cd build cmake .. make sudo make install ``` . #### CMake Options . - `PELORUS_BUILD_SHARED` - Build shared library (default: ON) - `PELORUS_BUILD_STATIC` - Build static library (default: ON) - `PELORUS_BUILD_EXAMPLES` - Build C/C++ examples (default: OFF) - `PELORUS_INSTALL` - Install library and headers (default: ON) . #### Feature Flags . - `PELORUS_FEATURE_RAYON` - Enable Rayon CPU parallelism (default: ON) - `PELORUS_FEATURE_METAL` - Enable Metal acceleration (default: OFF) - `PELORUS_FEATURE_CUDA` - Enable CUDA acceleration (default: OFF) - `PELORUS_FEATURE_VULKAN` - Enable Vulkan acceleration (default: OFF) - `PELORUS_FEATURE_NO_IMU_SYNC` - Disable IMU synchronization (default: OFF) - `PELORUS_FEATURE_LARGE_PROCESSING_QUEUE` - Use larger internal processing queues (default: OFF) . Select at most one GPU backend. Metal is available on macOS. CUDA requires a supported NVIDIA CUDA installation. Vulkan requires a compatible Vulkan device and driver. If no GPU backend is selected, Pelorus uses the CPU backend. . Example with CUDA: . ```bash cmake .. -DPELORUS_FEATURE_CUDA=ON ``` . ### Using Cargo (Direct) . You can also build directly with Cargo: . ```bash cargo build --package pelorus_c --release . # Select one GPU backend when needed: cargo build --package pelorus_c --release --features cuda cargo build --package pelorus_c --release --features vulkan cargo build --package pelorus_c --release --features metal ``` . ## Using the Library . ### In CMake Projects . After installation, use `find_package`: . ```cmake find_package(pelorus REQUIRED) add_executable(my_app main.c) target_link_libraries(my_app pelorus::pelorus) ``` . See [examples/CMAKE_USAGE.md](examples/CMAKE_USAGE.md) for more details. . ### With pkg-config . ```bash gcc my_app.c $(pkg-config --cflags --libs pelorus) -o my_app ``` . ### C++ Wrapper . A modern C++ wrapper is available in `pelorus.hpp`. . ```cpp #include #include . int main() { pelorus::Pelorus pelorus; . // Add measurements pelorus::ImuMsg imu; // ... fill IMU data ... pelorus.add_imu(imu); . // Receive odometry auto res = pelorus.try_recv(); if (res.status == pelorus::Pelorus::STATUS_OK) { const auto &odom = res.odom; std::cout << "Position: " << odom.position()[0] << "\n"; } . return 0; } ``` . ### PCL Integration . For projects using the Point Cloud Library (PCL): . ```cpp #include #include #include . pelorus::Pelorus pelorus; . // Convert and add PCL cloud to Pelorus pcl::PointCloud::Ptr cloud( new pcl::PointCloud()); // ... fill cloud ... pelorus::pcl::add_pointcloud(pelorus, cloud, timestamp_sec, timestamp_nsec); . // Get result auto result = pelorus.recv(); if (result.status == pelorus::Pelorus::STATUS_OK) { auto result_cloud = result.odom.get_cloud_pcl::Ptr>(); . // Or use the standalone function auto result_cloud2 = pelorus::pcl_helpers::to_pcl_cloud( result.odom.points(), result.odom.num_points()); } ``` . ### Eigen3 Integration . For projects using Eigen for transformations: . ```cpp #include #include . pelorus::Pelorus pelorus; auto result = pelorus.recv(); if (result.status == pelorus::Pelorus::STATUS_OK) { const auto &odom = result.odom; . // Get odometry as a transformation matrix Eigen::Isometry3d transform = pelorus::eigen::to_transform(odom); . // Transform a point from sensor to world coordinates Eigen::Vector3d point_sensor(1.0, 0.0, 0.0); Eigen::Vector3d point_world = transform * point_sensor; . // Get all odometry data as Eigen types auto state = pelorus::eigen::OdometryState::from_pelorus(odom); std::cout << "Position: " << state.transform.translation().transpose() << "\n"; std::cout << "Velocity: " << state.linear_velocity.transpose() << "\n"; std::cout << "Accelerometer bias: " << state.accel_bias.transpose() << "\n"; std::cout << "Gyroscope bias: " << state.gyro_bias.transpose() << "\n"; . // Extract individual components Eigen::Vector3d position = pelorus::eigen::to_position(odom.position()); Eigen::Quaterniond orientation = pelorus::eigen::to_quaternion(odom.orientation()); Eigen::Matrix pose_cov = pelorus::eigen::get_pose_covariance(*odom.get()); } ``` . ## Configuration . The library uses `.rl` configuration files: . ```c // Use custom configuration file to override defaults for your setup struct PelorusHandle* pelorus = pelorus_create("/path/to/my_config.rl"); . // Or: configure creation-time behavior without editing the on-disk .rl pelorus_create_options opts = PELORUS_CREATE_OPTIONS_DEFAULT; opts.config_path = "/path/to/my_config.rl"; // opts.device_specific_pointcloud2 = 0; // disable device-specific interpretation struct PelorusHandle* pelorus2 = pelorus_create_with_options(&opts); ``` . You can generate a default config file with: . ```bash pelorus config generate recommended > my_config.rl . # Or generate the complete default configuration: pelorus config generate full > my_config.rl ``` . All parameters (map resolution, IMU covariances, Lidar vendor, filtering options, etc.) are configurable. . ## API Design . Pelorus provides three ways to receive odometry results: . Bias-aware callers can use `pelorus_try_recv_with_bias()`, `pelorus_recv_with_bias()`, or `pelorus_set_callback_with_bias()`. These additive APIs return `pelorus_imu_bias` without changing the layout of the existing `pelorus_odometry` structure. The C++ wrapper uses these APIs automatically and exposes `Odometry::accel_bias()` and `Odometry::gyro_bias()`. . ### 1. Non-blocking (Polling) Use `pelorus_try_recv()` for non-blocking checks: ```c pelorus_odometry odom; int status = pelorus_try_recv(pelorus, &odom); if (status == PELORUS_STATUS_OK) { // Process odometry pelorus_free_odometry(&odom); } else if (status == PELORUS_STATUS_NO_DATA) { // No data available yet } else if (status == PELORUS_STATUS_CALLBACK_SET) { // Callback mode is active; polling APIs are unavailable } ``` . ### 2. Blocking (Synchronous) Use `pelorus_recv()` to wait for results: ```c pelorus_odometry odom; int status = pelorus_recv(pelorus, &odom); // Blocks until data available if (status == PELORUS_STATUS_OK) { // Process odometry pelorus_free_odometry(&odom); } else if (status == PELORUS_STATUS_CALLBACK_SET) { // Callback mode is active; cannot use blocking APIs } ``` . ### 3. Callback (Asynchronous) Use `pelorus_set_callback()` for event-driven processing: ```c void odometry_callback(const pelorus_odometry *odom, void *user_data) { // Process odometry (called from background thread) // No need to call pelorus_free_odometry() - handled automatically } . // Register callback pelorus_set_callback(pelorus, odometry_callback, user_data); . // Disable callback pelorus_set_callback(pelorus, NULL, NULL); ``` . **Note**: When using callbacks, `pelorus_try_recv()` and `pelorus_recv()` will not receive data. Callbacks and polling/blocking APIs are mutually exclusive. . ## Examples . See the `examples/` directory for complete usage examples: . - `async_callback.c` - Callback-based asynchronous example - `sync_blocking.c` - Synchronous blocking example - `sync_blocking_pcl_eigen.cpp` - C++ wrapper example with optional PCL/Eigen support - `eigen_example.cpp` - Eigen conversion example . Build and run examples: ```bash cd examples make ./async_callback ./sync_blocking ``` . ### Raw point helpers . If you already have raw point buffers (similar to the Python numpy input), you can avoid building a full `pelorus_pointcloud2` and instead call one of: . - `pelorus_add_points_xyzt_f32(...)` for Nx4 `[x,y,z,t]` (`t` is ns offset, cast to `uint32_t`) - `pelorus_add_points_xyzit_f32(...)` for Nx5 `[x,y,z,intensity,t]` . All of these are internally converted into a PointCloud2 with `x,y,z,intensity,t` fields. . ## Threading Model . The API is designed to be simple from the caller's perspective: - `pelorus_add_imu()`, `pelorus_add_odom()`, and `pelorus_add_pointcloud()` return immediately - Processing happens asynchronously in background threads - `pelorus_try_recv()` is non-blocking and returns immediately - `pelorus_recv()` blocks until data is available - Callbacks are invoked from a background thread . ## Memory Management . - Results from `pelorus_try_recv()` and `pelorus_recv()` must be freed with `pelorus_free_odometry()` - Callback results are automatically freed after the callback returns - The `PelorusHandle` must be destroyed with `pelorus_destroy()` . ## Timestamp semantics . Pelorus uses two timestamp levels: . 1. **IMU/Odom timestamps** (`timestamp_sec` + `timestamp_nanosec`) - Absolute timestamps (typically epoch / ROS time) used for synchronization. . 2. **Lidar timestamps** - `pelorus_pointcloud2.header_timestamp_sec/nanosec`: absolute reference time for the scan. - Per-point field `t` (if provided): `uint32` **nanoseconds offset**, **non-negative** and **forward in time** relative to the scan header timestamp. . The effective point time is: . `point_time_abs = header_time_abs + (t * 1e-9)` . ### Pelorus expects a simplified, single-row (unstructured) little-endian `PointCloud2`. . Interpretation of per-point timing depends on the parsing mode: . - When Pelorus uses *device-specific* parsing (the default), field meanings — including any `t` field — are interpreted according to the vendor/device configuration and may vary. - When using the generic parsing path (`device_specific_pointcloud2 == false`), Pelorus expects `t` to be a **non-negative** (`uint32`) nanoseconds offset relative to the scan header timestamp. . For generic point input, prefer `pelorus_add_points_xyzt_f32()` or `pelorus_add_points_xyzit_f32()`. . ## License . Dual-licensed under MIT and Apache 2.0, consistent with the Pelorus project. Package: libpelorus-dev Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 46 Depends: libpelorus ( = 0.0.9-1 ) Filename: pool/main/jammy/libpelorus-dev_0.0.9-1_arm64.deb Size: 8892 MD5sum: 03d3e5a6fc37919a28d01a79f5212af7 SHA1: 1a12ddaaaf26370ef7a24e0a2959c4e0345c53dc SHA256: bcc4a74f298f00b1afad58371538e84f2d39b2e396b7075c6e94cb29a132193b SHA512: bd4e0827103b570435e915412a39a622f9cab74ff2cde9d3fa8bce1364cf21e3b4199158957532841c7a9a4ab1df7800251d0a26159127f0d01a618a1b25f012 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. Package: libpelorus-vulkan-dev Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 46 Depends: libpelorus-vulkan ( = 0.0.9-1 ) Filename: pool/main/jammy/libpelorus-vulkan-dev_0.0.9-1_arm64.deb Size: 8904 MD5sum: 7c450443b991482929e1f866a8052520 SHA1: c900cdef76de7449c11a5a187824e96601d159a2 SHA256: ed8e1eed08ef0c1f13b6b1f0545645eeea236f0f7dbc7204d055c4f796e8bcde SHA512: f622d847e0313727bde6995af79934d2beb9d48d3efb70ccfaf4c084f6cfc375fa36f397b7b044edb33188eb197a57566f0a1c6d1e7d0a53b09cf11ca58d0c3b Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. Package: libpelorus-vulkan Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 100457 Depends: libvulkan1 Filename: pool/main/jammy/libpelorus-vulkan_0.0.9-1_arm64.deb Size: 15375580 MD5sum: b3506132537c7f81d8826fd27329d313 SHA1: af705695c884ae4ddaa55bfa43331a245ca70293 SHA256: b12a7fb91de80ab9f108240e317ea6d873cf8f7518c7d5d3cf40775b2fd60926 SHA512: a5cb1090564e10fa097b0aa49e084e941e806a0e1ffbd2aae31fdba23c4bb03d9738b418aa66ca3ac6b9c0f5ac705aabb5b04faaad0177acbc24be4e9194f689 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. # pelorus_c . C library bindings for Pelorus. . ## Building and Installation . ### CMake . The library can be built and installed using CMake: . ```bash cd pelorus_c mkdir build && cd build cmake .. make sudo make install ``` . #### CMake Options . - `PELORUS_BUILD_SHARED` - Build shared library (default: ON) - `PELORUS_BUILD_STATIC` - Build static library (default: ON) - `PELORUS_BUILD_EXAMPLES` - Build C/C++ examples (default: OFF) - `PELORUS_INSTALL` - Install library and headers (default: ON) . #### Feature Flags . - `PELORUS_FEATURE_RAYON` - Enable Rayon CPU parallelism (default: ON) - `PELORUS_FEATURE_METAL` - Enable Metal acceleration (default: OFF) - `PELORUS_FEATURE_CUDA` - Enable CUDA acceleration (default: OFF) - `PELORUS_FEATURE_VULKAN` - Enable Vulkan acceleration (default: OFF) - `PELORUS_FEATURE_NO_IMU_SYNC` - Disable IMU synchronization (default: OFF) - `PELORUS_FEATURE_LARGE_PROCESSING_QUEUE` - Use larger internal processing queues (default: OFF) . Select at most one GPU backend. Metal is available on macOS. CUDA requires a supported NVIDIA CUDA installation. Vulkan requires a compatible Vulkan device and driver. If no GPU backend is selected, Pelorus uses the CPU backend. . Example with CUDA: . ```bash cmake .. -DPELORUS_FEATURE_CUDA=ON ``` . ### Using Cargo (Direct) . You can also build directly with Cargo: . ```bash cargo build --package pelorus_c --release . # Select one GPU backend when needed: cargo build --package pelorus_c --release --features cuda cargo build --package pelorus_c --release --features vulkan cargo build --package pelorus_c --release --features metal ``` . ## Using the Library . ### In CMake Projects . After installation, use `find_package`: . ```cmake find_package(pelorus REQUIRED) add_executable(my_app main.c) target_link_libraries(my_app pelorus::pelorus) ``` . See [examples/CMAKE_USAGE.md](examples/CMAKE_USAGE.md) for more details. . ### With pkg-config . ```bash gcc my_app.c $(pkg-config --cflags --libs pelorus) -o my_app ``` . ### C++ Wrapper . A modern C++ wrapper is available in `pelorus.hpp`. . ```cpp #include #include . int main() { pelorus::Pelorus pelorus; . // Add measurements pelorus::ImuMsg imu; // ... fill IMU data ... pelorus.add_imu(imu); . // Receive odometry auto res = pelorus.try_recv(); if (res.status == pelorus::Pelorus::STATUS_OK) { const auto &odom = res.odom; std::cout << "Position: " << odom.position()[0] << "\n"; } . return 0; } ``` . ### PCL Integration . For projects using the Point Cloud Library (PCL): . ```cpp #include #include #include . pelorus::Pelorus pelorus; . // Convert and add PCL cloud to Pelorus pcl::PointCloud::Ptr cloud( new pcl::PointCloud()); // ... fill cloud ... pelorus::pcl::add_pointcloud(pelorus, cloud, timestamp_sec, timestamp_nsec); . // Get result auto result = pelorus.recv(); if (result.status == pelorus::Pelorus::STATUS_OK) { auto result_cloud = result.odom.get_cloud_pcl::Ptr>(); . // Or use the standalone function auto result_cloud2 = pelorus::pcl_helpers::to_pcl_cloud( result.odom.points(), result.odom.num_points()); } ``` . ### Eigen3 Integration . For projects using Eigen for transformations: . ```cpp #include #include . pelorus::Pelorus pelorus; auto result = pelorus.recv(); if (result.status == pelorus::Pelorus::STATUS_OK) { const auto &odom = result.odom; . // Get odometry as a transformation matrix Eigen::Isometry3d transform = pelorus::eigen::to_transform(odom); . // Transform a point from sensor to world coordinates Eigen::Vector3d point_sensor(1.0, 0.0, 0.0); Eigen::Vector3d point_world = transform * point_sensor; . // Get all odometry data as Eigen types auto state = pelorus::eigen::OdometryState::from_pelorus(odom); std::cout << "Position: " << state.transform.translation().transpose() << "\n"; std::cout << "Velocity: " << state.linear_velocity.transpose() << "\n"; std::cout << "Accelerometer bias: " << state.accel_bias.transpose() << "\n"; std::cout << "Gyroscope bias: " << state.gyro_bias.transpose() << "\n"; . // Extract individual components Eigen::Vector3d position = pelorus::eigen::to_position(odom.position()); Eigen::Quaterniond orientation = pelorus::eigen::to_quaternion(odom.orientation()); Eigen::Matrix pose_cov = pelorus::eigen::get_pose_covariance(*odom.get()); } ``` . ## Configuration . The library uses `.rl` configuration files: . ```c // Use custom configuration file to override defaults for your setup struct PelorusHandle* pelorus = pelorus_create("/path/to/my_config.rl"); . // Or: configure creation-time behavior without editing the on-disk .rl pelorus_create_options opts = PELORUS_CREATE_OPTIONS_DEFAULT; opts.config_path = "/path/to/my_config.rl"; // opts.device_specific_pointcloud2 = 0; // disable device-specific interpretation struct PelorusHandle* pelorus2 = pelorus_create_with_options(&opts); ``` . You can generate a default config file with: . ```bash pelorus config generate recommended > my_config.rl . # Or generate the complete default configuration: pelorus config generate full > my_config.rl ``` . All parameters (map resolution, IMU covariances, Lidar vendor, filtering options, etc.) are configurable. . ## API Design . Pelorus provides three ways to receive odometry results: . Bias-aware callers can use `pelorus_try_recv_with_bias()`, `pelorus_recv_with_bias()`, or `pelorus_set_callback_with_bias()`. These additive APIs return `pelorus_imu_bias` without changing the layout of the existing `pelorus_odometry` structure. The C++ wrapper uses these APIs automatically and exposes `Odometry::accel_bias()` and `Odometry::gyro_bias()`. . ### 1. Non-blocking (Polling) Use `pelorus_try_recv()` for non-blocking checks: ```c pelorus_odometry odom; int status = pelorus_try_recv(pelorus, &odom); if (status == PELORUS_STATUS_OK) { // Process odometry pelorus_free_odometry(&odom); } else if (status == PELORUS_STATUS_NO_DATA) { // No data available yet } else if (status == PELORUS_STATUS_CALLBACK_SET) { // Callback mode is active; polling APIs are unavailable } ``` . ### 2. Blocking (Synchronous) Use `pelorus_recv()` to wait for results: ```c pelorus_odometry odom; int status = pelorus_recv(pelorus, &odom); // Blocks until data available if (status == PELORUS_STATUS_OK) { // Process odometry pelorus_free_odometry(&odom); } else if (status == PELORUS_STATUS_CALLBACK_SET) { // Callback mode is active; cannot use blocking APIs } ``` . ### 3. Callback (Asynchronous) Use `pelorus_set_callback()` for event-driven processing: ```c void odometry_callback(const pelorus_odometry *odom, void *user_data) { // Process odometry (called from background thread) // No need to call pelorus_free_odometry() - handled automatically } . // Register callback pelorus_set_callback(pelorus, odometry_callback, user_data); . // Disable callback pelorus_set_callback(pelorus, NULL, NULL); ``` . **Note**: When using callbacks, `pelorus_try_recv()` and `pelorus_recv()` will not receive data. Callbacks and polling/blocking APIs are mutually exclusive. . ## Examples . See the `examples/` directory for complete usage examples: . - `async_callback.c` - Callback-based asynchronous example - `sync_blocking.c` - Synchronous blocking example - `sync_blocking_pcl_eigen.cpp` - C++ wrapper example with optional PCL/Eigen support - `eigen_example.cpp` - Eigen conversion example . Build and run examples: ```bash cd examples make ./async_callback ./sync_blocking ``` . ### Raw point helpers . If you already have raw point buffers (similar to the Python numpy input), you can avoid building a full `pelorus_pointcloud2` and instead call one of: . - `pelorus_add_points_xyzt_f32(...)` for Nx4 `[x,y,z,t]` (`t` is ns offset, cast to `uint32_t`) - `pelorus_add_points_xyzit_f32(...)` for Nx5 `[x,y,z,intensity,t]` . All of these are internally converted into a PointCloud2 with `x,y,z,intensity,t` fields. . ## Threading Model . The API is designed to be simple from the caller's perspective: - `pelorus_add_imu()`, `pelorus_add_odom()`, and `pelorus_add_pointcloud()` return immediately - Processing happens asynchronously in background threads - `pelorus_try_recv()` is non-blocking and returns immediately - `pelorus_recv()` blocks until data is available - Callbacks are invoked from a background thread . ## Memory Management . - Results from `pelorus_try_recv()` and `pelorus_recv()` must be freed with `pelorus_free_odometry()` - Callback results are automatically freed after the callback returns - The `PelorusHandle` must be destroyed with `pelorus_destroy()` . ## Timestamp semantics . Pelorus uses two timestamp levels: . 1. **IMU/Odom timestamps** (`timestamp_sec` + `timestamp_nanosec`) - Absolute timestamps (typically epoch / ROS time) used for synchronization. . 2. **Lidar timestamps** - `pelorus_pointcloud2.header_timestamp_sec/nanosec`: absolute reference time for the scan. - Per-point field `t` (if provided): `uint32` **nanoseconds offset**, **non-negative** and **forward in time** relative to the scan header timestamp. . The effective point time is: . `point_time_abs = header_time_abs + (t * 1e-9)` . ### Pelorus expects a simplified, single-row (unstructured) little-endian `PointCloud2`. . Interpretation of per-point timing depends on the parsing mode: . - When Pelorus uses *device-specific* parsing (the default), field meanings — including any `t` field — are interpreted according to the vendor/device configuration and may vary. - When using the generic parsing path (`device_specific_pointcloud2 == false`), Pelorus expects `t` to be a **non-negative** (`uint32`) nanoseconds offset relative to the scan header timestamp. . For generic point input, prefer `pelorus_add_points_xyzt_f32()` or `pelorus_add_points_xyzit_f32()`. . ## License . Dual-licensed under MIT and Apache 2.0, consistent with the Pelorus project. Package: libpelorus Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 66860 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/libpelorus_0.0.9-1_arm64.deb Size: 10369280 MD5sum: 66350bd3369d069dc57d0ef40b315aba SHA1: b15f3d0aabcfe2be4f82419617c657949a4dddeb SHA256: 64523011f24291c90d024fd0443c636329f71458d1a7650d042ea12fdab7f0cc SHA512: 8192fcd7a934d4da823314f43709da094f60f3678a613aca44e3fc2de56501c8bc8574243901433a313ff0acec401e33744fdd0df0e763547ad353cdd0157a15 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. # pelorus_c . C library bindings for Pelorus. . ## Building and Installation . ### CMake . The library can be built and installed using CMake: . ```bash cd pelorus_c mkdir build && cd build cmake .. make sudo make install ``` . #### CMake Options . - `PELORUS_BUILD_SHARED` - Build shared library (default: ON) - `PELORUS_BUILD_STATIC` - Build static library (default: ON) - `PELORUS_BUILD_EXAMPLES` - Build C/C++ examples (default: OFF) - `PELORUS_INSTALL` - Install library and headers (default: ON) . #### Feature Flags . - `PELORUS_FEATURE_RAYON` - Enable Rayon CPU parallelism (default: ON) - `PELORUS_FEATURE_METAL` - Enable Metal acceleration (default: OFF) - `PELORUS_FEATURE_CUDA` - Enable CUDA acceleration (default: OFF) - `PELORUS_FEATURE_VULKAN` - Enable Vulkan acceleration (default: OFF) - `PELORUS_FEATURE_NO_IMU_SYNC` - Disable IMU synchronization (default: OFF) - `PELORUS_FEATURE_LARGE_PROCESSING_QUEUE` - Use larger internal processing queues (default: OFF) . Select at most one GPU backend. Metal is available on macOS. CUDA requires a supported NVIDIA CUDA installation. Vulkan requires a compatible Vulkan device and driver. If no GPU backend is selected, Pelorus uses the CPU backend. . Example with CUDA: . ```bash cmake .. -DPELORUS_FEATURE_CUDA=ON ``` . ### Using Cargo (Direct) . You can also build directly with Cargo: . ```bash cargo build --package pelorus_c --release . # Select one GPU backend when needed: cargo build --package pelorus_c --release --features cuda cargo build --package pelorus_c --release --features vulkan cargo build --package pelorus_c --release --features metal ``` . ## Using the Library . ### In CMake Projects . After installation, use `find_package`: . ```cmake find_package(pelorus REQUIRED) add_executable(my_app main.c) target_link_libraries(my_app pelorus::pelorus) ``` . See [examples/CMAKE_USAGE.md](examples/CMAKE_USAGE.md) for more details. . ### With pkg-config . ```bash gcc my_app.c $(pkg-config --cflags --libs pelorus) -o my_app ``` . ### C++ Wrapper . A modern C++ wrapper is available in `pelorus.hpp`. . ```cpp #include #include . int main() { pelorus::Pelorus pelorus; . // Add measurements pelorus::ImuMsg imu; // ... fill IMU data ... pelorus.add_imu(imu); . // Receive odometry auto res = pelorus.try_recv(); if (res.status == pelorus::Pelorus::STATUS_OK) { const auto &odom = res.odom; std::cout << "Position: " << odom.position()[0] << "\n"; } . return 0; } ``` . ### PCL Integration . For projects using the Point Cloud Library (PCL): . ```cpp #include #include #include . pelorus::Pelorus pelorus; . // Convert and add PCL cloud to Pelorus pcl::PointCloud::Ptr cloud( new pcl::PointCloud()); // ... fill cloud ... pelorus::pcl::add_pointcloud(pelorus, cloud, timestamp_sec, timestamp_nsec); . // Get result auto result = pelorus.recv(); if (result.status == pelorus::Pelorus::STATUS_OK) { auto result_cloud = result.odom.get_cloud_pcl::Ptr>(); . // Or use the standalone function auto result_cloud2 = pelorus::pcl_helpers::to_pcl_cloud( result.odom.points(), result.odom.num_points()); } ``` . ### Eigen3 Integration . For projects using Eigen for transformations: . ```cpp #include #include . pelorus::Pelorus pelorus; auto result = pelorus.recv(); if (result.status == pelorus::Pelorus::STATUS_OK) { const auto &odom = result.odom; . // Get odometry as a transformation matrix Eigen::Isometry3d transform = pelorus::eigen::to_transform(odom); . // Transform a point from sensor to world coordinates Eigen::Vector3d point_sensor(1.0, 0.0, 0.0); Eigen::Vector3d point_world = transform * point_sensor; . // Get all odometry data as Eigen types auto state = pelorus::eigen::OdometryState::from_pelorus(odom); std::cout << "Position: " << state.transform.translation().transpose() << "\n"; std::cout << "Velocity: " << state.linear_velocity.transpose() << "\n"; std::cout << "Accelerometer bias: " << state.accel_bias.transpose() << "\n"; std::cout << "Gyroscope bias: " << state.gyro_bias.transpose() << "\n"; . // Extract individual components Eigen::Vector3d position = pelorus::eigen::to_position(odom.position()); Eigen::Quaterniond orientation = pelorus::eigen::to_quaternion(odom.orientation()); Eigen::Matrix pose_cov = pelorus::eigen::get_pose_covariance(*odom.get()); } ``` . ## Configuration . The library uses `.rl` configuration files: . ```c // Use custom configuration file to override defaults for your setup struct PelorusHandle* pelorus = pelorus_create("/path/to/my_config.rl"); . // Or: configure creation-time behavior without editing the on-disk .rl pelorus_create_options opts = PELORUS_CREATE_OPTIONS_DEFAULT; opts.config_path = "/path/to/my_config.rl"; // opts.device_specific_pointcloud2 = 0; // disable device-specific interpretation struct PelorusHandle* pelorus2 = pelorus_create_with_options(&opts); ``` . You can generate a default config file with: . ```bash pelorus config generate recommended > my_config.rl . # Or generate the complete default configuration: pelorus config generate full > my_config.rl ``` . All parameters (map resolution, IMU covariances, Lidar vendor, filtering options, etc.) are configurable. . ## API Design . Pelorus provides three ways to receive odometry results: . Bias-aware callers can use `pelorus_try_recv_with_bias()`, `pelorus_recv_with_bias()`, or `pelorus_set_callback_with_bias()`. These additive APIs return `pelorus_imu_bias` without changing the layout of the existing `pelorus_odometry` structure. The C++ wrapper uses these APIs automatically and exposes `Odometry::accel_bias()` and `Odometry::gyro_bias()`. . ### 1. Non-blocking (Polling) Use `pelorus_try_recv()` for non-blocking checks: ```c pelorus_odometry odom; int status = pelorus_try_recv(pelorus, &odom); if (status == PELORUS_STATUS_OK) { // Process odometry pelorus_free_odometry(&odom); } else if (status == PELORUS_STATUS_NO_DATA) { // No data available yet } else if (status == PELORUS_STATUS_CALLBACK_SET) { // Callback mode is active; polling APIs are unavailable } ``` . ### 2. Blocking (Synchronous) Use `pelorus_recv()` to wait for results: ```c pelorus_odometry odom; int status = pelorus_recv(pelorus, &odom); // Blocks until data available if (status == PELORUS_STATUS_OK) { // Process odometry pelorus_free_odometry(&odom); } else if (status == PELORUS_STATUS_CALLBACK_SET) { // Callback mode is active; cannot use blocking APIs } ``` . ### 3. Callback (Asynchronous) Use `pelorus_set_callback()` for event-driven processing: ```c void odometry_callback(const pelorus_odometry *odom, void *user_data) { // Process odometry (called from background thread) // No need to call pelorus_free_odometry() - handled automatically } . // Register callback pelorus_set_callback(pelorus, odometry_callback, user_data); . // Disable callback pelorus_set_callback(pelorus, NULL, NULL); ``` . **Note**: When using callbacks, `pelorus_try_recv()` and `pelorus_recv()` will not receive data. Callbacks and polling/blocking APIs are mutually exclusive. . ## Examples . See the `examples/` directory for complete usage examples: . - `async_callback.c` - Callback-based asynchronous example - `sync_blocking.c` - Synchronous blocking example - `sync_blocking_pcl_eigen.cpp` - C++ wrapper example with optional PCL/Eigen support - `eigen_example.cpp` - Eigen conversion example . Build and run examples: ```bash cd examples make ./async_callback ./sync_blocking ``` . ### Raw point helpers . If you already have raw point buffers (similar to the Python numpy input), you can avoid building a full `pelorus_pointcloud2` and instead call one of: . - `pelorus_add_points_xyzt_f32(...)` for Nx4 `[x,y,z,t]` (`t` is ns offset, cast to `uint32_t`) - `pelorus_add_points_xyzit_f32(...)` for Nx5 `[x,y,z,intensity,t]` . All of these are internally converted into a PointCloud2 with `x,y,z,intensity,t` fields. . ## Threading Model . The API is designed to be simple from the caller's perspective: - `pelorus_add_imu()`, `pelorus_add_odom()`, and `pelorus_add_pointcloud()` return immediately - Processing happens asynchronously in background threads - `pelorus_try_recv()` is non-blocking and returns immediately - `pelorus_recv()` blocks until data is available - Callbacks are invoked from a background thread . ## Memory Management . - Results from `pelorus_try_recv()` and `pelorus_recv()` must be freed with `pelorus_free_odometry()` - Callback results are automatically freed after the callback returns - The `PelorusHandle` must be destroyed with `pelorus_destroy()` . ## Timestamp semantics . Pelorus uses two timestamp levels: . 1. **IMU/Odom timestamps** (`timestamp_sec` + `timestamp_nanosec`) - Absolute timestamps (typically epoch / ROS time) used for synchronization. . 2. **Lidar timestamps** - `pelorus_pointcloud2.header_timestamp_sec/nanosec`: absolute reference time for the scan. - Per-point field `t` (if provided): `uint32` **nanoseconds offset**, **non-negative** and **forward in time** relative to the scan header timestamp. . The effective point time is: . `point_time_abs = header_time_abs + (t * 1e-9)` . ### Pelorus expects a simplified, single-row (unstructured) little-endian `PointCloud2`. . Interpretation of per-point timing depends on the parsing mode: . - When Pelorus uses *device-specific* parsing (the default), field meanings — including any `t` field — are interpreted according to the vendor/device configuration and may vary. - When using the generic parsing path (`device_specific_pointcloud2 == false`), Pelorus expects `t` to be a **non-negative** (`uint32`) nanoseconds offset relative to the scan header timestamp. . For generic point input, prefer `pelorus_add_points_xyzt_f32()` or `pelorus_add_points_xyzit_f32()`. . ## License . Dual-licensed under MIT and Apache 2.0, consistent with the Pelorus project. Package: libpelorus_glim_odometry-cuda12-6 Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 196 Depends: libpelorus-cuda12-6 ( = 0.0.9-1 ) Filename: pool/main/jammy/libpelorus_glim_odometry-cuda12-6_0.0.9-1_arm64.deb Size: 56920 MD5sum: 468624408ae26b7fb77f3424bd19785c SHA1: 8c52b7251c011c6fa2d1400d0fca4bca9302042a SHA256: 3e6cd1d5a78fb5b334b623a8ede91c150e96cb5556b7dbfb464f7c177037cdb4 SHA512: 70129403a2c0eade9015f8999595cde75955cfb250f0ac7b96b9cd4dfcc4c090e6d3d506fa594d558e585856009b1fc9e08fdb0ab9bbd1706ec33fe94d37777f Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a GLIM plugin. # pelorus_glim_odometry . GLIM odometry backend plugin that runs Pelorus as the odometry estimation module. . ```sh cd pelorus/glim_integration/pelorus_glim_odometry mkdir build && cd build cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local make sudo -E make install ``` . ## Enable Pelorus odometry in GLIM . > Note: Pelorus needs GLIM's IMU subscription in `config_ros` to use reliable > QoS (`glim_ros.imu_qos.reliability = "reliable"`). . In GLIM's `config.json`, set: - `"config_odometry": "config_odometry_pelorus.json"` . Create the config file in your GLIM config root: . ```json { "odometry_estimation": { "so_name": "libodometry_estimation_pelorus.so", "use_glim_config": true, . // optional, overrides all glim configs //"pelorus_rl_path": "path/to/your/pelorus.rl", . "query_resolution_factor": 0.5, "map_resolution": 0.5 } } ``` . `query_resolution_factor` is forwarded unchanged to Pelorus. The resulting query voxel size is `query_resolution_factor * map_resolution`. . The generated Pelorus overlay selects backend preprocessing. CUDA, Vulkan, or Metal is used when the corresponding backend is built and available. Otherwise Pelorus falls back to CPU preprocessing. . Pelorus accelerometer and gyroscope bias estimates are forwarded to GLIM's `EstimationFrame::imu_bias` in `[accelerometer, gyroscope]` order. . Now run GLIM as usual. Package: libpelorus_glim_odometry-cuda12-8 Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 196 Depends: libpelorus-cuda12-8 ( = 0.0.9-1 ) Filename: pool/main/jammy/libpelorus_glim_odometry-cuda12-8_0.0.9-1_arm64.deb Size: 56964 MD5sum: 4832dfd569506b16201ec66175ba4183 SHA1: 4cb9e2e9cdbec6c6b4216a3b9139dd331b7179f7 SHA256: b8228f2f85487b17bac266b9b183bd3ab6dea027e7833f6a90a9884875a5e289 SHA512: 3d4b23d9dc4ee742b5103f42804046b0e53e7f9212bbf1fe6546b4afeb73ddc054a9db4000a51db66a275c9dc3fef2108534c9cc0f7f9a85a08760a99684b190 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a GLIM plugin. # pelorus_glim_odometry . GLIM odometry backend plugin that runs Pelorus as the odometry estimation module. . ```sh cd pelorus/glim_integration/pelorus_glim_odometry mkdir build && cd build cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local make sudo -E make install ``` . ## Enable Pelorus odometry in GLIM . > Note: Pelorus needs GLIM's IMU subscription in `config_ros` to use reliable > QoS (`glim_ros.imu_qos.reliability = "reliable"`). . In GLIM's `config.json`, set: - `"config_odometry": "config_odometry_pelorus.json"` . Create the config file in your GLIM config root: . ```json { "odometry_estimation": { "so_name": "libodometry_estimation_pelorus.so", "use_glim_config": true, . // optional, overrides all glim configs //"pelorus_rl_path": "path/to/your/pelorus.rl", . "query_resolution_factor": 0.5, "map_resolution": 0.5 } } ``` . `query_resolution_factor` is forwarded unchanged to Pelorus. The resulting query voxel size is `query_resolution_factor * map_resolution`. . The generated Pelorus overlay selects backend preprocessing. CUDA, Vulkan, or Metal is used when the corresponding backend is built and available. Otherwise Pelorus falls back to CPU preprocessing. . Pelorus accelerometer and gyroscope bias estimates are forwarded to GLIM's `EstimationFrame::imu_bias` in `[accelerometer, gyroscope]` order. . Now run GLIM as usual. Package: libpelorus_glim_odometry-cuda13-1 Architecture: arm64 Version: 0.0.7-1 Priority: optional Section: libs Maintainer: Christopher Sieh Installed-Size: 2269 Depends: libpelorus-cuda13-1 ( = 0.0.7-1 ) Filename: pool/main/jammy/libpelorus_glim_odometry-cuda13-1_0.0.7-1_arm64.deb Size: 264300 MD5sum: f54fa7575a0a86d93fda3d76a27e77fe SHA1: 6af14089b9fd626f865df9d01aaec999853f4fdb SHA256: 596f3550676bccf61f5e35a6f49d7b94be93c552067586dd78b2f7e294d76578 SHA512: 086002f7ce6fc34a7869280f83c9c8db15bcf68b648f87570be39b70b6f511fce4ba7426ff1aaec3d17d712344c7d7aa40c009f6cc510e49e4f1479fb32942a5 Homepage: https://codeberg.org/stelzo/pelorus/ Description: Pelorus Odometry as a GLIM plugin. # pelorus_glim_odometry . GLIM odometry backend plugin that runs Pelorus as the odometry estimation module. . ```sh cd pelorus/glim_integration/pelorus_glim_odometry mkdir build && cd build cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local make sudo -E make install ``` . ## Enable Pelorus odometry in GLIM . > Note: Pelorus needs GLIM's IMU subscription in `config_ros` to use reliable > QoS (`glim_ros.imu_qos.reliability = "reliable"`). . In GLIM's `config.json`, set: - `"config_odometry": "config_odometry_pelorus.json"` . Create the config file in your GLIM config root: . ```json { "odometry_estimation": { "so_name": "libodometry_estimation_pelorus.so", "use_glim_config": true, . // optional, overrides all glim configs //"pelorus_rl_path": "path/to/your/pelorus.rl", . "query_resolution_factor": 0.5, "map_resolution": 0.5 } } ``` . `query_resolution_factor` is forwarded unchanged to Pelorus. The resulting query voxel size is `query_resolution_factor * map_resolution`. . The generated Pelorus overlay selects backend preprocessing. CUDA, Vulkan, or Metal is used when the corresponding backend is built and available; otherwise Pelorus falls back to CPU preprocessing. . Pelorus accelerometer and gyroscope bias estimates are forwarded to GLIM's `EstimationFrame::imu_bias` in `[accelerometer, gyroscope]` order. . Now run GLIM as usual. Package: libpelorus_glim_odometry-vulkan Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 196 Depends: libpelorus-vulkan ( = 0.0.9-1 ) Filename: pool/main/jammy/libpelorus_glim_odometry-vulkan_0.0.9-1_arm64.deb Size: 56948 MD5sum: 4808096b7e7d0bc97fbc37289fb94bfb SHA1: 13497abf598569dde3a66e39c76c7135b0b8b668 SHA256: e2a8fd3b688195138e4dbb93eedb448e25779eb3afc59d5741890981bbe36a9a SHA512: efbe2a5592f2a9172916017abddb323e49894fc7662ab7b609f7383233646d8600ed7cc90fc99889ceb8f24452b8adfe60437b476b7c1d06876af2c91209a651 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a GLIM plugin. # pelorus_glim_odometry . GLIM odometry backend plugin that runs Pelorus as the odometry estimation module. . ```sh cd pelorus/glim_integration/pelorus_glim_odometry mkdir build && cd build cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local make sudo -E make install ``` . ## Enable Pelorus odometry in GLIM . > Note: Pelorus needs GLIM's IMU subscription in `config_ros` to use reliable > QoS (`glim_ros.imu_qos.reliability = "reliable"`). . In GLIM's `config.json`, set: - `"config_odometry": "config_odometry_pelorus.json"` . Create the config file in your GLIM config root: . ```json { "odometry_estimation": { "so_name": "libodometry_estimation_pelorus.so", "use_glim_config": true, . // optional, overrides all glim configs //"pelorus_rl_path": "path/to/your/pelorus.rl", . "query_resolution_factor": 0.5, "map_resolution": 0.5 } } ``` . `query_resolution_factor` is forwarded unchanged to Pelorus. The resulting query voxel size is `query_resolution_factor * map_resolution`. . The generated Pelorus overlay selects backend preprocessing. CUDA, Vulkan, or Metal is used when the corresponding backend is built and available. Otherwise Pelorus falls back to CPU preprocessing. . Pelorus accelerometer and gyroscope bias estimates are forwarded to GLIM's `EstimationFrame::imu_bias` in `[accelerometer, gyroscope]` order. . Now run GLIM as usual. Package: libpelorus_glim_odometry Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 196 Depends: libpelorus ( = 0.0.9-1 ) Filename: pool/main/jammy/libpelorus_glim_odometry_0.0.9-1_arm64.deb Size: 56908 MD5sum: fa0de53d7926a05d3959364572baa25b SHA1: 249d9d9e9319b2db19ff1f0e84eccae0c2a86ed3 SHA256: 03ce3eae89791d4a934700d95bee4c5a488bfafa1e8cb0ead66187e1988b5089 SHA512: 000298552ae954258f7c4a8367a3a6f304699f93f5e204e48d013f9ac55b8055eee288b3a73cab99add487ab939693af805d9140eea01943270fa0e9a658de98 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a GLIM plugin. # pelorus_glim_odometry . GLIM odometry backend plugin that runs Pelorus as the odometry estimation module. . ```sh cd pelorus/glim_integration/pelorus_glim_odometry mkdir build && cd build cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local make sudo -E make install ``` . ## Enable Pelorus odometry in GLIM . > Note: Pelorus needs GLIM's IMU subscription in `config_ros` to use reliable > QoS (`glim_ros.imu_qos.reliability = "reliable"`). . In GLIM's `config.json`, set: - `"config_odometry": "config_odometry_pelorus.json"` . Create the config file in your GLIM config root: . ```json { "odometry_estimation": { "so_name": "libodometry_estimation_pelorus.so", "use_glim_config": true, . // optional, overrides all glim configs //"pelorus_rl_path": "path/to/your/pelorus.rl", . "query_resolution_factor": 0.5, "map_resolution": 0.5 } } ``` . `query_resolution_factor` is forwarded unchanged to Pelorus. The resulting query voxel size is `query_resolution_factor * map_resolution`. . The generated Pelorus overlay selects backend preprocessing. CUDA, Vulkan, or Metal is used when the corresponding backend is built and available. Otherwise Pelorus falls back to CPU preprocessing. . Pelorus accelerometer and gyroscope bias estimates are forwarded to GLIM's `EstimationFrame::imu_bias` in `[accelerometer, gyroscope]` order. . Now run GLIM as usual. Package: librat-dev Architecture: arm64 Version: 0.14.1-1 Priority: optional Installed-Size: 36573 Depends: libc6:arm64 (>= 2.35) Filename: pool/main/jammy/librat-dev_0.14.1-1_arm64.deb Size: 6824064 MD5sum: b8cb672d745fcf0d755ee52a5d3947d3 SHA1: c5758699c203deb0e3a06ca0b1a0d6341e9d10b4 SHA256: d59800b0b45e31f8536366cb46b2f1851ad2202c222e9dfa89a6cdeb760877e4 SHA512: a1ff0316f9e98ce4038da8d89d1eaa645e06ebbedf226ee2a1be3e2f2c347e513d51972a945ce7b1463c42f499af3a5520d5c1ca2bf76fe7af5eb748788bc47a Homepage: https://minot.steado.tech Description: Share and sync variables over the Minot network. # mt_rat . Part of the [minot](https://minot.steado.tech) family of crates. . [![Latest version](https://img.shields.io/crates/v/mt_rat.svg)](https://crates.io/crates/mt_rat) ![MIT](https://img.shields.io/badge/license-MIT-blue.svg) ![Apache](https://img.shields.io/badge/license-Apache-blue.svg) . Share and sync variables over the Minot network. Package: marina Architecture: arm64 Version: 0.5.4-1 Priority: optional Section: science Installed-Size: 18714 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/marina_0.5.4-1_arm64.deb Size: 4945628 MD5sum: 3bd9f10027cc9d5c374af9591a5ebe9b SHA1: 7731ec431553b7a8b697ef676762e3e90b4513cf SHA256: 24dfd23f0f2fe3653de43cc782b92698e7604fef3581790f76426971d255315c SHA512: 19fcdb19d3e7bfcca4e965831676da4e68a30616830316892d47bad0598733e8676b64d637defc4f10a89c334afd5c31a05391cf397098d8f6ff8c5153487033 Homepage: https://marina.steado.tech Description: A dataset manager for robotics to organize, share, and discover datasets and metadata across storage backends. Marina logo . # marina . **Marina** is a dataset manager for robotics built to organize, share, and discover bags and datasets across teams and storage backends. . See the [Web Documentation](https://marina.steado.tech/docs/) or `ssh marina@steado.tech` for more detailed information and setup. . ## ROS 2 CLI . While Marina's dynamic autocomplete for modern shells is designed to work as a standalone tool, we provide a ROS 2 CLI mapping to ensure a more familiar user experience. . ```bash # Pull a dataset from any configured registry... ros2 bag pull dlg_feldtage_24:cut . # and pass it straight to playback. ros2 bag play $(ros2 bag resolve dlg_feldtage_24:cut) . # See available bags from configured remotes... ros2 bag datasets --remote # or use the alias. ros2 bag ds --remote ``` . Datasets are pulled from remote registries. You can easily create your own using SSH, Google Drive, HTTP or any filesystem folder. . ```bash # Record to local cache... ros2 bag record --all -o $(ros2 bag import my_recording:session1) . # and push to your registry. ros2 bag push my-run:v1 /path/to/bag/ --registry team_ssh ``` . ## Standalone . Marina supports Linux and MacOS environments without additional requirements. Just [install](https://marina.steado.tech/docs/installation/packages.html) and run. . ```bash # Explore datasets and registries interactively. marina . # Pull a dataset from any configured registry. marina pull dlg_feldtage_24:cut . # Get and use the data from the local cache. cat $(marina resolve dlg_feldtage_24:cut)/metadata.yaml . # See available bags from configured remotes... marina list --remote # or use the alias. marina ls --remote . # Export the most verbose remote catalog JSON for the static explorer. marina list --remote --format json > web/catalog.json . # Push any folder or bags to your registry. marina bag push my-run:v1 /path/to/dataset/ --registry team_ssh ``` . --- . ### License . Licensed under either of Apache License, Version 2.0 or MIT license at your option. .
. Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions. Package: minot Architecture: arm64 Version: 0.14.1-1 Priority: optional Section: science Installed-Size: 20281 Depends: libc6:arm64 (>= 2.35) Filename: pool/main/jammy/minot_0.14.1-1_arm64.deb Size: 6377188 MD5sum: 689684262d9bdc6232f13c6af39cd08f SHA1: c158f40c9bab64dbb6d5037acab728ab78ae2c0a SHA256: 0c31391c192a81aea0c56fc4dc79927bafae5b70c680865d6393cc7e27b196c9 SHA512: 355105231ce32f6fda7163779619704c288b585a83be6c1f0e2f10b0bade3fd6720145c53e22566dca774114cb53ed06e2fbb4478e608d8e321d3e23ac5b3124 Homepage: https://minot.steado.tech Description: A versatile toolset for debugging and verifying stateful robot perception software. # Minot . Minot is a highly versatile toolset for debugging and verifying stateful robot perception software. Some common use cases are: . * Fine-grained rosbag publishing * Synchronous, deterministic and reproducable testing * ROS1 -> ROS2 or language migrations * Functional method evaluations . Visit the [Documentation](https://uos.github.io/minot) to find out more. . [![Latest version](https://img.shields.io/crates/v/minot.svg)](https://crates.io/crates/minot) ![MIT](https://img.shields.io/badge/license-MIT-blue.svg) ![Apache](https://img.shields.io/badge/license-Apache-blue.svg) . ~~~sh cargo install minot ~~~ Package: pelorus-cuda12-6 Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: science Installed-Size: 40329 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/jammy/pelorus-cuda12-6_0.0.9-1_arm64.deb Size: 9326284 MD5sum: a7883b6a963f16448ed536c93ef559d0 SHA1: bb473da5067add57070e63bd72a487241021bfc0 SHA256: 86cc81bc295770ba8cfd92ba72e21876ef5520826c07a0cf2e983f99dc063c7a SHA512: 3cc1824d58f6579630d251674b8b40bf45cf8f17a018f522b37430542ad42331aee993c07efaea31e2ccd0fcdada581e63790ed7bb0d6a0b9f63fedaba07b6dc Homepage: https://codeberg.org/stelzo/pelorus Description: Resource-aware Lidar-Inertial Odometry. Package: pelorus-cuda12-8 Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: science Installed-Size: 41085 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/jammy/pelorus-cuda12-8_0.0.9-1_arm64.deb Size: 9541176 MD5sum: e323f56058d90bd62532c0ea0ec6ea95 SHA1: befbd4dcd1e8195f77b4e77d0d37dc0cb5f378fc SHA256: e427f4ab813cfd45e266f7ce5df8e50c28871c769729e071344983e802d4b694 SHA512: 7d1dc07e678e4b7d6327280a5865af9f523ce8216a90ab9ddc96e5f931d99d0e83b1208a2764d0abb52d3f68be411ca3281c9a6b3e0959d5d5cefe72304604fb Homepage: https://codeberg.org/stelzo/pelorus Description: Resource-aware Lidar-Inertial Odometry. Package: pelorus-cuda13-1 Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: science Installed-Size: 37741 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/jammy/pelorus-cuda13-1_0.0.9-1_arm64.deb Size: 10181744 MD5sum: d321b2e1dd0581fef1bb30cb6787d2c2 SHA1: 649176ff64182c37b018e6b4cb543ec6e1b8ea7f SHA256: 5d78f14d124417abdcd1a83dc35af07507d0c6452c43e48f7ff697bf4b4efd5f SHA512: eaee9b50b0794275474971b279598dfd30b59eca16e028a9b8edbf33b49435cfe9455d338a90e468dd159b5ecd343401fb28b0dbf0405e0e3189cabf88a79222 Homepage: https://codeberg.org/stelzo/pelorus Description: Resource-aware Lidar-Inertial Odometry. Package: pelorus-vulkan Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: science Installed-Size: 39772 Depends: libvulkan1, minot (<< 0.12.0~), minot (>= 0.11.0) Filename: pool/main/jammy/pelorus-vulkan_0.0.9-1_arm64.deb Size: 9736196 MD5sum: 8118b74561c28db49f64ffcf744ff52f SHA1: 514cce830ff96feb639420ed33f881da49122cca SHA256: 1c0947cc73ca4dd5f22216ebbe585890a060373edc469265553301446eee022e SHA512: fc428311582f0556bb9df8f578562759635e18a874de416cf9844ae0fe2d48c93201691d3002a1fdce480a84c5b5dc19db8e100f5858ab8a989fcdca599bc823 Homepage: https://codeberg.org/stelzo/pelorus Description: Resource-aware Lidar-Inertial Odometry. Package: pelorus Architecture: arm64 Version: 0.0.9-1 Priority: optional Section: science Installed-Size: 33780 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/jammy/pelorus_0.0.9-1_arm64.deb Size: 8045000 MD5sum: e69294dd5a48b39a46b304e0582e41b6 SHA1: 1a6a5d48286c9af77336f5655420ee371edf2b29 SHA256: e5880cf7b2b5f2731343b67093a6bb55be289cbe2f97341aa5d8de5d87da7ac5 SHA512: 4e0bf747083cd2fbe2cecddd7e5c5efa3df712d1e948a1e05b81f3a2d8e7f64a432b4e8848fd591b553078505a2ec498489641b2bae192537322655bfd440ab9 Homepage: https://codeberg.org/stelzo/pelorus Description: Resource-aware Lidar-Inertial Odometry. Package: ratslang Architecture: arm64 Version: 0.5.0-1 Priority: optional Section: devel Installed-Size: 8998 Depends: libc6:arm64 (>= 2.35) Filename: pool/main/jammy/ratslang_0.5.0-1_arm64.deb Size: 2688696 MD5sum: ffaa16e73144148afe1c48da8869b01d SHA1: da101a5abd2436ced6c6e8c1c412ef72e2127b30 SHA256: eea81ad295d4c0427117702bff24d29d67c603953665ada1687436715f5ab962 SHA512: 3cb226d5300941168f9f6f5795f15933df58400b2c9adeacab8f7a7f163b9d3adf872d970b801499e79a38ac4ef6af5c4c56a62cb435656489de6eb9291aee2f Homepage: https://stelzo.codeberg.page/ratslang/tools/cli/ Description: Check, format, explain and migrate Ratslang configuration files. The ratslang command checks, formats, explains and migrates Ratslang configuration files. ratslang-lsp is the language server for editors. Package: ros-humble-marina Architecture: arm64 Version: 0.5.4-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 39056 Depends: libc6 (>= 2.34), libgcc-s1 (>= 4.2), libclang-dev, ros-humble-ros2bag, ros-humble-ros2cli Filename: pool/main/jammy/ros-humble-marina_0.5.4-0jammy_arm64.deb Size: 12611232 MD5sum: 49e8b82e3b20dc6303cefe14c4328a68 SHA1: 9ebde5a8e72c73e53f3118911d5deac15d8ec42d SHA256: 30fdd0f0f5239b672de4faaee5e2560aa53894423acaccbcb61a01a6148117a7 SHA512: f07af8e1fbd477cf0696df45a984ccb7f07685377c2d7e6716805aee383e6979df342ef4be033ba903ca59aa07d67f9ee3819eea995849f1d87ce22b8fb69ff2 Description: A dataset manager for robotics to organize, share, and discover datasets and metadata across storage backends. Package: ros-humble-minot Architecture: arm64 Version: 0.14.1-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 25572 Depends: libc6 (>= 2.34), libgcc-s1 (>= 4.2), ros-humble-builtin-interfaces, ros-humble-geometry-msgs, ros-humble-nav-msgs, ros-humble-rcl, ros-humble-rcl-action, ros-humble-rosgraph-msgs, ros-humble-sensor-msgs, ros-humble-std-msgs, ros-humble-tf2-msgs Filename: pool/main/jammy/ros-humble-minot_0.14.1-0jammy_arm64.deb Size: 7484578 MD5sum: 2e8e5d286b7037abdf8a51d4866b401f SHA1: 4314fd91ba043a1587d273a1c2ae51c951d76f15 SHA256: b2e3859aff2d5f79f10f4e1baae8699cd0cbe22df1abf524cb3b0c5484938ebe SHA512: c4a878b0c4afbd2b9a0c50a0f4e5668aafb61f607da068328ec08c634cfe17ab5af48d1a4ddb78bd1e90b858ac3b28ec89b159bb3422c206cacad3d873bbe682 Description: A versatile toolset for debugging and verifying stateful robot perception software. Package: ros-humble-pelorus-cuda12-6 Architecture: arm64 Version: 0.0.9-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 56225 Depends: ros-humble-launch, ros-humble-launch-ros, ros-humble-nav-msgs, ros-humble-rcl, ros-humble-rviz2, ros-humble-sensor-msgs, ros-humble-tf2-msgs, ros-humble-visualization-msgs Filename: pool/main/jammy/ros-humble-pelorus-cuda12-6_0.0.9-0jammy_arm64.deb Size: 15767290 MD5sum: 13d61b10eecd63d2a400b672aee8cb48 SHA1: 893c1b878b75bea75a0786f71454e6044157578a SHA256: 859005e4249160583d464ed8ee5d60996b6f37db51911439ff023bc5fd7775b5 SHA512: 91ea24c2743abca1672c0228c80d3e63fb2560305c3e259c0d951e1b15b1ebb0a5f1fc0c36629c8783746233fa23c4afb03198db7c7e8fcc3740a36fb19130b4 Description: Pelorus ROS2 Package: ros-humble-pelorus-cuda12-8 Architecture: arm64 Version: 0.0.9-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 57793 Depends: ros-humble-launch, ros-humble-launch-ros, ros-humble-nav-msgs, ros-humble-rcl, ros-humble-rviz2, ros-humble-sensor-msgs, ros-humble-tf2-msgs, ros-humble-visualization-msgs Filename: pool/main/jammy/ros-humble-pelorus-cuda12-8_0.0.9-0jammy_arm64.deb Size: 16225932 MD5sum: cd26eec2f98bafee7d076e98d41e6ae4 SHA1: 2ef98fc9c0bc2a1711319c75e291ba5a181e7968 SHA256: 63d1a35e431dae393e7504d9d6621ef1c4cd7f7af6562477ef0d5c743ed2b441 SHA512: 59370bdddb6aca16a07fb7fdfde4eebce77500c6bbaee2f3080c4d9667885eb5eeb7642c95c182bbf61de2efd4af59d5892bd9abf9860f3d45e5f6893a517180 Description: Pelorus ROS2 Package: ros-humble-pelorus-cuda13-1 Architecture: arm64 Version: 0.0.9-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 51073 Depends: ros-humble-launch, ros-humble-launch-ros, ros-humble-nav-msgs, ros-humble-rcl, ros-humble-rviz2, ros-humble-sensor-msgs, ros-humble-tf2-msgs, ros-humble-visualization-msgs Filename: pool/main/jammy/ros-humble-pelorus-cuda13-1_0.0.9-0jammy_arm64.deb Size: 17166688 MD5sum: 3e653a292171b44829a1da8ea3bea4a5 SHA1: c22d3655a8e2ec793ebc9d594f5de549207593dc SHA256: c703f895080269b68679994fcf0043dbcc3f2b37d1136f43a2b8234302581e04 SHA512: 42b4676d0ae31180fd5e3c3a346bfe631d0fe1976b01710d6bfeef2b2df72b772a6d872f44a2ab957988d731995ac0028961f3b363432e621c49b9440b0644b7 Description: Pelorus ROS2 Package: ros-humble-pelorus-vulkan Architecture: arm64 Version: 0.0.9-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 55117 Depends: libc6 (>= 2.34), libgcc-s1 (>= 4.2), libstdc++6 (>= 11), libvulkan1 (>= 1.2.131.2), ros-humble-launch, ros-humble-launch-ros, ros-humble-nav-msgs, ros-humble-rcl, ros-humble-rviz2, ros-humble-sensor-msgs, ros-humble-tf2-msgs, ros-humble-visualization-msgs Filename: pool/main/jammy/ros-humble-pelorus-vulkan_0.0.9-0jammy_arm64.deb Size: 16890922 MD5sum: 85e3bdb4eb2ccb9628f587f4785ecad5 SHA1: fbac6cdb02fcfdff537ad23927cd13d137ecdf35 SHA256: c4cc3bf10533e68e8945b1e9975b30d44d7ff0332aae90d513deac08f34818b1 SHA512: 63c4a2517666be28c0e9146cf0223e974cfd764bb9941e9bec01545e662aca26d7a097207aad2686ff29ee8cf16eac5ad6d0e9870d36ad196e7d2e739f236b99 Description: Pelorus ROS2 Package: ros-humble-pelorus Architecture: arm64 Version: 0.0.9-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 43093 Depends: libc6 (>= 2.34), libgcc-s1 (>= 4.2), ros-humble-launch, ros-humble-launch-ros, ros-humble-nav-msgs, ros-humble-rcl, ros-humble-rviz2, ros-humble-sensor-msgs, ros-humble-tf2-msgs, ros-humble-visualization-msgs Filename: pool/main/jammy/ros-humble-pelorus_0.0.9-0jammy_arm64.deb Size: 12983650 MD5sum: c9f879ac7677425982ffe192896aa731 SHA1: 49077f22e1187f41dd75a2331a3e62a5e501758c SHA256: 35538d750ddd886b787652209935c138c2ed29164239db16e453bee0bbbb3fde SHA512: b38ab8fff54bee57e0688ae694d1a5f7e34ce21261b8fe84db853a2f76a4d95e99eb08f7910911f48c622e7311548c07ae7598dc0ddf48048ee5614fe31743c8 Description: Pelorus ROS2 Package: sounding Architecture: arm64 Version: 0.4.1-1 Priority: optional Section: science Maintainer: stelzo Installed-Size: 1672 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/sounding_0.4.1-1_arm64.deb Size: 560508 MD5sum: 50080f9a33d96eae0cd76b50b89df296 SHA1: ef1c500e30c862aaa4087ea4e09efd4c7d098529 SHA256: ac789e5f1fb88b6c671311e7a6d7cd1f2d8b14c060f61b817dcd3d966c4d67fa SHA512: 8100a52ea751aca718fbc99a6332418fb6647a1e44d0db99d1272d92ec32fdf95dfff364bfec62dd8c08dd91eb4b10a164dbc926d48feb26c136d8d4e030d407 Homepage: https://codeberg.org/stelzo/sounding Description: A SLAM evaluation tool. # sounding . CLI tool for: - trajectory evaluation (`trajectory`) - process/system profiling (`probe`) . ## Install . We need the fontconfig library. For Ubuntu, you can `sudo apt install libfontconfig-dev`. . ### From crates.io (recommended) . ```bash cargo install sounding ``` . Or with rerun for visualisation: . ```bash cargo install sounding --features rerun ``` . ### Fast binary install with cargo-binstall . ```bash cargo binstall sounding ``` . ### Linux/macOS release archives . Download the matching `tar.gz` from releases, then install: . ```bash tar -xzf sounding--.tar.gz sudo install -m 755 sounding--/sounding /usr/local/bin/sounding ``` . ### Arch Linux (btw) (AUR) . Source build package: . ```bash yay -S sounding ``` . Prebuilt binary package: . ```bash yay -S sounding-bin ``` . ### Homebrew (macOS) . ```bash brew tap uos/sounding brew install sounding ``` . ### Debian/Ubuntu packages . `.deb` packages are published in the [PPA repository](https://ppa.steado.tech). . ## Shell completions . Run `sounding completions` to detect the current shell and install completions for the current user. Pass a shell explicitly, such as `sounding completions bash`, to print a completion script for packaging or a system-wide installation instead. . ## Build from source . ```bash cargo build --release ``` . ## Run . ```bash # all commands cargo run -- --help ``` . ## Trajectory command . ```bash cargo run -- trajectory ``` . Common options: . ```bash --json --export-summary-json [JSON_FILE] --export-plots-dir [DIR] --reference-body-extrinsic --delta # RPE interval in seconds (default: 1) --rerun ``` . `--reference-body-extrinsic` converts the reference trajectory into another body frame before evaluation. Pass the transform from the desired comparison frame into the current reference frame; it is right-multiplied onto each reference pose. For example, if the reference poses are IMU poses and the estimate is in the LiDAR frame, pass the LiDAR-to-IMU extrinsic. . ## Probe command . ```bash cargo run -- probe --output-dir ``` . Common options: . ```bash --json --output-dir --interval --strict --rerun ```