Package: dedrunk Architecture: amd64 Version: 0.1.1-1 Priority: optional Section: science Maintainer: stelzo Installed-Size: 18111 Depends: libc6 (>= 2.35) Filename: pool/main/jammy/dedrunk_0.1.1-1_amd64.deb Size: 5346864 MD5sum: 7403958a8fb86a5f79462f92cfe61f26 SHA1: 71c68f53149e0e21c693ac85265422730ccad412 SHA256: 02de11af8f8b232de421ebfe73937e303f52b3bbafa51f958191af439ae50212 SHA512: ba00091c1305bf52ba241bd6f3863dac18cca2c62ae3d4d394149e18adfec90f510cfc24eb9c1ea16f4495465f22cc56deb3cdc48796175fb7b9cd391d0c3702 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: amd64 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_amd64.deb Size: 8908 MD5sum: 8560c3130a7cd7cfde0bfb42ee756a14 SHA1: 1390aa70b8b1d69cb1c6356f99551cf7a4121b6f SHA256: cbdeacc1e7884afe71289d2ddadddee9c55942188dc2abb26d2af0803e615985 SHA512: 74af44301825ab7b8a2f022ed40a58ff14d74edc7723910f12c7a1703b9361c72f15a08039300358623d325f66467edc2fec4031b66d027a88fff261588b17a8 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. Package: libpelorus-cuda12-6 Architecture: amd64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 74342 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/libpelorus-cuda12-6_0.0.9-1_amd64.deb Size: 11540100 MD5sum: 2745cd754c4a0bd37e917afcf09ecf30 SHA1: f5ae896665691c8df28c3464707f2b1d42d4b604 SHA256: 6e858f29a3158c466856add081657176958c796c1c4c00110c526415759211ac SHA512: 5edf2e9ae2123af6cac99f2545a55ad3ebc0203b6ab92fb5339d0cbe02e530a3c751e93fcc7ab99691078c38722ae40062aa932d0a7e6964a5ff2ba2c37e22ec 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: amd64 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_amd64.deb Size: 8908 MD5sum: 47c8db0e9b45224badf615ba153967eb SHA1: 20654e962360dadb1a7c439c75d7a6a30c5a7c2f SHA256: c679cf8f404b1834514ef1347391edac8dc170ff6b4e152c0473857817f63eb9 SHA512: 777ce090e730f918c980cbf4e96c7318e91cce575d533eb14acf136f0e021eac2c5a23d64fb3feb3cc1ac53af2e663a2fb6c0ce94b70686d0365e3d956204535 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. Package: libpelorus-cuda12-8 Architecture: amd64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 74342 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/libpelorus-cuda12-8_0.0.9-1_amd64.deb Size: 11539888 MD5sum: 40d3d1c65d2f1cd62055cc39c93c51d7 SHA1: 5b6ab5987bd940e7bdb91d587cad51dcd0ee1d70 SHA256: 9c884ab9edb4f2c4a4e9d4ca6ae008aa61888eae27f3e13ef0d5538fe9f88da3 SHA512: 147bfc0813c79f7b8afc8466ae63a9a4063f840dc29586adcce5e9c50df993c86d672c9f25f0f8c57a52b61554f26033611660be28a77f751ae2f224b85f3cb2 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: amd64 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_amd64.deb Size: 8908 MD5sum: 00b9583c4ecd8e1476d42d894f370762 SHA1: a00c4310aa06055e6d5ab79774d41ac7dac0bb86 SHA256: 6c18702e78086c13c0e7cba1875318e16db89661113dc81d960078d3d009fb52 SHA512: 4327af24182f7af7327208a0ad542dee47fb2e01514d692e02be61c2875267856e561ca43f9eb19102c28e30af43b8f9ca0195cdddd6f136e5c0958a723092e7 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. Package: libpelorus-cuda13-1 Architecture: amd64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 74342 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/libpelorus-cuda13-1_0.0.9-1_amd64.deb Size: 11539308 MD5sum: 8cf8bccf7f66afdd642d84c5ed524d9e SHA1: bbe5d17991255e518f68bebfda83810573eba5de SHA256: 7e2e5a8206f70de211cfd4ae47391addcf887e946edfd3f57d6af59289038f58 SHA512: 8a7c982ee540ec55377d6fd95255a15dc44590cfee29f309c2ac6ab866f4e42929609ad0dae55d53ddb01a6d63ca873ad4802e3bca06bfcca0a736a4ff42cff3 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: amd64 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_amd64.deb Size: 8892 MD5sum: a114d1b195d3b2804d4bd698cb1fc518 SHA1: ac85b34141b87fee832f82ec889254d06cd988ec SHA256: c0947c306edba71f8a9df9db46f6f9218e7cc201bbb9a2d3931189f31c24eb55 SHA512: 1ba0b36ecfdf40cdcf3c8dacd6a97460107971a74fd8e8bdb9d695325bccf1e107feda0279f8e39f68d779c8975fcea2e141561d80470066de10697c6a142338 Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. Package: libpelorus-vulkan-dev Architecture: amd64 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_amd64.deb Size: 8904 MD5sum: 8ae3d979d2a12bd819c993bebc1c04e9 SHA1: 18819f55627d9b0e2ac764e36b2715834a942dc6 SHA256: 36687783fc44e4896dac965e65996a9ea3ea9721437d700683228ea4236539e6 SHA512: 33c1c4a1b4b24c6427ff083742681c4e54c11f2b5b83e123ee4d146c02dceaee32e4cb6be7d83150acc1f38ba1b6171bc081d67b18cb8c289554f639a2e24fcf Homepage: https://codeberg.org/stelzo/pelorus Description: Pelorus Odometry as a C library. Package: libpelorus-vulkan Architecture: amd64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 107741 Depends: libvulkan1 Filename: pool/main/jammy/libpelorus-vulkan_0.0.9-1_amd64.deb Size: 16927204 MD5sum: a33c86ee621f9829008da6f017f66cc9 SHA1: 0f99f6c5171cc6a7d931e060dcc2cdf58109f0ca SHA256: 4d6a8caaa99079bd784b41cff3a2184f0f2cb501d2c78d237e872acf74c6a87d SHA512: 8be2871db9f082b9df350dabe3a1b5d7d4891e25b9d47a1b1501ae1092dfc17e1d661549f8d89908c080e102d66d18a4019ae196c11e17feff3a541ff95f4826 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: amd64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 74342 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/libpelorus_0.0.9-1_amd64.deb Size: 11540064 MD5sum: a119fd5f6a622bc8f4f4f7f8b0121eba SHA1: 54909a1dffa5e2c35b80c82d9fccf48d5931fbe0 SHA256: c1d947b6ee27d500b950d78f12d91e8b7920e0c2b0f3aa0d448f7830d83705bf SHA512: f1644ea69c5741fc2abfdc4e3e29c49e0ad9d9905dafff592ae4b3560a6b907ea5f0eaabb463d90f8b2ce9908211cef8750971e48ecc60f9eaaf63af0c5111e9 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: amd64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 207 Depends: libpelorus-cuda12-6 ( = 0.0.9-1 ) Filename: pool/main/jammy/libpelorus_glim_odometry-cuda12-6_0.0.9-1_amd64.deb Size: 64008 MD5sum: 4e02a0d39e615f438c1dcd48b1e2636a SHA1: 9f7b21115cb5d9fbaf6f48984412f829958b2ecd SHA256: ffa0f02f12c26ccf859b8ca9c9c0b99873f73ef6355d87144cf363ac1d2ff256 SHA512: e79881d8b508cd6dd6c92a3e0b7f8f0f27f674509605def0afec33f42ae711735c3348518d5e8141950e39b6f469de75176dbdfe099eaa25cd9fb629d335bdfd 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: amd64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 207 Depends: libpelorus-cuda12-8 ( = 0.0.9-1 ) Filename: pool/main/jammy/libpelorus_glim_odometry-cuda12-8_0.0.9-1_amd64.deb Size: 63988 MD5sum: 77e8503b8c709d0d679d6ae6fd73f19e SHA1: 8194b720642ef6ccb4a323704f3988a6e4228e01 SHA256: 5a381da46a63d24685b6de4033c4707ef687a7a8ab9b9a009baba03796070a2d SHA512: 272de7df3d3276c9254dca0706d408b0de61be5a73fa9f9eca3913c481f4fcca33b3cb3be0a14fbc5586ebb0a7272fd0483f1c813228e2c614e5df567709bb46 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: amd64 Version: 0.0.7-1 Priority: optional Section: libs Maintainer: Christopher Sieh Installed-Size: 2233 Depends: libpelorus-cuda13-1 ( = 0.0.7-1 ) Filename: pool/main/jammy/libpelorus_glim_odometry-cuda13-1_0.0.7-1_amd64.deb Size: 273132 MD5sum: faa8b5f4a866325c2b917a08011ad4d2 SHA1: c25cbc0a8f15f12259ce12f179557925b1634476 SHA256: 2531cf71cbcd38b57d2e3c63cdb19f84a7078709af9ac43cd3a07fbde5587dcb SHA512: 53a3a127d828bc983fb54d0cea90cfba2fbfe5c6a329aa4ea1603695bd459ee97ee4f44a47b5ce49498e88112d26b23472da38039145696ea0da7414f379ef08 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: amd64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 207 Depends: libpelorus-vulkan ( = 0.0.9-1 ) Filename: pool/main/jammy/libpelorus_glim_odometry-vulkan_0.0.9-1_amd64.deb Size: 63956 MD5sum: 0e98ab84d423c7d03403371f17eb2167 SHA1: 85a290d7c1ed62a90aa5c85a8c9b4732a2ede46e SHA256: 4c1ed7a8c0ba8f1bb8888006fdea9dec1e37761ea546d10a1a4974e1f892c07c SHA512: be40e7d692849f596cc2b9a1e930d676f24b6f53ddc85707bfc1099a0f1f5f9b45d7e8392cb0b4a4a24708a6e31f2ceeeb5202e9c805873a3cbd4dc59677e856 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: amd64 Version: 0.0.9-1 Priority: optional Section: libs Installed-Size: 207 Depends: libpelorus ( = 0.0.9-1 ) Filename: pool/main/jammy/libpelorus_glim_odometry_0.0.9-1_amd64.deb Size: 63944 MD5sum: 69dfef62121791c9bde713615a37d7b1 SHA1: 0db05a4e2577104a57ef793a1d40b7016b5e5e51 SHA256: 94435354e2511ea3d026cfbd1f38d5f5c36c6af99d3a8ca75414906a1571342a SHA512: 9941badf9af5e939295959f2f0ebd17333973d99384444ddb1765859f7bc5423c0d932b131e30b9406eebc04f322a844f3363c6901aa8eda5082ad9cd728707d 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: amd64 Version: 0.14.1-1 Priority: optional Installed-Size: 37231 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/librat-dev_0.14.1-1_amd64.deb Size: 7476672 MD5sum: a08f39a58ffd64db53bf279f43bd70ed SHA1: cf32ec7126656aa284ac80e38ec34186256b0a0a SHA256: aedbe260997bf951615539af3dc2a7a63ca15dccb06dc958a92bf48d567f40c5 SHA512: 8e50bbb6954a9277f1b7ac5e709f636828249cf203e9d179d41b5b7a8a5f95592928fadb45b559473918480d066359676e172e41a203b6ee890e5272fd16177c 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: amd64 Version: 0.5.4-1 Priority: optional Section: science Installed-Size: 20846 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/marina_0.5.4-1_amd64.deb Size: 5621632 MD5sum: babdf6622a49541f0dc1bdf11724176e SHA1: 906b998fd88085107036fe6f7576f882d024f370 SHA256: 0c901719dd0e6594dcee2d66d0a8e008934810703430bc67ebf3272b5a2ce521 SHA512: bac9a97fbd45b0e30f89ba130b8894a9b8201f2193bc3f0cc17fc618fba9146737a96e7f27b59de13eac1a19b5c05b336e6bbf9dcedfbe63e834513e82fc6400 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: amd64 Version: 0.14.1-1 Priority: optional Section: science Installed-Size: 22285 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/minot_0.14.1-1_amd64.deb Size: 7214176 MD5sum: 474b49482c5630a66864f49c6623a66a SHA1: 44d8fe915c2176cd0c04a11bdf16e1858eca517c SHA256: a04b81d461fbdaad1f944f1d4d1f730fb1e71d8baf29d3f09ef1c32c0980b7c3 SHA512: f13230e41d2f6d268e2fa1a16783cbb7ccb420be730601cb3a2be1b2ec24ee5df02c82af896846a135058081d2b940e796d492bb91fe3eb8c0e79a294b66fab1 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: amd64 Version: 0.0.9-1 Priority: optional Section: science Installed-Size: 46484 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/jammy/pelorus-cuda12-6_0.0.9-1_amd64.deb Size: 10778996 MD5sum: e50f8b5d6d38cf909dd0bfcad80df78d SHA1: 501d93040539292627a858abebc61ec97027394c SHA256: e8e037fd89015feda3b56d829805b023308ec8c5bacac0ec00614fc0b2095ddc SHA512: b9a5d76d80afaff4bf734c68831eafd6fb4c6d9babbead6fcf695241b2508614eb331fb3c6cc894477aba4a65f5d03a8fbe95c9f551378f3fdc1229f06266fdf Homepage: https://codeberg.org/stelzo/pelorus Description: Resource-aware Lidar-Inertial Odometry. Package: pelorus-cuda12-8 Architecture: amd64 Version: 0.0.9-1 Priority: optional Section: science Installed-Size: 47237 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/jammy/pelorus-cuda12-8_0.0.9-1_amd64.deb Size: 10986656 MD5sum: 18736e6f5b6300100eeb356a5d7bc731 SHA1: 10ef74e2f0e2660e26583c8dc5bc2ec971b547d2 SHA256: 24476d27f8508572083f52523bf6bec1ffb7d9d6932be5f6e913f826d34d089d SHA512: 789e6b637174957318f11b09f66f20fc7aecd54256792c33ca98dc458117a12dc8643175af7b90fd332444076f067fdb44f4ba08caf5f2c1676920671bdff704 Homepage: https://codeberg.org/stelzo/pelorus Description: Resource-aware Lidar-Inertial Odometry. Package: pelorus-cuda13-1 Architecture: amd64 Version: 0.0.9-1 Priority: optional Section: science Installed-Size: 43898 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/jammy/pelorus-cuda13-1_0.0.9-1_amd64.deb Size: 11645424 MD5sum: 9b90dbf071c9ccd023ea93afe543acf0 SHA1: 00fb7c9df7b90106fc053a592b06fa7e877d12af SHA256: c58d01d04dbdfcbaf2142c9860d4dac74e366c9210b45f85adb42e906a3bf9b5 SHA512: 1cf453cb2d2dc522b37188ac7aee4ab9a8301f99e1af282bf763579c63c379bfdb129b5aeaab07787b00e499ecbb7997cf20695ca37175e13519e50ed83714f0 Homepage: https://codeberg.org/stelzo/pelorus Description: Resource-aware Lidar-Inertial Odometry. Package: pelorus-vulkan Architecture: amd64 Version: 0.0.9-1 Priority: optional Section: science Installed-Size: 46288 Depends: libvulkan1, minot (<< 0.12.0~), minot (>= 0.11.0) Filename: pool/main/jammy/pelorus-vulkan_0.0.9-1_amd64.deb Size: 11315504 MD5sum: 1bcd1205286a6d3a8e516aef3262efc6 SHA1: 6352b75353dde1ea02158c17550d1ae3a8680599 SHA256: 10a1d7b48cc596a7a3c6b87e7e1e1a214ab627b92c791fc08dc62138d4019edc SHA512: 92589a0474f51bbc5975bd1ed86293ec1ca6cdf3759e8e5ccb04cb1cc5c5ddb9d0ec88cebd2b48e08a2b7ff04091269831033453b078bebe37dbc27932266f02 Homepage: https://codeberg.org/stelzo/pelorus Description: Resource-aware Lidar-Inertial Odometry. Package: pelorus Architecture: amd64 Version: 0.0.9-1 Priority: optional Section: science Installed-Size: 39851 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/jammy/pelorus_0.0.9-1_amd64.deb Size: 9478132 MD5sum: dabb739db467ee0892e767f95b734174 SHA1: 379f24ed0a205baaa136f9913b5781fe107fde5d SHA256: c88e8e7bf6850e7230831d9745a5cbe8a66b62afbb366351a335d71d44496e42 SHA512: 813dde3a82d8a1d06d575598c336d110b02699cfbcb57f04f2a6d4d1e308734577ec8db7382751bd092b1b3e576a404b7b359ebe3bce340d8774eaf8b405972f Homepage: https://codeberg.org/stelzo/pelorus Description: Resource-aware Lidar-Inertial Odometry. Package: ratslang Architecture: amd64 Version: 0.5.0-1 Priority: optional Section: devel Installed-Size: 10911 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/ratslang_0.5.0-1_amd64.deb Size: 3079104 MD5sum: 99365ffb3c0f8b47c3b839e9d06283e1 SHA1: 5186df7d2d7df9461649e9332b30c5e8d8f19786 SHA256: c843092fb61735c594ae471cf4c0554a54b40cb880c222dec1c956d010e6ea68 SHA512: e9877975b11f4b90ffb91d29e30541e3404e9ae3213d23b45a41296c2b7f0d7c8b0f263b2d435a5e3b648df05f54b0e5dc2bc341fc24b633ec1dd37328839fac 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: amd64 Version: 0.5.4-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 43270 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_amd64.deb Size: 12892354 MD5sum: e6ab589b28fc4ac329b5bac1b61c0108 SHA1: 64a3aa762fb2628aa7aea1aaaec6f5ec56f72e05 SHA256: 2f086686b0c04752c9e6a09bd56aaaf87c5e385f034d097dc2fbd3b4bf73682e SHA512: 78b772b3148d53c2cd54f5aeda70922f9618b5e9db7e17ed56b62d95f10dbe0b9d028f4f6683688770b68d3a0e2f51ce8d3d3ac682e83f061dd00f1ba7261af5 Description: A dataset manager for robotics to organize, share, and discover datasets and metadata across storage backends. Package: ros-humble-minot Architecture: amd64 Version: 0.14.1-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 28407 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_amd64.deb Size: 8068886 MD5sum: bb5f2feb189b072bbd06e4b03bff631c SHA1: 2fd71b7e1881de461964105fea912d9a05bbe972 SHA256: 88d7b19d92a0db5968df9d71b6563b991fd801d6db7188f691f4b9ad944e7538 SHA512: 597366946a7aff9b34604ac794f28d36db14ea33d3a9ea415a89937b49f1b1d3939dd3e36699de493b958616b0e0f2eb9921b5513296e2a236af766b94194d19 Description: A versatile toolset for debugging and verifying stateful robot perception software. Package: ros-humble-pelorus-cuda12-6 Architecture: amd64 Version: 0.0.9-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 66097 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_amd64.deb Size: 17239624 MD5sum: 07ddf247a3818447a934b8ee1df9dd59 SHA1: cc5c5e151d48154043e4d27258d4efdfd4673c95 SHA256: f05eafa2e7b92bcf26b77e1baa050ef27e1df5d89bb6a2503afea773ab6d6f11 SHA512: 2496a771b3ceb469197842c9adc79667ebf4a86929166c63ce5df40d79804959fb69c1d9081cd0e5beae70e608c84ee5b46e7ab25b04b7e0cefeb3fdc11b83ff Description: Pelorus ROS2 Package: ros-humble-pelorus-cuda12-8 Architecture: amd64 Version: 0.0.9-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 67603 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_amd64.deb Size: 17690270 MD5sum: 934cc571be69a59c1bc1d0c3ec0d7728 SHA1: 3087d92e385250670c9906bcf9365ac68125c3dd SHA256: 855c518ccef6b6f9ded7dd3023b72f4be90b32110a58e676c7ccaca4806793c1 SHA512: 96f217199b0fbcbddfddf80d3bff1d5a91e4e34265afe685412fdb753487998bb2b7d1a6e55968fb2ead924701d8156bc3274a52c089993f161f8813a76edf53 Description: Pelorus ROS2 Package: ros-humble-pelorus-cuda13-1 Architecture: amd64 Version: 0.0.9-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 60927 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_amd64.deb Size: 18778436 MD5sum: ecfb004a9c5850f52db6c0da00071510 SHA1: b3da36402d7b0d3452f1442d702345ca3f499e60 SHA256: d61ebce98abda529ef4c65e02fe0e0d0c83cf3463d605d55c2a2eb5d9313a6b9 SHA512: 91710a2650b7b7c59b303afb512b60886d79469e7c7cbe09d46639553492ced084977c6b5781b14658279034850969ea7a7db656291e4a2488b46a4fcd572219 Description: Pelorus ROS2 Package: ros-humble-pelorus-vulkan Architecture: amd64 Version: 0.0.9-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 65691 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_amd64.deb Size: 18443854 MD5sum: 1f05e0848f7418af55acfd9b31ab351a SHA1: d34d4cc95272cdf3ee351e10a0b77c4b69ede61b SHA256: c8674b559e3d3b5a6994bcb7d65a9828a0b2c279e53e80fe76dd449217d56780 SHA512: 4b295eecc3a02f829c9784e0bcecfecccf0c3c1be7cf644126e5cf1735400ee3e4c5834013af2b37badc65dee1f2d1b11588412b2960e31e48087f34858ef4ea Description: Pelorus ROS2 Package: ros-humble-pelorus Architecture: amd64 Version: 0.0.9-0jammy Priority: optional Section: misc Maintainer: stelzo Installed-Size: 52747 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_amd64.deb Size: 14424038 MD5sum: bea40def7d2ea9f66940e1f691e97809 SHA1: 4158307fcc080d8d818ab4b63fc1cd62a01959ae SHA256: 07c78dde08b009c422e667f6c0ab0f7746e3f282bebb5f7413c4b5beab41521c SHA512: 2c87c8f3fd9d87fd4a94658f67998afd76af91d4dc41b3fa648952533883441e53bdcc9760dbef9c198f9ff0dedfa224286dd13cd8263c27b1de3691ac2d2fe7 Description: Pelorus ROS2 Package: sounding Architecture: amd64 Version: 0.4.1-1 Priority: optional Section: science Maintainer: stelzo Installed-Size: 1843 Depends: libc6 (>= 2.34) Filename: pool/main/jammy/sounding_0.4.1-1_amd64.deb Size: 644672 MD5sum: 610b592d68a99dbd499d8fd9c8e4531e SHA1: 3cf1e29c97ac7f60e84b1fde280150457935ae33 SHA256: 675b845a4c278c79c37881b11b926c93a5b918410f85a36989e6f88f64a0bf20 SHA512: 23e4e02ae2030d93ba5b6bec6deb77c89a8a97c4672fe01f27e645d157395e6906d74219341ae7eb9daf76ff3ae9a32514fd88c51efa7aa033b80406d181d228 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 ```