Package: dedrunk Architecture: arm64 Version: 0.1.1-1 Priority: optional Section: science Maintainer: stelzo Installed-Size: 15316 Depends: libc6 (>= 2.39) Filename: pool/main/noble/dedrunk_0.1.1-1_arm64.deb Size: 4688052 MD5sum: b40966b75ce94d3f86bdfd9ad5c1fdf1 SHA1: 0603625d69880a77ba194d7c10eaf73b1d67fc51 SHA256: b9ce71d651128dc1abd8a83309c8416a31cbf0985864480f1202ad37aeb732d1 SHA512: 8e4bd0141e54fb448aee9a5f966ed5177d48963991457a1be05cdfb3d06e7ce811a5a3dcdc58e225366db194b7d7816747bbc58d87225727bdb158d6b6f75f21 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/noble/libpelorus-cuda12-6-dev_0.0.9-1_arm64.deb Size: 8872 MD5sum: 0e27e71af58115e8d25f2d1dc7da6943 SHA1: fe0174491edcc43821810f97b7ece3391cdcbcd7 SHA256: 36c162f5902e53c3aa62fb973558442e4b82611cb2c0a3125af655a5f8e755e3 SHA512: 7bf46cfb9becfc4c49041a869c71db830450b16c0754e8e09437a4881b4d81eb89b4880a5b771dc3ce98a38189b4fbcf0b9a871cde2300ae8d9be3e2333766d3 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: 66999 Depends: libc6 (>= 2.39) Filename: pool/main/noble/libpelorus-cuda12-6_0.0.9-1_arm64.deb Size: 10380792 MD5sum: ba568fbcd11bb5282dbc0014ad082909 SHA1: 67b15b14a5c532e2e8fef0492f49f6f8eb98b665 SHA256: 26985acf26209e88be9afb6aff97e493db63c2c4af3a7c3b32efbf1aeeb3a39b SHA512: a1caa0dc5d7f50906f7d2a71997e4ef7b77f324f50d3da82f972fbb15a360fe93081a194b9c15c81d57e862f33bc3844cbb1112e167eb81e3049ef9407b2aadf 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/noble/libpelorus-cuda12-8-dev_0.0.9-1_arm64.deb Size: 8872 MD5sum: 887e85bea6b95f3daef902531f3428f7 SHA1: 882bfe1f649cff8662bb956379a06e2687911ed1 SHA256: 3686c1688c6480c98fb23e90f44838c378f03a40792edbf7645c7257a3c8b7d8 SHA512: caa6fbcb7f2860624599bdb206c59530864f706abf31e8a37edc7b6c3b02e733565f5f067801608dc97b0fe9c8b6550be61565c7988e6b9a064550ce485c9acd 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: 66999 Depends: libc6 (>= 2.39) Filename: pool/main/noble/libpelorus-cuda12-8_0.0.9-1_arm64.deb Size: 10380704 MD5sum: 6cc2f74785c8d52b23adfcd15bb5184d SHA1: 279bc56842f7de592d187af71c8c725370815591 SHA256: 2fc63572cbc2e32d4d6b25bf90ac2c0891c24286ca09b8f86c1ed53262c98fb5 SHA512: 5ef247a05e43ff5d2684ffbcfb1e0c159be964eb8e156b89796d7647bf3b74b98a2c339f7cb11850dbec346b0eb3435c752253320f9beab5af2cea8157b1dcb9 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/noble/libpelorus-cuda13-1-dev_0.0.9-1_arm64.deb Size: 8872 MD5sum: 616a8f78ee19dccbdfbcb7edce27ffae SHA1: 0a41e3dc25939fa782e7dd385e9696424894b259 SHA256: ca354f86f7b2e554dd23e3c1f730547d3dd9b78f305ea2fe92435172076a3f22 SHA512: ee12655e112f6cd52ab266e9b442a468be4c1eb7d6dcbc2ed704e4fe5900404a1e0ed364972eeae8bc4d536e0b51826f6d0c9876ef319e89826620188de5b302 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: 66999 Depends: libc6 (>= 2.39) Filename: pool/main/noble/libpelorus-cuda13-1_0.0.9-1_arm64.deb Size: 10380512 MD5sum: 1c3e8c22df99e1155212420e3839b8a0 SHA1: 6c4d9ce9e996a5eede4795bf7b7cd1c000696046 SHA256: 3c4c1923cd1f0bfdee60a17e7120d0bc60e601c706f1850245890a7bfd003017 SHA512: 7dd437a22ec7ef699ce06a0af459b61d8d00065629b0a1f7ff6952158037567af25ae39c5eecf668c75edf3c5c35418c8bf7413499907a1d4fe0573266d417aa 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/noble/libpelorus-dev_0.0.9-1_arm64.deb Size: 8856 MD5sum: b941f815f95272d46d12e21b09cfcc5c SHA1: 0b9209aa4c60cb06b89231dd72addffcbf3c4719 SHA256: c148c6706d5b51a0136bb6400cceb6a4afc1a51bec831956ee2f3040ba8b3c7e SHA512: 1a54515785b6076b755f9db7fbfe9389282e5e908012c93a4518ed876db4e85c2be1ac852a9e2213e759259edffedb040a90b4096f3c3c38307cb6223d42b381 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/noble/libpelorus-vulkan-dev_0.0.9-1_arm64.deb Size: 8868 MD5sum: c4f925b24aa711bc163db5dded446bf8 SHA1: e7c5989bc955f176a4c3634765dafefcf07d2c26 SHA256: c578a421d2489ebb3677aef7ba6ea3f97c2d1029fdb4bfa1301c3ae0197fb8e7 SHA512: b0241fcae1623d32a1bf3cedf529eae3cd4c9fdd827e97e1266c55f212b33b75d196c6ec5e7fda9604116328f6ccbb7419de9c2edfa5419822218349b619f22a 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: 99963 Depends: libvulkan1 Filename: pool/main/noble/libpelorus-vulkan_0.0.9-1_arm64.deb Size: 15398576 MD5sum: 97932df9fa3c27ff3f53a0e8c6c851e3 SHA1: fc1f3f10d61c8e9eacbc3aea4c554392a43ff397 SHA256: 577713b0f9c38d92a0737594cd72494742cd14d0b8714e53ef76588f0715be24 SHA512: d0ffbfc14b3677bee805d001b1d841152490c5ee8c1440c1e2df885ac14f9116f9b7d4aa9957c17d1ce54f087577d26a8d1c5d198ce549cef4e6e91dcae7b68e 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: 66999 Depends: libc6 (>= 2.39) Filename: pool/main/noble/libpelorus_0.0.9-1_arm64.deb Size: 10380736 MD5sum: b747b9c1fc6e175990541af58f284583 SHA1: b3b85ca5d83b2cd90cd2b259f91389594ee2efd6 SHA256: 9961b3d493a0d13ad64d6068687c7474f91721fa55131b9486cc54cd6414b934 SHA512: 165ae7a9e389af4794d9846e500e25098ee744ce521ee0af496d65259f638c6e50e2f4346d3d8d2e2fe19d17e7159bca5f72fd614c53cde1512893ea5160996e 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: 238 Depends: libpelorus-cuda12-6 ( = 0.0.9-1 ) Filename: pool/main/noble/libpelorus_glim_odometry-cuda12-6_0.0.9-1_arm64.deb Size: 68168 MD5sum: 75404d2cf9a9b427788988d4231b8ba0 SHA1: afce91a7b1e2fbc86131f7b308b0c02d8a20b975 SHA256: 0a0913eb60be91e27c3384d765c285c890c590a960fc1c3f363947145510c89f SHA512: 77b4958b08e35bbfe2e0edc0f2588da16d01bdb87e7939208eaa40947b723a78aaeffd30fab323a4e67daca9368fd8f6c903089ee57d0de5a054a7c6fdf644fb 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: 238 Depends: libpelorus-cuda12-8 ( = 0.0.9-1 ) Filename: pool/main/noble/libpelorus_glim_odometry-cuda12-8_0.0.9-1_arm64.deb Size: 68192 MD5sum: d8be75d8971c477c44331d4d33efdff5 SHA1: b04fec923b455df2da361bd56a1c5abe5b586b33 SHA256: bbfd9eef65bdb26e19094c170613c926656ee59ff0163e5d61a8933869351646 SHA512: fa182df794405e70e12e718259105f8747bb959ebe3ea3530f5fae58f98ce4544477157d69612e6713277841d52500d89cc9df5688379ff4891ab4319ab3d4f5 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: 2305 Depends: libpelorus-cuda13-1 ( = 0.0.7-1 ) Filename: pool/main/noble/libpelorus_glim_odometry-cuda13-1_0.0.7-1_arm64.deb Size: 274216 MD5sum: cce3dcd7008c3156f5a160d108800764 SHA1: 72b7f890850dd7e5ba7bb270d2593c8cd51c8c37 SHA256: 816e33c8130c805fe186687e1bbc14358feed676ccdc1384ec98d1b6e6b9b807 SHA512: b8023ad51d67b998c72ce141bbd0f6c69c5956215bc6357a61443c2e76325d2655eac6fcf320719239edf0a0f39b10b09aac332854508ed66d51873fe22d1f12 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: 238 Depends: libpelorus-vulkan ( = 0.0.9-1 ) Filename: pool/main/noble/libpelorus_glim_odometry-vulkan_0.0.9-1_arm64.deb Size: 68048 MD5sum: b8c4bfe3491ef01b6198b69aeee36c7f SHA1: d6d6c7a39f485d660652ecf8fbf07a62c816dce4 SHA256: 626773fb667a03fe7cd1051baa381da9e0c05fc137dd30a203269a0d0237edb3 SHA512: 480e851e6c5f9dd915da4121aa8421abbe99697f24dfc472021ab52a464a696e9c9531d9c746a4722a805d7b1578018c9459c613110f0f0c34a4ee412c8a0fae 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: 238 Depends: libpelorus ( = 0.0.9-1 ) Filename: pool/main/noble/libpelorus_glim_odometry_0.0.9-1_arm64.deb Size: 68072 MD5sum: e8439f94bd78b2f4a4d77d8578cd718e SHA1: cd2fb9b389303f1ba8a4098404723552a553c928 SHA256: cf504530527120c18877196dbe76075af4d89bb9cfaa4baeacc0c06847286292 SHA512: 8544346eaf70b303938cd8de63823f7ac6f9dea6358945e0f918cf53a0f08e6b8ecef6ffcfc3f7920c64a12d681d48d5d2c4b3d5167b4d98b9cee493c1fe95aa 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: 36617 Depends: libc6:arm64 (>= 2.39) Filename: pool/main/noble/librat-dev_0.14.1-1_arm64.deb Size: 6836176 MD5sum: f206447d0f1927ff6f8b2ec94361c1a0 SHA1: 7ddf9273b55ec664d8e458b91a26ebdbb6d72c86 SHA256: 7f955822caea34eacf13695d7c8be72049ab84f233256b33d6c903bfa328f409 SHA512: 7f73521fe5e48cc7d44de484acbf8d94f455876421ca274a80bfcd669c7cc1a9b6bf2f769ccae80a4ea5fb6162ca002dd6ed599cd9c627973a57909cc698b2e4 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: 18746 Depends: libc6 (>= 2.39) Filename: pool/main/noble/marina_0.5.4-1_arm64.deb Size: 4948732 MD5sum: 65171db7375bed7f755e54db8e6bbb07 SHA1: c3e5efd303bdbaec5b7246adeaa7b023a4905ac2 SHA256: 0affc88d8590346ebdd790966c0b2c6aa273dd000193a774ccb50e81afd2807b SHA512: 5a1ece62e27bb6e0a46dab565b0ae34f0f5b34d27b91d039ded703402fee6b2e7d87bda5abbb5c2ad0ad439782b802b42b0723c5805e6a640db2e2d8988845b9 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: 20345 Depends: libc6:arm64 (>= 2.39) Filename: pool/main/noble/minot_0.14.1-1_arm64.deb Size: 6383728 MD5sum: fd25797cf0987c474bbca3cfaced9cf7 SHA1: ac64b3bc0c5cfcb94417e4a9d36581e8dc72663c SHA256: d2c9fde79f943973465958f11722890ed3060c583574aba6de2352b9c246fe07 SHA512: f49a4434bb75e4fa963b5997d5eca1bf20f3e21acb30d1ce11aeae74a0a4fdfb7a9cff7af53a5ec5bcac28c728f4202e8c27e2439c455ec1b2fb4fb1aa629339 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: 40373 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/noble/pelorus-cuda12-6_0.0.9-1_arm64.deb Size: 9343284 MD5sum: adf63ada9c7ff9f47f9c580ba716c94b SHA1: 54705f4f32c37b55b13443fd6b8f2b583cbedf9a SHA256: bc80274557ea0fd74002e58c88739e5fe7d0c72e240745511bae95b338fbe0fa SHA512: c4d51a78b68d85335755fd0e522339aee2f0f14037bf131a68ac1fa8acd7960f61ccee22a679d475022104efe68854cc9202ec82ccdc37537951b0bf29a28b1b 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: 41077 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/noble/pelorus-cuda12-8_0.0.9-1_arm64.deb Size: 9556132 MD5sum: dd23828b35039722df55a781999a270a SHA1: 3ed6318f681b205c338adf278a64ce381d2adb86 SHA256: 3bd0af86eca32b445c1fa354f62ae81ee978a5cef9da88939161c2e4e099aba3 SHA512: 17081f8e2341bbbd9efc6cf719b92b7c822e2617727c72094f2b31a1eb2ada6e5547a5712443ea35b22f11a69a4a9931e1652487039fdb3d4a12cc4fa1c00a9c 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: 37813 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/noble/pelorus-cuda13-1_0.0.9-1_arm64.deb Size: 10194564 MD5sum: e509241fcb819d15b45320b092d0dad2 SHA1: 57dea6a7615abebe40106a15fbadd6f54896f44c SHA256: 000de5ebb316fd453d86c47bdfb9d9c51ba1cb821e8ce612bbd48a60d07b501b SHA512: 274c029de904497ed060e0f139845fb6dfa99fd077b78035adfdac38d709c6f07f8ba429676fa0af5495c3a6a1664f4d266ce762b07a2c30c21993187b331bdd 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: 39872 Depends: libvulkan1, minot (<< 0.12.0~), minot (>= 0.11.0) Filename: pool/main/noble/pelorus-vulkan_0.0.9-1_arm64.deb Size: 9775480 MD5sum: 79cb7ea15e1150853d92bca8159e7409 SHA1: 11ba13f1b72bbb07916dcdc342be1b3fe3cde991 SHA256: 2ca0f118263a9a18aa42fe62fb2f6ee85747e1d2084956690feb98b01f2ba6a6 SHA512: 8313a6f472880c92d19398051a09d644c11ba1790c1a44d83867bdc38de354d5fe57becbf2093037a59e1479690df50b2dd9bc57fa4f12f0f550b6971a9180ff 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: 33844 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/noble/pelorus_0.0.9-1_arm64.deb Size: 8058720 MD5sum: 97bfa9204baa032ee86f132ebe202034 SHA1: 0ccee6c65e1cfd4674cb478441bd975ea39eaa8b SHA256: e55a3f36c37e503078f6e0a2759ea7e4b082a02b75c7f8b4d2a444f0f5dcd3a4 SHA512: 4798e7246154834a3eb7cf386f3cc2e72c4b901288f4a59a57f0b018cabc66e25ca12acf004494b15ef4ed43f3fea8ec7547f739435153cee2982cd65e478f46 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/noble/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-jazzy-marina Architecture: arm64 Version: 0.5.4-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 39974 Depends: libc6 (>= 2.39), libgcc-s1 (>= 4.2), libclang-dev, ros-jazzy-ros2bag, ros-jazzy-ros2cli Filename: pool/main/noble/ros-jazzy-marina_0.5.4-0noble_arm64.deb Size: 12614364 MD5sum: bd07e5cb38eab0cf7fa4b21db9900dd5 SHA1: 138974128c9ba4a6266f2da4b0cc178fe187120b SHA256: aa36e24436b9af852ae7e9f06451905e5cbfa47db1c8823f1dc97147ce0d06ca SHA512: c461d83565f285adbe751ee09f96969680493df359413103d888e7ea463cdb26c8a603a6b19a1e1ca1ef973c46810b43d3519fa2d3189883100841974c5c7c92 Description: A dataset manager for robotics to organize, share, and discover datasets and metadata across storage backends. Package: ros-jazzy-minot Architecture: arm64 Version: 0.14.1-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 25420 Depends: libc6 (>= 2.39), libgcc-s1 (>= 4.2), ros-jazzy-builtin-interfaces, ros-jazzy-geometry-msgs, ros-jazzy-nav-msgs, ros-jazzy-rcl, ros-jazzy-rcl-action, ros-jazzy-rosgraph-msgs, ros-jazzy-sensor-msgs, ros-jazzy-std-msgs, ros-jazzy-tf2-msgs Filename: pool/main/noble/ros-jazzy-minot_0.14.1-0noble_arm64.deb Size: 7422044 MD5sum: c219b2b591e2bd0fca27b91fd05f26d2 SHA1: 9155c3b6be21c14e174bb315be2c72fe2b4219ef SHA256: f712550686dac1632e6b5a4287ad5ab52f82f41cb159d75f656e0a786e4c03cc SHA512: 4484953379db49dd562c0d08fe31ed3a4918c83311901f7852cc94f0c5a5ed0247f5676a54cbd8072223111d17a634e61ebab8fd8e11d6b5b5d08762580fff01 Description: A versatile toolset for debugging and verifying stateful robot perception software. Package: ros-jazzy-pelorus-cuda12-6 Architecture: arm64 Version: 0.0.9-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 56321 Depends: ros-jazzy-launch, ros-jazzy-launch-ros, ros-jazzy-nav-msgs, ros-jazzy-rcl, ros-jazzy-rviz2, ros-jazzy-sensor-msgs, ros-jazzy-tf2-msgs, ros-jazzy-visualization-msgs Filename: pool/main/noble/ros-jazzy-pelorus-cuda12-6_0.0.9-0noble_arm64.deb Size: 15792884 MD5sum: 267d6d15620b8cd9edf728333a7f2c0b SHA1: 97f236c25190b7e330b8dc612a9b7678fe316552 SHA256: 7bc5d7ee704410fe555c421115494d4051132e14a510be979257bbaf5f25ce60 SHA512: fce973f1745d4f1ea7021f84b1acc0db3c2d9f4b685f7977fc33c5b685bf6da6e4b0d06d1a0f8e7807e6cab774b32d79a79d2b99222cd85bd850f7a32dc99488 Description: Pelorus ROS2 Package: ros-jazzy-pelorus-cuda12-8 Architecture: arm64 Version: 0.0.9-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 57857 Depends: ros-jazzy-launch, ros-jazzy-launch-ros, ros-jazzy-nav-msgs, ros-jazzy-rcl, ros-jazzy-rviz2, ros-jazzy-sensor-msgs, ros-jazzy-tf2-msgs, ros-jazzy-visualization-msgs Filename: pool/main/noble/ros-jazzy-pelorus-cuda12-8_0.0.9-0noble_arm64.deb Size: 16251714 MD5sum: d4adc5bb8f2432a0d777f3006c90855a SHA1: ca0bf836b775d25d1cb4ed647bb4059f65a43d0b SHA256: 16bc4f45e0938ceeaa2ec2d9cdc55c2f0e7273e8fecccd93c094a79b3555c865 SHA512: ff0755725695d169985ee271b7ee056156c884745a264a67dbf1b2e898e5be2805c30fae1963789c5d8a7c213970f9ea04ebbada244c5bcaffb4ba5e6dd12de9 Description: Pelorus ROS2 Package: ros-jazzy-pelorus-cuda13-1 Architecture: arm64 Version: 0.0.9-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 51201 Depends: ros-jazzy-launch, ros-jazzy-launch-ros, ros-jazzy-nav-msgs, ros-jazzy-rcl, ros-jazzy-rviz2, ros-jazzy-sensor-msgs, ros-jazzy-tf2-msgs, ros-jazzy-visualization-msgs Filename: pool/main/noble/ros-jazzy-pelorus-cuda13-1_0.0.9-0noble_arm64.deb Size: 17144678 MD5sum: 8d5d6d2aae15ef7eecae0786a11d40b9 SHA1: cf20297c7258d37e38ae538fbd0f91cb6744db3c SHA256: 93eb7916bf22a6e72e5893843b0ba9738ed18aa6bbe19a6d523c5764afe85ef2 SHA512: f9740b384e810dbe679b55b0df018635899cd03b04ea509d9689181c9a2987a31b1710b84610667ea4965f27542a95ef309a60dd9c5c97694611e48799c40291 Description: Pelorus ROS2 Package: ros-jazzy-pelorus-vulkan Architecture: arm64 Version: 0.0.9-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 55573 Depends: libc6 (>= 2.39), libgcc-s1 (>= 4.2), libstdc++6 (>= 11), libvulkan1 (>= 1.2.131.2), ros-jazzy-launch, ros-jazzy-launch-ros, ros-jazzy-nav-msgs, ros-jazzy-rcl, ros-jazzy-rviz2, ros-jazzy-sensor-msgs, ros-jazzy-tf2-msgs, ros-jazzy-visualization-msgs Filename: pool/main/noble/ros-jazzy-pelorus-vulkan_0.0.9-0noble_arm64.deb Size: 17016900 MD5sum: dbb9398ceaaa784ad6c9e79670d77923 SHA1: 4bed5e80a3fd8e0c97ebc0381f8f292cd92fd81a SHA256: e7d181a5ae4b1b1b213a9cc96b33bc6ec384934b2b5fed8097de3be16fa8b76c SHA512: 517363483c42fa862713c7ee7e3df8c9e71a30f2164d74b7235d6c99eae35d2933a8af60992a8bc7d20e36ddb3752c0b2e4b0293e719433205dfbd21d1086def Description: Pelorus ROS2 Package: ros-jazzy-pelorus Architecture: arm64 Version: 0.0.9-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 43261 Depends: libc6 (>= 2.39), libgcc-s1 (>= 4.2), ros-jazzy-launch, ros-jazzy-launch-ros, ros-jazzy-nav-msgs, ros-jazzy-rcl, ros-jazzy-rviz2, ros-jazzy-sensor-msgs, ros-jazzy-tf2-msgs, ros-jazzy-visualization-msgs Filename: pool/main/noble/ros-jazzy-pelorus_0.0.9-0noble_arm64.deb Size: 12951404 MD5sum: e5c41ba8a6e1f9ba1c36ebffc1e514f6 SHA1: 120d968476030d3325142adb9291dc7857a4d9d0 SHA256: 341a00a628392a3dc8a9d3bc1fe8a21565bf3bfe8f43a4d17f6a2e6aa48e00dc SHA512: 98febb60219890809503daf5cf0c412dfe3a9bffe8afe1d27ba4f25f40e9e4cfbdd124c7b27dc203c083ceab5c4fc127c65f9b971991581a27ca40751ff20538 Description: Pelorus ROS2 Package: sounding Architecture: arm64 Version: 0.4.1-1 Priority: optional Section: science Maintainer: stelzo Installed-Size: 1692 Depends: libc6 (>= 2.39) Filename: pool/main/noble/sounding_0.4.1-1_arm64.deb Size: 560812 MD5sum: d2dbb774bfb3f898af23ab8a52c7dcd5 SHA1: 7992fdd582f3d6e0ea65d6a78a8d4e2eed887cd1 SHA256: 25bf2f29aa939b307a138d4a6e63dcb1f2826018f775bce15a39a29bc274bc48 SHA512: 5eb807a4549a37a6fe90d0eb15c1c7c2a7dbe6e485fe671e8351282363f3f2105baeff752871ec730e36ba90144c04f03275b6b3723c3220bbb35158c86e48f2 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 ```