Package: dedrunk Architecture: amd64 Version: 0.1.1-1 Priority: optional Section: science Maintainer: stelzo Installed-Size: 18190 Depends: libc6 (>= 2.39) Filename: pool/main/noble/dedrunk_0.1.1-1_amd64.deb Size: 5384000 MD5sum: b4bb4c49798505da181e9595e6f568bc SHA1: 797ab19743e02b9aaa3b04cb06ffbe50075a4f0b SHA256: 0703b4c3e928f77f32e7ad0739db968272a8a1873deca3839189a910c011a124 SHA512: dec5f3e4d5888db448a1fa129a678b787c1e67b887407d056f1396d222f99bea92a3e80d2ed9b2bb64706013132d2dc0fa372465f8c7ad6573bfe67b70c2b778 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/noble/libpelorus-cuda12-6-dev_0.0.9-1_amd64.deb Size: 8872 MD5sum: ed2d0b1617264588f4904731f673ad52 SHA1: 491de6d062ce3e8326fd4400a28f393807bb11ee SHA256: 19d4a10f65cf271e7d691bf981daf34ca0ddd596effe8ca0593ee5aca803c51f SHA512: 00414fe068f5b7bf6bd0ede5b59e0434a0cc3bb134f3da633d4ac210c023685507fa4e3d65837d1eb45fa9d3377a057ddc64fa65a1fc2ac7b31d274b6a8af258 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: 74599 Depends: libc6 (>= 2.39) Filename: pool/main/noble/libpelorus-cuda12-6_0.0.9-1_amd64.deb Size: 11595752 MD5sum: 6d4d6b287bd798fea8169daff56a26b8 SHA1: a92540f22f9de94cf12636934a88655d4dbab65f SHA256: ad4c410290ce39982d0f1b6f35afc3b0816f1f6443ffdb6a5a5296783335e68d SHA512: 431b898b9b46faffd6663da1ea579e5c592695265063b13b545a2a097ad5cad7e4902eb3251986bef20dbfb9f78c7f534c88053361b5a3c21527b279bc093c26 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/noble/libpelorus-cuda12-8-dev_0.0.9-1_amd64.deb Size: 8872 MD5sum: 241d2744e9ff537c3d4e2252a6746683 SHA1: c40ec0ec7352c0c99927ce4f45211b56f4b83d55 SHA256: 3cc4ec3879fb3608626f3c0772766efa0c9a91b8f5e54cd85a57d9b2ee1d904d SHA512: a0914f9697fbc81e084bd75a224cb7034f1ef0181451f66fe059aa6807fd75e0d9384ac1a2823dbb22c7ac0c538899a30c3595b8a13351158e0b85f021c8d696 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: 74599 Depends: libc6 (>= 2.39) Filename: pool/main/noble/libpelorus-cuda12-8_0.0.9-1_amd64.deb Size: 11595412 MD5sum: f5b0e208632ba616c0d068dcac555b07 SHA1: bcbda1a8d1497f0a6ab7242397052d5c3373dc96 SHA256: c237aa0b1ecefe0c2f318b943837863f8e590807fcdcaa7b992be27a661fb889 SHA512: 02eec0536fc0d5fd89a0abdf523bdf3de4dff6a43e7cfee221c541a1606fa4fb6d5a31fe81b1c689d8538c60cf589fc264b4f65017a2bca73246760a9a072efd 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/noble/libpelorus-cuda13-1-dev_0.0.9-1_amd64.deb Size: 8872 MD5sum: 37f2a5677f69a68ad64a360f29ff883d SHA1: d7e3658dc19c87942f99eff8225bcee9e8348788 SHA256: a251e491f0f556b3e0a7bf9adc3252db8df3cbe498ac54b2dc67216477795d52 SHA512: f50d43a8205705dd05c20b64637346980906d95b7df37f4197164ab400db0239c73b1032defef3c9dd8dc7e837939602da2576223352d540afde802b4e9d9fdf 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: 74599 Depends: libc6 (>= 2.39) Filename: pool/main/noble/libpelorus-cuda13-1_0.0.9-1_amd64.deb Size: 11595636 MD5sum: 7c25442978ad1a2f4db6ef80027de47d SHA1: 292581e0ac74d8d4a4cffa9b884b3e76e6f558f2 SHA256: c9633dfce3d77178928f3d07ec3b88a48c285197e4a3a0c77cb8a1c9fde8f67d SHA512: 2f47ecb4a658111f616687bf85f35e5091dc7e3ee427beb13f76fe3f34e2de310999dbf8bdf8a23cad043c55b5847e497ebb84b6aa7f0b08da5dbd6cef18ec60 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/noble/libpelorus-dev_0.0.9-1_amd64.deb Size: 8856 MD5sum: 60fa11b3bfc0e8b395d3bfc3f56040e6 SHA1: 44dd84de5ba2ecdc4fe9a9398698f9ee0d3aeab3 SHA256: 4ef7da5080f30939f302edf04f0ee0a21fdf0b877aa48215b0f775508c8eddd0 SHA512: fb0f551e58a7d429f59d39204ed00ddf43d84a70acc32ffca8bc738133e7db80ead95f412e9ab4aeb5a828607f1ddead956a1391540209cea04ca107fe54ae85 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/noble/libpelorus-vulkan-dev_0.0.9-1_amd64.deb Size: 8868 MD5sum: a17fde41e9bec1c398ca8fd884aa0da3 SHA1: 2b808cbba5f36f93c2bab903f1ccfa322e018d0f SHA256: 486d962a14581db9e4058084de32909483496b5c9fabeca1abcf4a0027927172 SHA512: 46d31a4b3ed77142302f12a372e1479f68dedeaedf953b62cf17faea62ef1fbaa977033e5977a97f5d1e0f13560d86f6fc0703d9de778287337778c2782435ef 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: 107860 Depends: libvulkan1 Filename: pool/main/noble/libpelorus-vulkan_0.0.9-1_amd64.deb Size: 17064060 MD5sum: aadb6737052f9e8211a70b0c83caa219 SHA1: dfe02021d812556b81c2cf12cab5fe9c762340c3 SHA256: a03dbcf0c397fc90280dd53dfa5571e3caecfb77a1e32156a1bbe24c2314a312 SHA512: 631931fab35637832faad97cec8333e00079b988ae0db7d85f7217da721496c96658e0b4d57b0be6116dc9755a68a4956ccdf70fe7a432c70587a76164adb5d9 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: 74599 Depends: libc6 (>= 2.39) Filename: pool/main/noble/libpelorus_0.0.9-1_amd64.deb Size: 11595488 MD5sum: 1e7404b6002d54de506aad2c0fb839c0 SHA1: abc4dea4cd137ae56d2c5240ec6d16eaaefe944b SHA256: a53c679b8cc16034a7d0b1cc1cb1cde69d18de7825f3b3e33e9e7c67c328a26c SHA512: 2cf676ca03e01ce9e843ba4acbb8c8d950fe725668502d7c761154d29a0ca7b8b0b26088b523252d931084b5cb27dd34ca43118a4fe70b6d412da66ec91ece8a 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: 236 Depends: libpelorus-cuda12-6 ( = 0.0.9-1 ) Filename: pool/main/noble/libpelorus_glim_odometry-cuda12-6_0.0.9-1_amd64.deb Size: 76648 MD5sum: c3573d490bef7131b91b547c8249cc45 SHA1: 68287217df7851118f2970abbb5f45a02dd6c860 SHA256: a448dd973519bd95c1c5887c4467dc3f9d011b669e2178fd3144c84076de468c SHA512: 9cedbbf2d7a9d10f3b0c545d64a86306d21b43da5af81a73e9ed78a00e7d80adad033c4fb8cc973fea7ba971b1cb706391a7e3577d696f57ea6b7da1df48dfa8 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: 236 Depends: libpelorus-cuda12-8 ( = 0.0.9-1 ) Filename: pool/main/noble/libpelorus_glim_odometry-cuda12-8_0.0.9-1_amd64.deb Size: 76648 MD5sum: 8d0212d5c1a5e61c3b6fac4b27176d91 SHA1: 29070cfd176e4fcb231e4f1ed7525660235570c8 SHA256: d1a6bc89d83db91959fbfb650822d0349f9654259ad780816d527d8603f1bc3b SHA512: 8d24eb01aa51e4e3d382d4a7fadd5334dd1484e13269da0a50a8a956569ab3c0edd0bc41cb1ccc6fa4f4ea33df1fdda07e024723b7731f42604135ed93421a8a 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: 2264 Depends: libpelorus-cuda13-1 ( = 0.0.7-1 ) Filename: pool/main/noble/libpelorus_glim_odometry-cuda13-1_0.0.7-1_amd64.deb Size: 283784 MD5sum: 8a5a51f84003dc729a8023f32f401c92 SHA1: c54014fc5d691e44e699489b08b5866b9c61872c SHA256: e94f738c14180801903449a23c96b1909470c7d225c677a179ee2fb6359c7f2f SHA512: b7a379b8573ee697b7b07e4cdc67ba1e67f40e2f0316c5e5b465ac9473f642a9ea6aab09730d17d2d1dd8843d18809056ecf649445a621c68f3de572306fbd51 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: 236 Depends: libpelorus-vulkan ( = 0.0.9-1 ) Filename: pool/main/noble/libpelorus_glim_odometry-vulkan_0.0.9-1_amd64.deb Size: 76548 MD5sum: 67c888a93b9c7c6d4c349747a8a06d5c SHA1: afc8ac1f1d5dc8cd72bbfc92ed0f1f4e06e64264 SHA256: 1cf6068fce878741c511ca0c4bb1c7c0f1a3d560a96b6e75b47758282cbaeb30 SHA512: 087cd703a1d4b32879e11c3736ca906aad98c1f1c8ee0575ead9f6b8aa1c3845306d437bf3d3378c851361a1c331d088313f6a3d86bb76404957306885405ba4 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: 236 Depends: libpelorus ( = 0.0.9-1 ) Filename: pool/main/noble/libpelorus_glim_odometry_0.0.9-1_amd64.deb Size: 76492 MD5sum: bc1f7da1521dfb7204cc6c8163ed693a SHA1: 00f2171c8a0f2a87b1a05c24778235398783e0db SHA256: 958dcc9c6952e49c9012b646a9a7b19501af7f6d82c93eec2c865ea566c48b02 SHA512: 1db09893cad10655f37ca5b766211161515527e6f7db4e1e77e04d2a68a570232415cc6a373634b9aa058b4c81f13098f593756b604eec3d12535f2f780544b7 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: 37338 Depends: libc6 (>= 2.34) Filename: pool/main/noble/librat-dev_0.14.1-1_amd64.deb Size: 7470120 MD5sum: b6dbdbe8d98bee668013e34cbae8b0c6 SHA1: 4c8e3334c6995c690058a7c369e36704d2691826 SHA256: 5fa6927581552c165d053c815cfa982ed07006d23d560aeed9a7cba946f3211f SHA512: c6e9f198d70714b9c2c8181207cd60cb45d59996739113e3407d55a27862e7da7fe3817a7ac9d0031ea1201ea83b175f291f8cb230afde2b4c0c4b42209d90f4 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: lvr2 Architecture: amd64 Version: 25.2.0 Priority: optional Section: devel Maintainer: jubraun@uos.de Installed-Size: 50399 Depends: libboost-all-dev, libflann-dev, libgsl-dev, libeigen3-dev, libopenmpi-dev, openmpi-bin, ocl-icd-opencl-dev, freeglut3-dev, libhdf5-dev, liblz4-dev, libopencv-dev, libyaml-cpp-dev, libcgal-dev, libgdal-dev, libboost-filesystem1.83.0 (>= 1.83.0), libboost-iostreams1.83.0 (>= 1.83.0), libboost-program-options1.83.0 (>= 1.83.0), libc6 (>= 2.38), libgcc-s1 (>= 4.0), libgdal34t64 (>= 3.4.0), libglu1-mesa | libglu1, libgomp1 (>= 6), libgsl27 (>= 2.7.1), libgslcblas0 (>= 2.7.1), libhdf5-103-1t64, liblz4-1 (>= 0.0~r130), libopencv-core406t64 (>= 4.6.0+dfsg), libopencv-features2d406t64 (>= 4.6.0+dfsg), libopencv-imgcodecs406t64 (>= 4.6.0+dfsg), libopencv-imgproc406t64 (>= 4.6.0+dfsg), libopengl0, libstdc++6 (>= 13.1), libyaml-cpp0.8 (>= 0.7.0), ocl-icd-libopencl1 | libopencl-1.1-1 | libopencl1, ocl-icd-libopencl1 | libopencl1 Filename: pool/main/noble/lvr2_25.2.0_amd64.deb Size: 10078658 MD5sum: 77253666146de5f1f0f643f140113638 SHA1: df4984d9900a9a17ba60e1394a29273a41948854 SHA256: d2ead883196aa00fed7afebe4501afd62d3c261dde2fb2e0324ffa0b7cbd5957 SHA512: 88eb03e472ef4a88e165286c9b344d9ec99e989bb59bd6e9a1f3acf9abaf7b2cba36863a4b4d4da2a03c4856ad40bd26184199464823ae69019c9c11fd7bafc3 Description: lvr2 built using CMake Package: marina Architecture: amd64 Version: 0.5.4-1 Priority: optional Section: science Installed-Size: 20859 Depends: libc6 (>= 2.39) Filename: pool/main/noble/marina_0.5.4-1_amd64.deb Size: 5627784 MD5sum: b73a6b6f915586d55e4e1d21bce79069 SHA1: 86cc3f58e3dc12d96144a0c2146fd9fb40435679 SHA256: 971e4e088c18af8c004d9624f009b797318d2ac45ee45f5cdd36a752b7ce80d3 SHA512: 23edfcdbd8143192069558daa5b6bbb44a6872950c427cc76632857ed41197b01ac1c593b1a7bd1abdf5c6c1bd1dc3a2a25d39f0424f3eaac9e54e88262c329a 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: 22298 Depends: libc6 (>= 2.39) Filename: pool/main/noble/minot_0.14.1-1_amd64.deb Size: 7223184 MD5sum: 23463e8ecb208950e76cc3c960e3884f SHA1: e66aad428e595b4b72cae951b86d65e955f7671a SHA256: e7227f8213d1c440c2fcb96d9f0b956f8e121699afb4876da4fc957364e817c6 SHA512: e574f6e07a2de28d231de5e660911ead3e5ad74db8cf4eb0b301de391f2439da8c800046b8610bc000f051a172561f8c6d14ee0959d62ffa7212d018dacd4e57 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: 46511 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/noble/pelorus-cuda12-6_0.0.9-1_amd64.deb Size: 10798156 MD5sum: b83c9b446a2dc0716de9fc2b1b7ac6f9 SHA1: 2e12263bfca18c383ece72803d5b467c6e350fa4 SHA256: 6d8694584621a74eff98a02c04341e6053267512154cfe327ece5b444ce25d88 SHA512: 2eeae7dfd5a374d33f1161f3429ae8cda500543481cbc798379cb113734b1583a4b023167058504cb0feeffed912378580344edef173c4610632e60d8e29f8f4 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: 47257 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/noble/pelorus-cuda12-8_0.0.9-1_amd64.deb Size: 11008508 MD5sum: b271dd309bac50818e777eb4b1575f86 SHA1: 43fdfc766a7213d6af5fe17433fc16e5d22f9f10 SHA256: 99a08989375d5d8bff5db957e378a242ee86c757f20685d7af829f73beb1bfd6 SHA512: 213248e99ad6983fe2fbbb70f10f5be5dfa7b1f072400c6764b23fb6cececddba5db91bf52de403996a758774aba87f1072407dca0ba1363adc20ae3bba486ea 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: 43934 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/noble/pelorus-cuda13-1_0.0.9-1_amd64.deb Size: 11662028 MD5sum: 6d421475448673b117c0688161877947 SHA1: 0f76baf3d852e704d24e2bef7df857fef77a2ee7 SHA256: 94a31bec65ebf8d7b633bb11471d52a498d5c39726c65532554cca7ddd9f6e3f SHA512: 26cc7f78c22faf2e4e0a923d0495079304b94b0e9b3acafbfe788d15916ed920d6bf95d5da672e084b9efb254a35bf5e2afd0e4160c7bfbd953a48372446b277 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: 46416 Depends: libvulkan1, minot (<< 0.12.0~), minot (>= 0.11.0) Filename: pool/main/noble/pelorus-vulkan_0.0.9-1_amd64.deb Size: 11392696 MD5sum: 69f04bea1f07bc479fe895a126130444 SHA1: 3d2ebc208267fdce7a78069e1958523c863dacb1 SHA256: dc9b3e0901850473f572a93a52ca3debb4339024a7ff81eac21da4a137e04469 SHA512: cfc43eabf7abe68e01ea17950e4690d9a2fa198c7487e861cc0f7644f638e7965f0ba9a76d5a67da39e9b5b637a645d742f4694564a086ad2913fe75346d9196 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: 39884 Depends: dedrunk, marina, minot (<< 0.15.0~), minot (>= 0.14.0) Filename: pool/main/noble/pelorus_0.0.9-1_amd64.deb Size: 9492904 MD5sum: dd12f57d24f8389ed02acf483c38e9dc SHA1: eff4b135654835c3ec6723cb826dec58f1f0a798 SHA256: d8bf3490effd06674665e9cc9e9db248a16019f13d8c934f936ecf6a0068f53c SHA512: 95900b799b1184628aa26cc0c0529fd98ecd982e8bfffffc3e12e528b32d2ae7a6ed323cac16f58ccc8e55a193e26d78a6606ef5682d796bf2a47e855927b895 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/noble/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: rmagine-core Architecture: amd64 Version: 2.3.2 Priority: optional Section: devel Maintainer: Alexander Mock Installed-Size: 1911 Depends: libeigen3-dev, libassimp-dev Filename: pool/main/noble/rmagine-core_2.3.2_amd64.deb Size: 201940 MD5sum: dc6c09f2622a63be47e24954a8a4cd3d SHA1: 70d0532a5de315afcf937875efe2f0f38e29e79e SHA256: e15b7bde389ab2dfd38d41d723826191326abb27c27a635b839260037bcd1dc5 SHA512: 5c41d31ac6ca5577f525a59240410175d0899dc4ca045c59298833ff5eb35754992f33c686413dcd414104d04ad00aa467c2c34a7694104fefb6a35454014464 Description: Rmagine - 3D Range Sensor Simulation in Polygonal Maps via Ray Tracing for Embedded Hardware on Mobile Robots Package: rmagine-cuda Architecture: amd64 Version: 2.3.2 Priority: optional Section: devel Maintainer: Alexander Mock Installed-Size: 14693 Depends: rmagine-core Filename: pool/main/noble/rmagine-cuda_2.3.2_amd64.deb Size: 3037978 MD5sum: 79230c0b851f0e8587d6550e2a5db541 SHA1: 97b9dc175a6c4bcd250af57c76d2eda085203f25 SHA256: fc368d462afd4e57f2cbf5f2349dc7a77e27545b7818dc00fd4eb4e83298d830 SHA512: 661ef454404961ba15b8f84a2a1d39504b3266e92307a89b164c7d48b93c9da2b5d8ec338c4689b9be689d8357906f8e875e2c90d9d2d07b910c418709f451df Description: Rmagine - 3D Range Sensor Simulation in Polygonal Maps via Ray Tracing for Embedded Hardware on Mobile Robots Package: rmagine-embree Architecture: amd64 Version: 2.3.2 Priority: optional Section: devel Maintainer: Alexander Mock Installed-Size: 763 Depends: rmagine-core Filename: pool/main/noble/rmagine-embree_2.3.2_amd64.deb Size: 90604 MD5sum: 057e475142354d24c8268f32ecafe1f5 SHA1: 223803a0771a3687d5644f81a2b01b7562736888 SHA256: d5c0086e614c76b28288ab728357f1e991a2228c5504cabc96554051f215379a SHA512: 74dc13c4efd7f6f2dc4e10ab4b8191a70ccfbd6f65704f27106e72a3b7566dde79a978b51e72aba8982c85943fe0775700d63cf41f6a3e8a453cd3977c0d4669 Description: Rmagine - 3D Range Sensor Simulation in Polygonal Maps via Ray Tracing for Embedded Hardware on Mobile Robots Package: rmagine-optix Architecture: amd64 Version: 2.3.2 Priority: optional Section: devel Maintainer: Alexander Mock Installed-Size: 1654 Depends: rmagine-cuda Filename: pool/main/noble/rmagine-optix_2.3.2_amd64.deb Size: 164838 MD5sum: a3f4472870dfe3b2d020ee4afee26d8f SHA1: d355bfa7d32e1693ef0bea169ecd46e6d293c38b SHA256: 0d394ca5d93ae825ea4d5f3a7b775ecc9775f95a5e19f3ffc97d65c61949e5cc SHA512: c86a447081d53dc54dbab9bb67fa1be90953a1e5658d5e67a11b9ef0960a2135c1881294072d9d98ca1dd537b7c75a713fd7eec8041ce833ed9a82256e575bba Description: Rmagine - 3D Range Sensor Simulation in Polygonal Maps via Ray Tracing for Embedded Hardware on Mobile Robots Package: rmagine-ouster Architecture: amd64 Version: 2.3.2 Priority: optional Section: devel Maintainer: Alexander Mock Installed-Size: 125 Filename: pool/main/noble/rmagine-ouster_2.3.2_amd64.deb Size: 12114 MD5sum: e201a57132af1b5ce0cc8bb97c6c397b SHA1: e028c8c0aade074cf3eec681a0725f99fb1a5832 SHA256: 410048aeb2a074a47e925c99778e8bfe84ddfeab108d1b7b8207177e5825db25 SHA512: c22c1609b2451734ba75d041014f1d2a7523dbe68b032db3e6251191a0a24970b81f4dcd976a95e6484ce9c9571f63fc6f03efb4786effdf8c4ff2efdea32e3b Description: Rmagine - 3D Range Sensor Simulation in Polygonal Maps via Ray Tracing for Embedded Hardware on Mobile Robots Package: ros-jazzy-marina Architecture: amd64 Version: 0.5.4-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 43064 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_amd64.deb Size: 12858690 MD5sum: be92c69f28e53e747fd92b4312c2bd75 SHA1: b8945b24e252253ce53317ea36ab14eb45d07d51 SHA256: ffb9d85465894a7b2aa40e7cbe1c974344428cb5bf01a9cb31cbbfb4f9d5b6ab SHA512: 7cfd77e2d3d808f80aee52a0dbab86e578b2f1a258e3f6d711e479507eaa08622c3eacc08f82a4961a2f4f355455c39c5ad3962290c7378966ecb2457a4fa80d Description: A dataset manager for robotics to organize, share, and discover datasets and metadata across storage backends. Package: ros-jazzy-minot Architecture: amd64 Version: 0.14.1-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 28496 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_amd64.deb Size: 8067558 MD5sum: f0e61d1efeab08e271978be56a2d0aed SHA1: 80aa728d0757b9690eafb287e17d16e5c663f66e SHA256: da2d4e27892c7bd01514ab3afe31595368b4dd9be83c91e9d57249e832059207 SHA512: 34aac9348d73d3b63460c27454e36cc10c5f892def6e4dd14308a415abf4ed16b3e2c5521b04dfd3ec1fa90e1c5cf4021f64fe2a8df02a87b89b983c839e0f39 Description: A versatile toolset for debugging and verifying stateful robot perception software. Package: ros-jazzy-pelorus-cuda12-6 Architecture: amd64 Version: 0.0.9-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 66113 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_amd64.deb Size: 17214730 MD5sum: a217547b826a3b15a1d5bafac41a19b2 SHA1: 4ae28420ed62e0af1814717a745a4c888e2c5d34 SHA256: 1aa4dae1127180f480c163ac5f5c74595134b32d718ce89f2e903be8d9463cd1 SHA512: 13ec94e4c7e58ebf005dd20a6af0c956483c056540531f0e37aa505428e9c13bdbd938011faeb9ccc5d1725a70910667581551a440530586716488581e8983ab Description: Pelorus ROS2 Package: ros-jazzy-pelorus-cuda12-8 Architecture: amd64 Version: 0.0.9-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 67603 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_amd64.deb Size: 17646664 MD5sum: d25a59f170e3c522730c50f33bfcfbc9 SHA1: c4c8a5a568ca989b75bc94d3136de0397769534b SHA256: 96c4cb045768c7eb6f8c267f4919f3a4594b92aaa10bc0a30f1bdd4de5d114be SHA512: 9bb42dcb1f7214fad4f5652882c55e463a362936477ae464c75dc6778d83284030979f5a52c9aaf79e01f51d227e122afd1c3f612a864fe3438bfbbe2dd7e7aa Description: Pelorus ROS2 Package: ros-jazzy-pelorus-cuda13-1 Architecture: amd64 Version: 0.0.9-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 60959 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_amd64.deb Size: 18735064 MD5sum: 87ed4e1a0890a6f7b2b8736565181478 SHA1: 27afa7402a54292634359e6731dfa140ef47ff37 SHA256: 7f4089dd9d766dc274d613181d5042fd1923b8b3a69577c80d42ce657ae3a6b7 SHA512: 9abaccf271c0de5c809f7a8be96256220193b4507f4c1a34cd67bd1c01653bbe74e495e2fca25fbc4088bfe2b1302f2d09956fde63fee1d78fed93753691f1fd Description: Pelorus ROS2 Package: ros-jazzy-pelorus-vulkan Architecture: amd64 Version: 0.0.9-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 65951 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_amd64.deb Size: 18553710 MD5sum: c6db3212774d332fb75008b97c83a08a SHA1: ea8abaee1dc19db44701270abd507fe07e9e604d SHA256: 25ed3857043b1f9fb7c59b4e9341a68fd7bc53acc41f175e8f35412dd410798c SHA512: a3c63360ec9d682065d8a8b1c7d064230eb8e6ec23b68025bb04801afde3d6940b9ce9e88cccf0efd3d8ba88ade1486eeb0d7c4176dc8214dfdb406bfc5ff577 Description: Pelorus ROS2 Package: ros-jazzy-pelorus Architecture: amd64 Version: 0.0.9-0noble Priority: optional Section: misc Maintainer: stelzo Installed-Size: 52783 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_amd64.deb Size: 14398036 MD5sum: 523f0dd150f366b42ba95f8cbd61c74b SHA1: c60d7ca99ae81c5a5100ac07e533438a0198d688 SHA256: c8e87b2843bd9957fb239bbfa56fbe47af3ed07847fe6ba354cfb0a439a48d2e SHA512: c3a6f88f77cbc01f79bee34d3efbc937da83b47bb512df3d949156ea776d993ae76b15e12390f7b262a4a315da8bbd2f27bcf4f9b0e2610ef921ed3cce2bb5bb Description: Pelorus ROS2 Package: sounding Architecture: amd64 Version: 0.4.1-1 Priority: optional Section: science Maintainer: stelzo Installed-Size: 1844 Depends: libc6 (>= 2.39) Filename: pool/main/noble/sounding_0.4.1-1_amd64.deb Size: 644772 MD5sum: ef33d4c4bf2067a618560dacf7c46c8c SHA1: 28bf950cf79757f185f4be5b76a9f62880f1e7fc SHA256: e09449e7f723b51acb4e806b53a659f23da8ce7011615a353f3fd0dcd3b3fa33 SHA512: 4c53648f2be6aec2f0fe858ed6eee9c3386e0d3665bef2b8991741daf566bf82af1821640f3ec7cab9ee058bfa2fda03878723aa68c80ae43e2aee92c2577eb0 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 ```