fix lint

Updates the requirements on [r2r](https://github.com/sequenceplanner/r2r) to permit the latest version.
- [Commits](https://github.com/sequenceplanner/r2r/compare/0.8.4...0.9.0)

---
updated-dependencies:
- dependency-name: r2r
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.gitattributes

@@ -0,0 +1 @@
+rpcl2/tests/*.bash linguist-vendored

.github/workflows/crates.yml

@@ -1,22 +0,0 @@
-on:
-  release:
-    types: [created]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - name: Setup Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-
-      - name: Publish to crates.io
-        uses: actions-rs/cargo@v1
-        with:
-          command: publish
-          args: --token ${{ secrets.CRATES_IO_TOKEN }}

.github/workflows/nightly.yml

@@ -0,0 +1,34 @@
+name: Nightly testing
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+  schedule: [cron: "40 1 * * *"]
+
+permissions:
+  contents: read
+
+jobs:
+  ubuntu:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: clippy
+      - name: Linting
+        run: cargo clippy --all-targets --features derive,nalgebra,rayon,serde,ros2-interfaces-jazzy -- -D warnings
+      - name: Tests
+        run: cargo test --features derive,nalgebra,rayon,serde,ros2-interfaces-jazzy
+
+  # outdated:
+  #   name: Outdated
+  #   runs-on: ubuntu-latest
+  #   if: github.event_name != 'pull_request'
+  #   timeout-minutes: 45
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - uses: dtolnay/rust-toolchain@stable
+  #     - uses: dtolnay/install@cargo-outdated
+  #     - run: cargo outdated --exit-code 1

.github/workflows/no_std.yml

@@ -0,0 +1,24 @@
+name: Build no_std
+
+on:
+  push:
+    branches-ignore:
+      - rclrs
+  pull_request:
+    branches-ignore:
+      - rclrs
+  workflow_dispatch:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  ubuntu:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          target: thumbv7em-none-eabihf
+      - name: no_std build
+        run: cargo build --target thumbv7em-none-eabihf --manifest-path rpcl2/ensure_no_std/Cargo.toml

.github/workflows/r2r_galactic.yml

@@ -17,5 +17,5 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: docker build . --file ./tests/Dockerfile_r2r_galactic --tag r2r_galactic
+      - run: docker build . --file ./rpcl2/tests/Dockerfile_r2r_galactic --tag r2r_galactic
-      - run: docker run r2r_galactic cargo test --features r2r_msg,derive,nalgebra,rayon
+      - run: docker run r2r_galactic cargo test --features r2r_msg,derive,nalgebra,rayon,serde

.github/workflows/r2r_humble.yml

@@ -17,5 +17,5 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: docker build . --file ./tests/Dockerfile_r2r_humble --tag r2r_humble
+      - run: docker build . --file ./rpcl2/tests/Dockerfile_r2r_humble --tag r2r_humble
-      - run: docker run r2r_humble cargo test --features r2r_msg,derive,nalgebra,rayon
+      - run: docker run r2r_humble cargo test --features r2r_msg,derive,nalgebra,rayon,serde

.github/workflows/r2r_iron.yml

@@ -17,5 +17,5 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: docker build . --file ./tests/Dockerfile_r2r_iron --tag r2r_iron
+      - run: docker build . --file ./rpcl2/tests/Dockerfile_r2r_iron --tag r2r_iron
-      - run: docker run r2r_iron cargo test --features r2r_msg,derive,nalgebra,rayon
+      - run: docker run r2r_iron cargo test --features r2r_msg,derive,nalgebra,rayon,serde

.github/workflows/r2r_jazzy.yml

@@ -0,0 +1,21 @@
+name: r2r_jazzy
+
+on:
+  push:
+    branches-ignore:
+      - rclrs
+  pull_request:
+    branches-ignore:
+      - rclrs
+  workflow_dispatch:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  tests_jazzy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: docker build . --file ./rpcl2/tests/Dockerfile_r2r_jazzy --tag r2r_jazzy
+      - run: docker run r2r_jazzy cargo test --features r2r_msg,derive,nalgebra,rayon,serde

.github/workflows/rclrs_humble.yml

@@ -17,5 +17,5 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: docker build . --file ./tests/Dockerfile_rclrs_humble --tag rclrs_humble
+      - run: docker build . --file ./rpcl2/tests/Dockerfile_rclrs_humble --tag rclrs_humble
-      - run: docker run rclrs_humble cargo test --features derive,nalgebra,rayon
+      - run: docker run rclrs_humble cargo test --features derive,nalgebra,rayon,serde

.github/workflows/rclrs_iron.yml

@@ -17,5 +17,5 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: docker build . --file ./tests/Dockerfile_rclrs_iron --tag rclrs_iron
+      - run: docker build . --file ./rpcl2/tests/Dockerfile_rclrs_iron --tag rclrs_iron
-      - run: docker run rclrs_iron cargo test --features derive,nalgebra,rayon
+      - run: docker run rclrs_iron cargo test --features derive,nalgebra,rayon,serde

.github/workflows/rclrs_jazzy.yml

@@ -0,0 +1,21 @@
+name: rclrs_jazzy
+
+on:
+  push:
+    branches:
+      - rclrs
+  pull_request:
+    branches:
+      - rclrs
+  workflow_dispatch:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  tests_jazzy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: docker build . --file ./rpcl2/tests/Dockerfile_rclrs_jazzy --tag rclrs_jazzy
+      - run: docker run rclrs_jazzy cargo test --features derive,nalgebra,rayon,serde

.github/workflows/rosrust_noetic.yml

@@ -105,4 +105,4 @@ jobs:
       - name: test
         run: |
           source /opt/ros/$ROS_DISTRO/setup.bash
-          cargo test --features rosrust_msg,derive,nalgebra,rayon
+          cargo test --features rosrust_msg,derive,nalgebra,rayon,serde

.github/workflows/tests.yml

@@ -16,15 +16,13 @@ jobs:
   ubuntu:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
-      - name: Install latest Rust
+      - uses: dtolnay/rust-toolchain@stable
-        run: |
+        with:
-          curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh -s -- -y
+          components: clippy
-          rustc --version
-          cargo --version
       - name: Linting
-        run: cargo clippy --all-targets --features derive,nalgebra,rayon -- -D warnings
+        run: cargo clippy --all-targets --features derive,nalgebra,rayon,serde -- -D warnings
-      - name: Tests
+      - name: Build examples with features
-        run: cargo test --features derive,nalgebra,rayon
+        run: cargo build --examples --features derive,nalgebra,rayon,serde,ros2-interfaces-jazzy
-      - name: no_std Tests
+      - name: Test library
-        run: cargo test --no-default-features --features nalgebra
+        run: cargo test --features derive,nalgebra,rayon,serde

.gitignore

@@ -1,3 +1,3 @@
-Cargo.lock
+Cargo.lock*
 .idea/
 target/

CHANGELOG.md

@@ -0,0 +1,62 @@
+# Changelog
+
+## v0.5.0 -> v0.5.1
+
+- Fixes a bug, where the conversion of larger to smaller types results in a false buffer interpretation.
+
+## v0.5.0-rc.3 -> v0.5.0
+
+- `PointConvertible` trait is now `unsafe` since the offset is used for raw memory access, where safety can not be guaranteed by the compiler.
+- Fixes clippy on nightly.
+- Fixes a bug when attempting to write larger types than available in the message. This now results in a `ExhaustedSource` error.
+- Adds `repr(C)` to docs where custom conversions are explained to encourage best practices for raw type descriptions.
+
+## v0.5.0-rc.2 -> v0.5.0-rc.3
+
+- Bump r2r to 0.9.
+- Fixed building in `no_std` environments.
+- Removed `expect` calls.
+
+## v0.5.0-rc.1 -> v0.5.0-rc.2
+
+- `PointConvertible` now includes the information for `TypeLayout` and `Fields`, which reduces boilerplate code for custom points. The respective derive macro is updated to work with the updated trait.
+- `_vec` functions now work without the `derive` feature and thus are always available.
+- The `derive` feature now is disabled by default but it is still strongly recommended for custom points to avoid layout errors. This also makes procmacro dependencies optional for the functionality, since every conversion can be called without them.
+- The alignment of all predefined points is increased for SSE optimization and optimized copies between C++ PCL and Rust.
+
+## v0.4.0 -> v0.5.0-rc.1
+
+Most of the library is rewritten to be simpler and more expandable while adding mostly performance focused features to motivate the breaking changes.
+
+## Why?
+
+The previous concept of the `Convert` struct for both directions of conversion leads to use cases, where the behavior is unexpected for the user.
+
+## What changed?
+
+Nearly every public function is changed to be easier to work with and faster at runtime and adaptable for different scenarios.
+
+It is easier to update to the new version by looking at it as a new crate and starting with the documentation.
+
+### Breaking
+
+- Switched from FallibleIterator to Iterator, since all possible errors are checked before returning the type.
+- Renamed `pcl_utils` module to `points` to make the module more a general toolkit and less a PCL compatibility layer.
+- Renamed `ros_types` module to `ros` since types are inferred.
+- Removed `Convert` struct. The `PointCloud2Msg` now directly offers `try_from_iter` and `try_into_iter` functions.
+- Dimensions and PointMeta in `PointConvertible` are merged to types, that are mostly deducted to minimize the needed code (see the docs for a custom point example).
+- Conversions can not fail per point in `PointConvertible`, so TryFrom -> From.
+- RGB is now stored as a union to allow direct copy with `_vec` functions without packing it manually per point. There are setters and getters for safety and usability.
+- ros_types::TimeMsg (now ros::TimeMsg) uses `nanosec` instead of `nsec` naming to conform with ROS2. This also removes the type alias for `rosrust`. Instead, there is a `impl From<rosrust::Time> for TimeMsg` now.
+
+### Added features
+
+- `[from|into]_vec` enabled by derive for memory heavy applications (enabled by default).
+- `[from|into]_par_iter` enabled by rayon for processing heavy applications.
+- `derive` macros for minimizing code for custom point conversions (enabled by default).
+- `xyz()` getter enabled by nalgebra for all predefined points.
+- `prelude::*` re-export module for quickly importing common types in point cloud processing projects.
+- Lightweight: `no_std` compatibility for `iter` conversions and dependency-free builds when only needing `iter` conversions.
+- Overall speed up thanks to more vectorizable iterator conversions and the new `vec` and `par_iter` functions. See the [comparison with PCL](https://github.com/stelzo/ros_pcl_conv_bench) for more info.
+- More type deduction in public facing functions, leading to less code for the user of the library.
+- More documentation.

Cargo.toml

@@ -1,63 +1,5 @@
-[package]
+[workspace]
-name = "ros_pointcloud2"
-version = "0.5.0-rc.3"
-edition = "2021"
-authors = ["Christopher Sieh <stelzo@steado.de>"]
-description = "Customizable conversions for working with sensor_msgs/PointCloud2."
-repository = "https://github.com/stelzo/ros_pointcloud2"
-license = "MIT OR Apache-2.0"
-keywords = ["ros", "pointcloud2", "pointcloud", "message"]
-categories = [
-    "science::robotics",
-    "encoding",
-    "data-structures",
-    "api-bindings",
-]
-readme = "README.md"
-documentation = "https://docs.rs/ros_pointcloud2"
-homepage = "https://github.com/stelzo/ros_pointcloud2"
-exclude = [
-    "**/.github/**",
-    "**/tests/**",
-    "**/examples/**",
-    "**/benches/**",
-    "**/target/**",
-    "**/build/**",
-    "**/dist/**",
-    "**/docs/**",
-    "**/doc/**",
-]
-rust-version = "1.63"
 
-[dependencies]
+members = [ "derive-test","rpcl2", "rpcl2-derive"]
-rosrust_msg = { version = "0.1", optional = true }
-rosrust = { version = "0.9.11", optional = true }
-r2r = { version = "0.9", optional = true }
-rayon = { version = "1", optional = true }
-nalgebra = { version = "0.32", optional = true, default-features = false }
-rpcl2-derive = { version = "0.2", optional = true }
-memoffset = { version = "0.9", optional = true }
 
-sensor_msgs = { version = "*", optional = true }
+resolver = "2"
-std_msgs = { version = "*", optional = true }
-builtin_interfaces = { version = "*", optional = true }
-
-[dev-dependencies]
-rand = "0.8"
-criterion = { version = "0.5", features = ["html_reports"] }
-
-[features]
-rclrs_msg = ["dep:sensor_msgs", "dep:std_msgs", "dep:builtin_interfaces"]
-rosrust_msg = ["dep:rosrust_msg", "dep:rosrust"]
-r2r_msg = ["dep:r2r"]
-rayon = ["dep:rayon"]
-derive = ["dep:rpcl2-derive", "dep:memoffset"]
-nalgebra = ["dep:nalgebra"]
-std = ["nalgebra/std"]
-
-default = ["std", "rclrs_msg"]
-
-[package.metadata.docs.rs]
-features = ["derive", "nalgebra", "rayon"]
-default-target = "x86_64-unknown-linux-gnu"
-rustdoc-args = ["--cfg", "docsrs"]

LICENSE-APACHE

@@ -1,4 +1,4 @@
-i                                 Apache License
+                              Apache License
                         Version 2.0, January 2004
                      http://www.apache.org/licenses/
 
@@ -174,28 +174,3 @@ i                                 Apache License
    of your accepting any such warranty or additional liability.
 
 END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright {yyyy} {name of copyright owner}
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

LICENSE-MIT

@@ -1,21 +1,23 @@
-The MIT License (MIT)
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
 
-Copyright (c) 2024 Christopher Sieh
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-of this software and associated documentation files (the "Software"), to deal
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-in the Software without restriction, including without limitation the rights
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-copies of the Software, and to permit persons to whom the Software is
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-furnished to do so, subject to the following conditions:
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-The above copyright notice and this permission notice shall be included in all
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-copies or substantial portions of the Software.
+DEALINGS IN THE SOFTWARE.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.md

@@ -7,7 +7,7 @@
 
 ros_pointcloud2 uses its own type for the message `PointCloud2Msg` to keep the library framework agnostic. ROS1 and ROS2 are supported with feature flags.
 
-Get started with the example below, check out the other use cases in the `examples` folder or see the [Documentation](https://docs.rs/ros_pointcloud2/0.5.0-rc.3/) for a complete guide.
+Get started with the example below, check out the other use cases in the `examples` folder or see the [Documentation](https://docs.rs/ros_pointcloud2/0.5.2/) for a complete guide.
 
 ## Quickstart
 
@@ -49,9 +49,11 @@ There are currently 3 integrations for common ROS crates.
   - [![Tests](https://github.com/stelzo/ros_pointcloud2/actions/workflows/r2r_galactic.yml/badge.svg)](https://github.com/stelzo/ros_pointcloud2/actions/workflows/r2r_galactic.yml)
   - [![Tests](https://github.com/stelzo/ros_pointcloud2/actions/workflows/r2r_humble.yml/badge.svg)](https://github.com/stelzo/ros_pointcloud2/actions/workflows/r2r_humble.yml)
   - [![Tests](https://github.com/stelzo/ros_pointcloud2/actions/workflows/r2r_iron.yml/badge.svg)](https://github.com/stelzo/ros_pointcloud2/actions/workflows/r2r_iron.yml)
+  - [![Tests](https://github.com/stelzo/ros_pointcloud2/actions/workflows/r2r_jazzy.yml/badge.svg)](https://github.com/stelzo/ros_pointcloud2/actions/workflows/r2r_jazzy.yml)
 - [rclrs_msg](https://github.com/ros2-rust/ros2_rust)
   - [![Tests](https://github.com/stelzo/ros_pointcloud2/actions/workflows/rclrs_humble.yml/badge.svg)](https://github.com/stelzo/ros_pointcloud2/actions/workflows/rclrs_humble.yml)
   - [![Tests](https://github.com/stelzo/ros_pointcloud2/actions/workflows/rclrs_iron.yml/badge.svg)](https://github.com/stelzo/ros_pointcloud2/actions/workflows/rclrs_iron.yml)
+  - [![Tests](https://github.com/stelzo/ros_pointcloud2/actions/workflows/rclrs_jazzy.yml/badge.svg)](https://github.com/stelzo/ros_pointcloud2/actions/workflows/rclrs_jazzy.yml)
 
 You can use `rosrust` and `r2r` by enabling the respective feature:
 
@@ -68,7 +70,7 @@ Features do not work properly with `rcrls` because the messages are linked exter
 
 ```toml
 [dependencies]
-ros_pointcloud2 = { git = "https://github.com/stelzo/ros_pointcloud2", tag = "v0.5.0-rc.3_rclrs" }
+ros_pointcloud2 = { git = "https://github.com/stelzo/ros_pointcloud2", tag = "v0.5.2_rclrs" }
 ```
 
 Also, indicate the following dependencies to your linker inside the `package.xml` of your package.

derive-test/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "derive-test"
+version = "0.1.0"
+edition = "2021"
+readme = "../README.md"
+description = "Test package for the derive feature of ros_pointcloud2"
+repository = "https://github.com/stelzo/ros_pointcloud2"
+license = "MIT OR Apache-2.0"
+keywords = ["ros", "pointcloud2", "pointcloud", "message"]
+categories = [
+  "science::robotics",
+  "encoding",
+  "data-structures",
+  "api-bindings",
+]
+
+[dependencies]
+ros_pointcloud2 = { path = "../rpcl2", features = ["std", "derive"] }
+rpcl2-derive = { path = "../rpcl2-derive" }

derive-test/tests/derive_test.rs

@@ -0,0 +1,20 @@
+use ros_pointcloud2::PointConvertible;
+use rpcl2_derive::*;
+
+#[derive(Debug, PartialEq, Clone, Default, PointConvertible)]
+#[repr(C, align(4))]
+struct MyPointXYZI {
+    x: f32,
+    #[rpcl2(rename("test"))]
+    y: u16,
+    z: f32,
+    #[rpcl2(rename("i"))]
+    intensity: i32,
+    label: u8,
+}
+
+#[test]
+fn layout() {
+    let layout_str = format!("{:?}", MyPointXYZI::layout());
+    assert_eq!("LayoutDescription([Field { name: \"x\", ty: \"f32\", size: 4 }, Field { name: \"test\", ty: \"u16\", size: 2 }, Padding { size: 2 }, Field { name: \"z\", ty: \"f32\", size: 4 }, Field { name: \"i\", ty: \"i32\", size: 4 }, Field { name: \"label\", ty: \"u8\", size: 1 }, Padding { size: 3 }])", layout_str);
+}

package.xml

@@ -1,16 +0,0 @@
-<package format="3">
-  <name>ros_pointcloud2_tests</name>
-  <version>0.0.0</version>
-  <description>Dummy package for linking messages in crate tests.</description>
-  <maintainer email="user@todo.todo">user</maintainer>
-  <license>TODO: License declaration</license>
-
-  <depend>rclrs</depend>
-  <depend>sensor_msgs</depend>
-  <depend>std_msgs</depend>
-  <depend>builtin_interfaces</depend>
-
-  <export>
-    <build_type>ament_cargo</build_type>
-  </export>
-</package>

rpcl2-derive/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "rpcl2-derive"
+description = "Derive macros for ros_pointcloud2 crate."
+version = "0.4.0"
+edition = "2021"
+authors = ["Christopher Sieh <stelzo@steado.de>"]
+homepage = "https://github.com/stelzo/ros_pointcloud2"
+license = "MIT OR Apache-2.0"
+keywords = ["ros", "pointcloud2", "ros_pointcloud2"]
+categories = [
+    "science::robotics",
+    "encoding",
+    "data-structures",
+    "api-bindings",
+]
+repository = "https://github.com/stelzo/ros_pointcloud2"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "2.0"
+quote = "1.0"
+proc-macro2 = "1.0"

rpcl2-derive/README.md

@@ -0,0 +1,8 @@
+<p align="center">
+  <h3 align="center">ROS PointCloud2</h3>
+  <p align="center">Derive macros for the ros_pointcloud2 library.</p>
+  <p align="center"><a href="https://crates.io/crates/ros_pointcloud2"><img src="https://img.shields.io/crates/v/ros_pointcloud2.svg" alt=""></a> <a href="https://github.com/stelzo/ros_pointcloud2/tree/main/tests"><img src="https://github.com/stelzo/ros_pointcloud2/actions/workflows/tests.yml/badge.svg" alt=""></a>
+  </p>
+</p>
+
+This crate is within `ros_pointcloud2` to implement the `PointConvertible` trait for custom points. The layouting part of it is heavily inspired by the [type-layout](https://crates.io/crates/type-layout) crate.

rpcl2-derive/src/lib.rs

@@ -0,0 +1,214 @@
+//! This crate provides macros for `ros_pointcloud2`.
+extern crate proc_macro;
+
+use std::collections::HashMap;
+
+use proc_macro::TokenStream;
+use proc_macro2::{Ident, Literal};
+use quote::{quote, ToTokens};
+use syn::{parenthesized, parse_macro_input, Data, DeriveInput, Fields, LitStr};
+
+fn get_allowed_types() -> HashMap<&'static str, usize> {
+    let mut allowed_datatypes = HashMap::<&'static str, usize>::new();
+    allowed_datatypes.insert("f32", std::mem::size_of::<f32>());
+    allowed_datatypes.insert("f64", std::mem::size_of::<f64>());
+    allowed_datatypes.insert("i32", std::mem::size_of::<i32>());
+    allowed_datatypes.insert("u8", std::mem::size_of::<u8>());
+    allowed_datatypes.insert("u16", std::mem::size_of::<u16>());
+    allowed_datatypes.insert("u32", std::mem::size_of::<u32>());
+    allowed_datatypes.insert("i8", std::mem::size_of::<i8>());
+    allowed_datatypes.insert("i16", std::mem::size_of::<i16>());
+    allowed_datatypes
+}
+
+fn struct_field_rename_array(input: &DeriveInput) -> Vec<String> {
+    let fields = match input.data {
+        syn::Data::Struct(ref data) => match data.fields {
+            syn::Fields::Named(ref fields) => &fields.named,
+            _ => panic!("StructNames can only be derived for structs with named fields"),
+        },
+        _ => panic!("StructNames can only be derived for structs"),
+    };
+
+    let mut field_names = Vec::with_capacity(fields.len());
+    for f in fields.iter() {
+        if f.attrs.is_empty() {
+            field_names.push(f.ident.as_ref().unwrap().to_token_stream().to_string());
+        } else {
+            f.attrs.iter().for_each(|attr| {
+                if attr.path().is_ident("rpcl2") {
+                    let res = attr.parse_nested_meta(|meta| {
+                        if meta.path.is_ident("rename") {
+                            let new_name;
+                            parenthesized!(new_name in meta.input);
+                            let lit: LitStr = new_name.parse()?;
+                            field_names.push(lit.value());
+                            Ok(())
+                        } else {
+                            panic!("expected `name` attribute");
+                        }
+                    });
+                    if let Err(e) = res {
+                        panic!("Error parsing attribute: {e}");
+                    }
+                }
+            });
+        }
+    }
+
+    field_names
+}
+
+/// This macro implements the `PointConvertible` trait for your struct so you can use your point for the PointCloud2 conversion.
+///
+/// The struct field names are used in the message if you do not use the `rename` attribute for a custom name.
+///
+/// Note that the repr(C) attribute is required for the struct to work efficiently with C++ PCL.
+/// With Rust layout optimizations, the struct might not work with the PCL library but the message still conforms to the description of PointCloud2.
+/// Furthermore, Rust layout can lead to smaller messages to be send over the network.
+///
+#[proc_macro_derive(PointConvertible, attributes(rpcl2))]
+pub fn ros_point_derive(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = input.clone().ident;
+
+    let fields = match input.data {
+        syn::Data::Struct(ref data) => data.fields.clone(),
+        _ => {
+            return syn::Error::new_spanned(input, "Only structs are supported")
+                .to_compile_error()
+                .into()
+        }
+    };
+
+    let allowed_datatypes = get_allowed_types();
+
+    if fields.is_empty() {
+        return syn::Error::new_spanned(input, "No fields found")
+            .to_compile_error()
+            .into();
+    }
+
+    for field in fields.iter() {
+        let ty = field.ty.to_token_stream().to_string();
+        if ty.contains("RGB") || ty.contains("rgb") {
+            return syn::Error::new_spanned(field, "RGB can not be guaranteed to have the correct type or layout. Implement PointConvertible manual or use predefined points instead.")
+                .to_compile_error()
+                .into();
+        }
+        if !allowed_datatypes.contains_key(&ty.as_str()) {
+            return syn::Error::new_spanned(field, "Field type not allowed")
+                .to_compile_error()
+                .into();
+        }
+    }
+
+    let field_len_token: usize = fields.len();
+    let rename_arr = struct_field_rename_array(&input);
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    let layout = layout_of_type(&name, &input.data);
+
+    let expanded = quote! {
+        unsafe impl #impl_generics ::ros_pointcloud2::PointConvertible<#field_len_token> for #name #ty_generics #where_clause {
+            fn layout() -> ::ros_pointcloud2::LayoutDescription {
+                let mut last_field_end = 0;
+                let mut fields = Vec::new();
+
+                #layout
+
+                let mut rename_idx = 0;
+                let rename_arr = vec![#(#rename_arr),*];
+                let field_info: Vec<::ros_pointcloud2::LayoutField> = fields.into_iter().map(|field| {
+                    match field {
+                        (0, ty, size) => {
+                            rename_idx += 1;
+                            ::ros_pointcloud2::LayoutField::new(rename_arr[rename_idx - 1], ty, size)
+                        },
+                        (1, _, size) => ::ros_pointcloud2::LayoutField::padding(size),
+                        _ => unreachable!(),
+                    }
+                }).collect();
+
+                ::ros_pointcloud2::LayoutDescription::new(field_info.as_slice())
+            }
+        }
+    };
+
+    let field_names_get = fields
+        .iter()
+        .enumerate()
+        .map(|(idx, f)| {
+            let field_name = f.ident.as_ref().unwrap();
+            quote! { #field_name: point[#idx].get() }
+        })
+        .collect::<Vec<_>>();
+
+    let from_my_point = quote! {
+        impl From<ros_pointcloud2::RPCL2Point<#field_len_token>> for #name {
+            fn from(point: ros_pointcloud2::RPCL2Point<#field_len_token>) -> Self {
+                Self {
+                    #(#field_names_get,)*
+                }
+            }
+        }
+    };
+
+    let field_names_into = fields
+        .iter()
+        .map(|f| {
+            let field_name = f.ident.as_ref().unwrap();
+            quote! { point.#field_name.into() }
+        })
+        .collect::<Vec<_>>();
+
+    let from_custom_point = quote! {
+        impl From<#name> for ros_pointcloud2::RPCL2Point<#field_len_token> {
+            fn from(point: #name) -> Self {
+                [ #(#field_names_into,)* ].into()
+            }
+        }
+    };
+
+    TokenStream::from(quote! {
+        #expanded
+        #from_my_point
+        #from_custom_point
+    })
+}
+
+fn layout_of_type(struct_name: &Ident, data: &Data) -> proc_macro2::TokenStream {
+    match data {
+        Data::Struct(data) => match &data.fields {
+            Fields::Named(fields) => {
+                let values = fields.named.iter().map(|field| {
+                    let field_name = field.ident.as_ref().unwrap();
+                    let field_ty = &field.ty;
+                    let field_ty_str = Literal::string(&field_ty.to_token_stream().to_string());
+                    let field_ty = &field.ty;
+
+                    quote! {
+                        let size = ::core::mem::size_of::<#field_ty>();
+                        let offset = ::core::mem::offset_of!(#struct_name, #field_name);
+                        if offset > last_field_end {
+                            fields.push((1, "", offset - last_field_end));
+                        }
+                        fields.push((0, #field_ty_str, size));
+                        last_field_end = offset + size;
+                    }
+                });
+
+                quote! {
+                    #(#values)*
+
+                    let struct_size = ::std::mem::size_of::<#struct_name>();
+                    if struct_size > last_field_end {
+                        fields.push((1, "", struct_size - last_field_end));
+                    }
+                }
+            }
+            Fields::Unnamed(_) => unimplemented!(),
+            Fields::Unit => unimplemented!(),
+        },
+        Data::Enum(_) | Data::Union(_) => unimplemented!("type-layout only supports structs"),
+    }
+}

rpcl2/Cargo.toml

@@ -0,0 +1,70 @@
+[package]
+name = "ros_pointcloud2"
+version = "0.5.3"
+edition = "2021"
+authors = ["Christopher Sieh <stelzo@steado.de>"]
+description = "Customizable conversions for working with sensor_msgs/PointCloud2."
+repository = "https://github.com/stelzo/ros_pointcloud2"
+license = "MIT OR Apache-2.0"
+keywords = ["ros", "pointcloud2", "pointcloud", "message"]
+categories = [
+  "science::robotics",
+  "encoding",
+  "data-structures",
+  "api-bindings",
+]
+readme = "../README.md"
+documentation = "https://docs.rs/ros_pointcloud2"
+homepage = "https://github.com/stelzo/ros_pointcloud2"
+exclude = [
+  "**/.github/**",
+  "**/tests/**",
+  "**/examples/**",
+  "**/benches/**",
+  "**/target/**",
+  "**/build/**",
+  "**/dist/**",
+  "**/docs/**",
+  "**/doc/**",
+  "**/ensure_no_std/**",
+]
+rust-version = "1.77"
+
+[dependencies]
+rosrust_msg = { version = "0.1.8", optional = true }
+rosrust = { version = "0.9.12", optional = true }
+r2r = { version = "0.9", optional = true }
+rayon = { version = "1", optional = true }
+nalgebra = { version = "0.33", optional = true, default-features = false }
+rpcl2-derive = { version = "0.4", optional = true, path = "../rpcl2-derive" }
+serde = { version = "1.0", features = ["derive"], optional = true }
+ros2-interfaces-jazzy = { version = "0.0.4", features = [
+  "sensor_msgs",
+], optional = true }
+
+[dev-dependencies]
+rand = "0.9"
+criterion = { version = "0.5", features = ["html_reports"] }
+pretty_assertions = "1.0"
+
+[[bench]]
+name = "roundtrip"
+harness = false
+path = "benches/roundtrip.rs"
+
+[features]
+serde = ["dep:serde", "nalgebra/serde-serialize-no-std"]
+rosrust_msg = ["dep:rosrust_msg", "dep:rosrust"]
+r2r_msg = ["dep:r2r"]
+ros2-interfaces-jazzy = ["dep:ros2-interfaces-jazzy"]
+rayon = ["dep:rayon"]
+derive = ["dep:rpcl2-derive"]
+nalgebra = ["dep:nalgebra"]
+std = ["nalgebra/std"]
+
+default = ["std"]
+
+[package.metadata.docs.rs]
+features = ["derive", "nalgebra", "rayon", "serde"]
+default-target = "x86_64-unknown-linux-gnu"
+rustdoc-args = ["--cfg", "docsrs"]

rpcl2/benches/roundtrip.rs

@@ -0,0 +1,679 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use ros_pointcloud2::prelude::*;
+
+use rand::Rng;
+
+pub type PointXYZB = PointXYZINormal;
+
+pub fn distance_to_origin(point: &PointXYZ) -> f32 {
+    ((point.x.powi(2)) + (point.y.powi(2)) + (point.z.powi(2))).sqrt()
+}
+
+pub fn dot_product(point1: &PointXYZ, point2: &PointXYZ) -> f32 {
+    point1.x * point2.x + point1.y * point2.y + point1.z * point2.z
+}
+
+pub fn cross_product(point1: &PointXYZ, point2: &PointXYZ) -> PointXYZ {
+    PointXYZ {
+        x: point1.y * point2.z - point1.z * point2.y,
+        y: point1.z * point2.x - point1.x * point2.z,
+        z: point1.x * point2.y - point1.y * point2.x,
+    }
+}
+
+pub fn scalar_multiply(point: &PointXYZ, scalar: f32) -> PointXYZ {
+    PointXYZ {
+        x: point.x * scalar,
+        y: point.y * scalar,
+        z: point.z * scalar,
+    }
+}
+
+pub fn magnitude_squared(point: &PointXYZ) -> f32 {
+    (point.x.powi(2)) + (point.y.powi(2)) + (point.z.powi(2))
+}
+
+pub fn reflection_through_plane(
+    point: &PointXYZ,
+    normal: &PointXYZ,
+    point_on_plane: &PointXYZ,
+) -> PointXYZ {
+    PointXYZ {
+        x: point.x
+            - 2.0
+                * ((point.x - point_on_plane.x) * normal.x
+                    + (point.y - point_on_plane.y) * normal.y
+                    + (point.z - point_on_plane.z) * normal.z),
+        y: point.y
+            - 2.0
+                * ((point.x - point_on_plane.x) * normal.x
+                    + (point.y - point_on_plane.y) * normal.y
+                    + (point.z - point_on_plane.z) * normal.z),
+        z: point.z
+            - 2.0
+                * ((point.x - point_on_plane.x) * normal.x
+                    + (point.y - point_on_plane.y) * normal.y
+                    + (point.z - point_on_plane.z) * normal.z),
+    }
+}
+
+pub fn rotation_about_x(point: &PointXYZ, angle: f32) -> PointXYZ {
+    let c = f32::cos(angle);
+    let s = f32::sin(angle);
+    PointXYZ {
+        x: point.x,
+        y: point.y * c - point.z * s,
+        z: point.y * s + point.z * c,
+    }
+}
+
+pub fn closest_point_on_line(
+    point: &PointXYZ,
+    line_point: &PointXYZ,
+    line_direction: &PointXYZ,
+) -> PointXYZ {
+    PointXYZ {
+        x: line_point.x
+            + (line_point.x - point.x) * ((line_point.x - point.x).powi(2))
+                / ((line_direction.x * 2.0).powi(2))
+            + (line_direction.y * 2.0) * (point.z - line_point.z)
+                / ((line_direction.z * 2.0).powi(2)),
+        y: line_point.y
+            + (line_point.y - point.y) * ((line_point.y - point.y).powi(2))
+                / ((line_direction.y * 2.0).powi(2))
+            + (line_direction.x * 2.0) * (point.x - line_point.x)
+                / ((line_direction.x * 2.0).powi(2)),
+        z: line_point.z
+            + (line_point.z - point.z) * ((line_point.z - point.z).powi(2))
+                / ((line_direction.z * 2.0).powi(2))
+            + (line_direction.y * 2.0) * (point.y - line_point.y)
+                / ((line_direction.y * 2.0).powi(2)),
+    }
+}
+
+fn minus(point1: &PointXYZ, point2: &PointXYZ) -> PointXYZ {
+    PointXYZ {
+        x: point1.x - point2.x,
+        y: point1.y - point2.y,
+        z: point1.z - point2.z,
+    }
+}
+
+pub fn generate_random_pointcloud(num_points: usize, min: f32, max: f32) -> Vec<PointXYZB> {
+    let mut rng = rand::rng();
+    let mut pointcloud = Vec::with_capacity(num_points);
+    for _ in 0..num_points {
+        let point = PointXYZB {
+            x: rng.random_range(min..max),
+            y: rng.random_range(min..max),
+            z: rng.random_range(min..max),
+            ..Default::default()
+        };
+        pointcloud.push(point);
+    }
+    pointcloud
+}
+
+pub fn heavy_computing(point: &PointXYZ, iterations: u32) -> f32 {
+    let mut result = distance_to_origin(point);
+    for _ in 0..iterations {
+        result += dot_product(
+            point,
+            &PointXYZ {
+                x: 1.0,
+                y: 2.0,
+                z: 3.0,
+            },
+        );
+        result += cross_product(
+            point,
+            &PointXYZ {
+                x: 4.0,
+                y: 5.0,
+                z: 6.0,
+            },
+        )
+        .x;
+        result = result + (result * 10.0).sqrt();
+        let reflected_point = reflection_through_plane(
+            point,
+            &PointXYZ {
+                x: 7.0,
+                y: 8.0,
+                z: 9.0,
+            },
+            &PointXYZ {
+                x: 3.0,
+                y: 4.0,
+                z: 5.0,
+            },
+        );
+        let rotated_point = rotation_about_x(
+            &PointXYZ {
+                x: 10.0,
+                y: 11.0,
+                z: 12.0,
+            },
+            std::f32::consts::PI / 2.0,
+        );
+
+        result += magnitude_squared(&minus(&reflected_point, &rotated_point));
+    }
+    result
+}
+
+fn roundtrip_vec(cloud: Vec<PointXYZB>) -> bool {
+    let orig_len = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_vec(cloud).unwrap();
+    let total: Vec<PointXYZ> = internal_msg.try_into_vec().unwrap();
+    orig_len == total.len()
+}
+
+fn roundtrip(cloud: Vec<PointXYZB>) -> bool {
+    let orig_len = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+    let total = internal_msg
+        .try_into_iter()
+        .unwrap()
+        .collect::<Vec<PointXYZ>>();
+    orig_len == total.len()
+}
+
+fn roundtrip_filter_vec(cloud: Vec<PointXYZB>) -> bool {
+    let orig_len = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_vec(cloud).unwrap();
+    let total = internal_msg
+        .try_into_iter()
+        .unwrap()
+        .filter(|point: &PointXYZ| distance_to_origin(point) < 69.9)
+        .fold(PointXYZ::default(), |acc, point| PointXYZ {
+            x: acc.x + point.x,
+            y: acc.y + point.y,
+            z: acc.z + point.z,
+        });
+    orig_len == total.x as usize
+}
+
+fn roundtrip_filter(cloud: Vec<PointXYZB>) -> bool {
+    let orig_len = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+    let total = internal_msg
+        .try_into_iter()
+        .unwrap()
+        .filter(|point: &PointXYZ| distance_to_origin(point) < 69.9)
+        .fold(PointXYZ::default(), |acc, point| PointXYZ {
+            x: acc.x + point.x,
+            y: acc.y + point.y,
+            z: acc.z + point.z,
+        });
+    orig_len == total.x as usize
+}
+
+fn roundtrip_computing(cloud: Vec<PointXYZB>) -> bool {
+    let internal_msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+    let total = internal_msg
+        .try_into_iter()
+        .unwrap()
+        .map(|point: PointXYZ| heavy_computing(&point, 100))
+        .sum::<f32>();
+    total > 0.0
+}
+
+#[cfg(feature = "rayon")]
+fn roundtrip_computing_par(cloud: Vec<PointXYZB>) -> bool {
+    let internal_msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+    let total = internal_msg
+        .try_into_par_iter()
+        .unwrap()
+        .map(|point: PointXYZ| heavy_computing(&point, 100))
+        .sum::<f32>();
+    total > 0.0
+}
+
+#[cfg(feature = "rayon")]
+fn roundtrip_computing_par_par(cloud: Vec<PointXYZB>) -> bool {
+    let internal_msg = PointCloud2Msg::try_from_par_iter(cloud.into_par_iter()).unwrap();
+    let total = internal_msg
+        .try_into_par_iter()
+        .unwrap()
+        .map(|point: PointXYZ| heavy_computing(&point, 100))
+        .sum::<f32>();
+    total > 0.0
+}
+
+fn roundtrip_computing_vec(cloud: Vec<PointXYZB>) -> bool {
+    let internal_msg = PointCloud2Msg::try_from_vec(cloud).unwrap();
+    let total: f32 = internal_msg
+        .try_into_vec()
+        .unwrap()
+        .into_iter()
+        .map(|point: PointXYZ| heavy_computing(&point, 100))
+        .sum();
+    total > 0.0
+}
+
+#[cfg(feature = "rayon")]
+fn roundtrip_par(cloud: Vec<PointXYZB>) -> bool {
+    let orig_len = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+    let total = internal_msg
+        .try_into_par_iter()
+        .unwrap()
+        .collect::<Vec<PointXYZ>>();
+    orig_len != total.len()
+}
+
+#[cfg(feature = "rayon")]
+fn roundtrip_par_par(cloud: Vec<PointXYZB>) -> bool {
+    let orig_len = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_par_iter(cloud.into_par_iter()).unwrap();
+    let total = internal_msg
+        .try_into_par_iter()
+        .unwrap()
+        .collect::<Vec<PointXYZ>>();
+    orig_len != total.len()
+}
+
+#[cfg(feature = "rayon")]
+fn roundtrip_filter_par(cloud: Vec<PointXYZB>) -> bool {
+    let orig_len: usize = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+    let total = internal_msg
+        .try_into_par_iter()
+        .unwrap()
+        .filter(|point: &PointXYZ| distance_to_origin(point) < 69.9)
+        .reduce(PointXYZ::default, |acc, point| PointXYZ {
+            x: acc.x + point.x,
+            y: acc.y + point.y,
+            z: acc.z + point.z,
+        });
+    orig_len == total.x as usize
+}
+
+#[cfg(feature = "rayon")]
+fn roundtrip_filter_par_par(cloud: Vec<PointXYZB>) -> bool {
+    let orig_len: usize = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_par_iter(cloud.into_par_iter()).unwrap();
+    let total = internal_msg
+        .try_into_par_iter()
+        .unwrap()
+        .filter(|point: &PointXYZ| distance_to_origin(point) < 69.9)
+        .reduce(PointXYZ::default, |acc, point| PointXYZ {
+            x: acc.x + point.x,
+            y: acc.y + point.y,
+            z: acc.z + point.z,
+        });
+    orig_len == total.x as usize
+}
+
+fn roundtrip_benchmark(c: &mut Criterion) {
+    let cloud_points_16k = generate_random_pointcloud(16_000, f32::MIN / 2.0, f32::MAX / 2.0);
+    let cloud_points_60k = generate_random_pointcloud(60_000, f32::MIN / 2.0, f32::MAX / 2.0);
+    let cloud_points_120k = generate_random_pointcloud(120_000, f32::MIN / 2.0, f32::MAX / 2.0);
+    let cloud_points_500k = generate_random_pointcloud(500_000, f32::MIN / 2.0, f32::MAX / 2.0);
+    let cloud_points_1_5m = generate_random_pointcloud(1_500_000, f32::MIN / 2.0, f32::MAX / 2.0);
+
+    // 16k points (Velodyne with 16 beams)
+
+    // Moving memory
+    c.bench_function("16k iter", |b| {
+        b.iter(|| {
+            black_box(roundtrip(cloud_points_16k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("16k iter_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_par(cloud_points_16k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("16k iter_par_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_par_par(cloud_points_16k.clone()));
+        })
+    });
+
+    c.bench_function("16k vec", |b| {
+        b.iter(|| {
+            black_box(roundtrip_vec(cloud_points_16k.clone()));
+        })
+    });
+
+    // Simple distance filter
+    c.bench_function("16k iter_filter", |b| {
+        b.iter(|| {
+            roundtrip_filter(black_box(cloud_points_16k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("16k filter_par", |b| {
+        b.iter(|| {
+            roundtrip_filter_par(black_box(cloud_points_16k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("16k filter_par_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_filter_par_par(cloud_points_16k.clone()));
+        })
+    });
+
+    c.bench_function("16k vec_filter", |b| {
+        b.iter(|| {
+            roundtrip_filter_vec(black_box(cloud_points_16k.clone()));
+        })
+    });
+
+    // Heavy computing
+    c.bench_function("16k iter_compute", |b| {
+        b.iter(|| {
+            roundtrip_computing(black_box(cloud_points_16k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("16k iter_compute_par", |b| {
+        b.iter(|| {
+            roundtrip_computing_par(black_box(cloud_points_16k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("16k iter_compute_par_par", |b| {
+        b.iter(|| {
+            roundtrip_computing_par_par(black_box(cloud_points_16k.clone()));
+        })
+    });
+
+    c.bench_function("16k vec_compute", |b| {
+        b.iter(|| {
+            roundtrip_computing_vec(black_box(cloud_points_16k.clone()));
+        })
+    });
+
+    // 60k points (Ouster with 64 beams)
+
+    // Moving memory
+    c.bench_function("60k iter", |b| {
+        b.iter(|| {
+            black_box(roundtrip(cloud_points_60k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("60k iter_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_par(cloud_points_60k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("60k iter_par_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_par_par(cloud_points_60k.clone()));
+        })
+    });
+
+    c.bench_function("60k vec", |b| {
+        b.iter(|| {
+            black_box(roundtrip_vec(cloud_points_60k.clone()));
+        })
+    });
+
+    // 120k points (Ouster with 128 beams)
+
+    // Moving memory
+    c.bench_function("120k iter", |b| {
+        b.iter(|| {
+            black_box(roundtrip(cloud_points_120k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("120k iter_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_par(cloud_points_120k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("120k iter_par_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_par_par(cloud_points_120k.clone()));
+        })
+    });
+
+    c.bench_function("120k vec", |b| {
+        b.iter(|| {
+            black_box(roundtrip_vec(cloud_points_120k.clone()));
+        })
+    });
+
+    // Simple distance filter
+    c.bench_function("120k iter_filter", |b| {
+        b.iter(|| {
+            roundtrip_filter(black_box(cloud_points_120k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("120k filter_par", |b| {
+        b.iter(|| {
+            roundtrip_filter_par(black_box(cloud_points_120k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("120k filter_par_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_filter_par_par(cloud_points_120k.clone()));
+        })
+    });
+
+    c.bench_function("120k vec_filter", |b| {
+        b.iter(|| {
+            roundtrip_filter_vec(black_box(cloud_points_120k.clone()));
+        })
+    });
+
+    // Heavy computing
+    c.bench_function("120k iter_compute", |b| {
+        b.iter(|| {
+            roundtrip_computing(black_box(cloud_points_120k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("120k iter_compute_par", |b| {
+        b.iter(|| {
+            roundtrip_computing_par(black_box(cloud_points_120k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("120k iter_compute_par_par", |b| {
+        b.iter(|| {
+            roundtrip_computing_par_par(black_box(cloud_points_120k.clone()));
+        })
+    });
+
+    c.bench_function("120k vec_compute", |b| {
+        b.iter(|| {
+            roundtrip_computing_vec(black_box(cloud_points_120k.clone()));
+        })
+    });
+
+    // 500k points (just to show how it scales)
+
+    // Moving memory
+    c.bench_function("500k iter", |b| {
+        b.iter(|| {
+            black_box(roundtrip(cloud_points_500k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("500k iter_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_par(cloud_points_500k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("500k iter_par_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_par_par(cloud_points_500k.clone()));
+        })
+    });
+
+    c.bench_function("500k vec", |b| {
+        b.iter(|| {
+            black_box(roundtrip_vec(cloud_points_500k.clone()));
+        })
+    });
+
+    // Simple distance filter
+    c.bench_function("500k iter_filter", |b| {
+        b.iter(|| {
+            roundtrip_filter(black_box(cloud_points_500k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("500k filter_par", |b| {
+        b.iter(|| {
+            roundtrip_filter_par(black_box(cloud_points_500k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("500k filter_par_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_filter_par_par(cloud_points_500k.clone()));
+        })
+    });
+
+    c.bench_function("500k vec_filter", |b| {
+        b.iter(|| {
+            roundtrip_filter_vec(black_box(cloud_points_500k.clone()));
+        })
+    });
+
+    // Heavy computing
+    c.bench_function("500k iter_compute", |b| {
+        b.iter(|| {
+            roundtrip_computing(black_box(cloud_points_500k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("500k iter_compute_par", |b| {
+        b.iter(|| {
+            roundtrip_computing_par(black_box(cloud_points_500k.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("500k iter_compute_par_par", |b| {
+        b.iter(|| {
+            roundtrip_computing_par_par(black_box(cloud_points_500k.clone()));
+        })
+    });
+
+    c.bench_function("500k vec_compute", |b| {
+        b.iter(|| {
+            roundtrip_computing_vec(black_box(cloud_points_500k.clone()));
+        })
+    });
+
+    // 1.5m points (scale of small localmaps in SLAM)
+
+    // Moving memory
+    c.bench_function("1.5m iter", |b| {
+        b.iter(|| {
+            black_box(roundtrip(cloud_points_1_5m.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("1.5m iter_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_par(cloud_points_1_5m.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("1.5m iter_par_par", |b| {
+        b.iter(|| {
+            black_box(roundtrip_par_par(cloud_points_1_5m.clone()));
+        })
+    });
+
+    c.bench_function("1.5m vec", |b| {
+        b.iter(|| {
+            black_box(roundtrip_vec(cloud_points_1_5m.clone()));
+        })
+    });
+
+    // Simple distance filter
+    c.bench_function("1.5m iter_filter", |b| {
+        b.iter(|| {
+            roundtrip_filter(black_box(cloud_points_1_5m.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("1.5m iter_par_filter", |b| {
+        b.iter(|| {
+            black_box(roundtrip_filter_par(cloud_points_1_5m.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("1.5m iter_par_par_filter", |b| {
+        b.iter(|| {
+            black_box(roundtrip_filter_par_par(cloud_points_1_5m.clone()));
+        })
+    });
+
+    c.bench_function("1.5m vec_filter", |b| {
+        b.iter(|| {
+            roundtrip_filter_vec(black_box(cloud_points_1_5m.clone()));
+        })
+    });
+
+    // Heavy computing
+    c.bench_function("1.5m iter_compute", |b| {
+        b.iter(|| {
+            roundtrip_computing(black_box(cloud_points_1_5m.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("1.5m iter_compute_par", |b| {
+        b.iter(|| {
+            roundtrip_computing_par(black_box(cloud_points_1_5m.clone()));
+        })
+    });
+
+    #[cfg(feature = "rayon")]
+    c.bench_function("1.5m iter_compute_par_par", |b| {
+        b.iter(|| {
+            roundtrip_computing_par_par(black_box(cloud_points_1_5m.clone()));
+        })
+    });
+
+    c.bench_function("1.5m vec_compute", |b| {
+        b.iter(|| {
+            roundtrip_computing_vec(black_box(cloud_points_1_5m.clone()));
+        })
+    });
+}
+
+criterion_group!(benches, roundtrip_benchmark);
+criterion_main!(benches);

rpcl2/ensure_no_std/.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

rpcl2/ensure_no_std/Cargo.toml

@@ -0,0 +1,15 @@
+[workspace]
+
+[package]
+name = "ensure_no_std"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+ros_pointcloud2 = { path = "..", default-features = false, features = ["nalgebra", "derive"] }
+
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"

rpcl2/ensure_no_std/src/main.rs

@@ -0,0 +1,14 @@
+#![no_std]
+#![no_main]
+
+use core::panic::PanicInfo;
+
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    loop {}
+}
+
+#[no_mangle]
+pub extern "C" fn _start() -> ! {
+    loop {}
+}

rpcl2/examples/custom_enum_field_filter.rs

@@ -0,0 +1,160 @@
+/// This example demonstrates how to use a custom point with encoded metadata.
+/// The use case is a segmentation point cloud where each point holds a label and we want to filter by it.
+/// Since the datatypes for the PointCloud2 message are very limited,
+/// we need to encode the enum into a supported type.
+/// This needs some manual work to tell the library how to encode and decode the enum.
+///
+/// Important Note: This example is only possible with disabled `derive` feature,
+/// because the library (currently) does not know the size of your chosen supported type at compile time.
+/// This makes direct copies impossible.
+use ros_pointcloud2::prelude::*;
+
+#[derive(Debug, PartialEq, Clone, Default, Copy)]
+enum Label {
+    #[default]
+    Human,
+    Deer,
+    Car,
+}
+
+// Define a custom point with an enum.
+// This is normally not supported by PointCloud2 but we will explain the library how to handle it.
+#[derive(Debug, PartialEq, Clone, Default)]
+#[repr(C, align(4))]
+struct CustomPoint {
+    x: f32,
+    y: f32,
+    z: f32,
+    intensity: f32,
+    my_custom_label: Label,
+}
+
+// Some convenience functions to convert between the enum and u8.
+impl From<Label> for u8 {
+    fn from(label: Label) -> Self {
+        match label {
+            Label::Human => 0,
+            Label::Deer => 1,
+            Label::Car => 2,
+        }
+    }
+}
+
+impl From<u8> for Label {
+    fn from(label: u8) -> Self {
+        match label {
+            0 => Label::Human,
+            1 => Label::Deer,
+            2 => Label::Car,
+            _ => panic!("Invalid label"),
+        }
+    }
+}
+
+impl CustomPoint {
+    fn new(x: f32, y: f32, z: f32, intensity: f32, my_custom_label: Label) -> Self {
+        Self {
+            x,
+            y,
+            z,
+            intensity,
+            my_custom_label,
+        }
+    }
+}
+
+// We implement the PointConvertible trait (needed for every custom point).
+// RPCL2Point is the internal representation. It takes the amount of fields as generic arguments.
+impl From<CustomPoint> for RPCL2Point<5> {
+    fn from(point: CustomPoint) -> Self {
+        [
+            point.x.into(),
+            point.y.into(),
+            point.z.into(),
+            point.intensity.into(),
+            u8::from(point.my_custom_label).into(),
+        ]
+        .into()
+    }
+}
+
+impl From<RPCL2Point<5>> for CustomPoint {
+    fn from(point: RPCL2Point<5>) -> Self {
+        Self::new(
+            point[0].get(),
+            point[1].get(),
+            point[2].get(),
+            point[3].get(),
+            point[4].get(),
+        )
+    }
+}
+
+// C representation of the struct hardcoded without using the derive feature.
+unsafe impl PointConvertible<5> for CustomPoint {
+    fn layout() -> LayoutDescription {
+        LayoutDescription::new(&[
+            LayoutField::new("x", "f32", 4),
+            LayoutField::new("y", "f32", 4),
+            LayoutField::new("z", "f32", 4),
+            LayoutField::new("intensity", "f32", 4),
+            LayoutField::new("my_custom_label", "u8", 1),
+            LayoutField::padding(3),
+        ])
+    }
+}
+
+// Now we tell the library how to encode and decode the label.
+// You don't need to do this if your CustomPoint has a field that is already supported by PointCloud2.
+impl GetFieldDatatype for Label {
+    fn field_datatype() -> FieldDatatype {
+        FieldDatatype::U8 // Declare that we want to use u8 as the datatype for the label.
+    }
+}
+
+// Again, you don't need this with only supported field types.
+// u8 -> Label
+impl FromBytes for Label {
+    // Technically, PointCloud2 supports big and little endian even though it is rarely used.
+    // 'be' stands for big endian and 'le' for little endian.
+    fn from_be_bytes(bytes: PointDataBuffer) -> Self {
+        u8::from_be_bytes([bytes[0]]).into()
+    }
+
+    fn from_le_bytes(bytes: PointDataBuffer) -> Self {
+        u8::from_le_bytes([bytes[0]]).into()
+    }
+}
+
+// Label -> u8
+impl From<Label> for PointDataBuffer {
+    fn from(label: Label) -> Self {
+        [u8::from(label)].into()
+    }
+}
+
+fn main() {
+    let cloud = vec![
+        CustomPoint::new(1.0, 2.0, 3.0, 4.0, Label::Deer),
+        CustomPoint::new(4.0, 5.0, 6.0, 7.0, Label::Car),
+        CustomPoint::new(7.0, 8.0, 9.0, 10.0, Label::Human),
+    ];
+
+    println!("Original cloud: {cloud:?}");
+
+    let msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+
+    println!("filtering by label == Deer");
+    let out = msg
+        .try_into_iter()
+        .unwrap()
+        .filter(|point: &CustomPoint| point.my_custom_label == Label::Deer)
+        .collect::<Vec<_>>();
+
+    println!("Filtered cloud: {out:?}");
+
+    assert_eq!(
+        vec![CustomPoint::new(1.0, 2.0, 3.0, 4.0, Label::Deer),],
+        out
+    );
+}

rpcl2/examples/rayon_bench.rs

@@ -0,0 +1,135 @@
+use rand::Rng;
+/// This example implements a naive benchmark for the library so you can evaluate the use of rayon for parallel processing.
+/// It generates a random point cloud and measures the time it takes to iterate over it.
+/// The code works mainly as a showcase. For actual benchmarks, check the `benches` directory or run `cargo bench`.
+use std::time::Duration;
+
+use ros_pointcloud2::prelude::*;
+
+pub fn generate_random_pointcloud(num_points: usize, min: f32, max: f32) -> Vec<PointXYZ> {
+    let mut rng = rand::rng();
+    let mut pointcloud = Vec::with_capacity(num_points);
+    for _ in 0..num_points {
+        let point = PointXYZ {
+            x: rng.random_range(min..max),
+            y: rng.random_range(min..max),
+            z: rng.random_range(min..max),
+        };
+        pointcloud.push(point);
+    }
+    pointcloud
+}
+
+fn roundtrip(cloud: Vec<PointXYZ>) -> bool {
+    let orig_len = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+    let total = internal_msg
+        .try_into_iter()
+        .unwrap()
+        .collect::<Vec<PointXYZ>>();
+    orig_len == total.len()
+}
+
+fn roundtrip_filter(cloud: Vec<PointXYZ>) -> bool {
+    let orig_len = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+    let total = internal_msg
+        .try_into_iter()
+        .unwrap()
+        .filter(|point: &PointXYZ| {
+            (point.x.powi(2) + point.y.powi(2) + point.z.powi(2)).sqrt() < 1.9
+        })
+        .fold(PointXYZ::default(), |acc, point| PointXYZ {
+            x: acc.x + point.x,
+            y: acc.y + point.y,
+            z: acc.z + point.z,
+        });
+    orig_len == total.x as usize
+}
+
+#[cfg(feature = "rayon")]
+fn roundtrip_par(cloud: Vec<PointXYZ>) -> bool {
+    let orig_len = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+    let total = internal_msg
+        .try_into_par_iter()
+        .unwrap()
+        .collect::<Vec<PointXYZ>>();
+    orig_len != total.len()
+}
+
+#[cfg(feature = "rayon")]
+fn roundtrip_filter_par(cloud: Vec<PointXYZ>) -> bool {
+    let orig_len: usize = cloud.len();
+    let internal_msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+    let total = internal_msg
+        .try_into_par_iter()
+        .unwrap()
+        .filter(|point: &PointXYZ| {
+            (point.x.powi(2) + point.y.powi(2) + point.z.powi(2)).sqrt() < 1.9
+        })
+        .reduce(PointXYZ::default, |acc, point| PointXYZ {
+            x: acc.x + point.x,
+            y: acc.y + point.y,
+            z: acc.z + point.z,
+        });
+    orig_len == total.x as usize
+}
+
+// call measure_func X times and print the average time
+fn measure_func_avg(
+    num_iterations: u32,
+    pcl_size: usize,
+    func: fn(Vec<PointXYZ>) -> bool,
+) -> Duration {
+    let mut total_time = Duration::new(0, 0);
+    for _ in 0..num_iterations {
+        total_time += measure_func(pcl_size, func);
+    }
+    total_time / num_iterations
+}
+
+fn measure_func<F>(pcl_size: usize, func: F) -> Duration
+where
+    F: Fn(Vec<PointXYZ>) -> bool,
+{
+    let cloud_points = generate_random_pointcloud(pcl_size, f32::MIN / 2.0, f32::MAX / 2.0);
+    let start = std::time::Instant::now();
+    let _ = func(cloud_points);
+    start.elapsed()
+}
+
+fn main() {
+    println!("100k");
+    let how_many = 10_000;
+    let how_often = 1_000;
+
+    let dur = measure_func_avg(how_often, how_many, roundtrip);
+    println!("roundtrip: {dur:?}");
+
+    #[cfg(feature = "rayon")]
+    let dur = measure_func_avg(how_often, how_many, roundtrip_par);
+    println!("roundtrip_par: {dur:?}");
+
+    println!("200k");
+    let how_many = 200_000;
+    let how_often = 100;
+
+    let dur = measure_func_avg(how_often, how_many, roundtrip_filter);
+    println!("roundtrip_filter: {dur:?}");
+
+    #[cfg(feature = "rayon")]
+    let dur = measure_func_avg(how_often, how_many, roundtrip_filter_par);
+    println!("roundtrip_filter_par: {dur:?}");
+
+    println!("10m");
+    let how_many = 10_000_000;
+    let how_often = 10;
+
+    let dur = measure_func_avg(how_often, how_many, roundtrip_filter);
+    println!("roundtrip_filter: {dur:?}");
+
+    #[cfg(feature = "rayon")]
+    let dur = measure_func_avg(how_often, how_many, roundtrip_filter_par);
+    println!("roundtrip_filter_par: {dur:?}");
+}

rpcl2/examples/simple_distance_filter.rs

@@ -0,0 +1,31 @@
+/// This example demonstrates a very simple distance filter with predefined point types.
+/// Note that this example is a simplified version of the custom_enum_field_filter.rs example.
+/// Also, it effectively demonstrates a typesafe byte-to-byte buffer filter with a single iteration.
+///
+/// It also works without any dependencies, making it a good "hello world" example.
+use ros_pointcloud2::prelude::*;
+
+fn main() {
+    let cloud = vec![
+        PointXYZ::new(1.0, 1.0, 1.0),
+        PointXYZ::new(2.0, 2.0, 2.0),
+        PointXYZ::new(3.0, 3.0, 3.0),
+    ];
+
+    println!("Original cloud: {cloud:?}");
+
+    let msg = PointCloud2Msg::try_from_iter(cloud).unwrap();
+
+    println!("filtering by distance < 1.9m");
+    let out = msg
+        .try_into_iter()
+        .unwrap()
+        .filter(|point: &PointXYZ| {
+            (point.x.powi(2) + point.y.powi(2) + point.z.powi(2)).sqrt() < 1.9
+        })
+        .collect::<Vec<_>>();
+
+    println!("Filtered cloud: {out:?}");
+
+    assert_eq!(vec![PointXYZ::new(1.0, 1.0, 1.0),], out);
+}

rpcl2/src/iterator.rs

@@ -260,8 +260,6 @@ where
     /// The theoretical time complexity is O(n) where n is the number of fields defined in the message for a single point which is typically small.
     /// It therefore has a constant time complexity O(1) for practical purposes.
     fn try_from(cloud: PointCloud2Msg) -> Result<Self, Self::Error> {
-        let mut pdata_with_offsets = vec![(String::default(), FieldDatatype::default(), 0); N];
-
         let fields_only = crate::ordered_field_names::<N, C>();
 
         let not_found_fieldnames = fields_only
@@ -281,13 +279,14 @@ where
             return Err(MsgConversionError::FieldsNotFound(names_not_found));
         }
 
-        for (field, with_offset) in cloud.fields.iter().zip(pdata_with_offsets.iter_mut()) {
+        let mut pdata_with_offsets = Vec::with_capacity(N);
+        for field in cloud.fields.iter() {
             if fields_only.contains(&field.name) {
-                *with_offset = (
+                pdata_with_offsets.push((
                     field.name.clone(),
                     field.datatype.try_into()?,
                     field.offset as usize,
-                );
+                ));
             }
         }
 

rpcl2/src/lib.rs

@@ -17,11 +17,11 @@
 //! - [`try_into_par_iter`](PointCloud2Msg::try_into_par_iter) requires `rayon` feature
 //! - [`try_from_par_iter`](PointCloud2Msg::try_from_par_iter) requires `rayon` feature
 //!
-//! For ROS interoperability, there are integrations avialable with feature flags. If you miss a message type, please open an issue or a PR.
+//! For ROS interoperability, there are integrations available with feature flags. If you miss a message type, please open an issue or a PR.
 //! See the [`ros`] module for more information on how to integrate more libraries.
 //!
 //! Common point types like [`PointXYZ`](points::PointXYZ) or [`PointXYZI`](points::PointXYZI) are provided. See the full list [`here`](points). You can easily add any additional custom type.
-//! See [custom_enum_field_filter.rs](https://github.com/stelzo/ros_pointcloud2/blob/main/examples/custom_enum_field_filter.rs) for an example.
+//! See [custom_enum_field_filter.rs](https://github.com/stelzo/ros_pointcloud2/blob/main/rpcl2/examples/custom_enum_field_filter.rs) for an example.
 //!
 //! # Minimal Example
 //! ```
@@ -67,6 +67,7 @@
 //! ## Derive (recommended)
 //! ```ignore
 //! #[derive(Clone, Debug, PartialEq, Copy, Default, PointConvertible)]
+//! #[repr(C, align(4))]
 //! pub struct MyPointXYZI {
 //!     pub x: f32,
 //!     pub y: f32,
@@ -81,6 +82,7 @@
 //! use ros_pointcloud2::prelude::*;
 //!
 //! #[derive(Clone, Debug, PartialEq, Copy, Default)]
+//! #[repr(C, align(4))]
 //! pub struct MyPointXYZI {
 //!     pub x: f32,
 //!     pub y: f32,
@@ -106,7 +108,7 @@
 //!     }
 //! }
 //!
-//! impl PointConvertible<4> for MyPointXYZI {
+//! unsafe impl PointConvertible<4> for MyPointXYZI {
 //!     fn layout() -> LayoutDescription {
 //!         LayoutDescription::new(&[
 //!             LayoutField::new("x", "f32", 4),
@@ -125,7 +127,7 @@
 //! ```
 #![crate_type = "lib"]
 #![cfg_attr(docsrs, feature(doc_cfg))]
-#![doc(html_root_url = "https://docs.rs/ros_pointcloud2/0.5.0-rc.3")]
+#![doc(html_root_url = "https://docs.rs/ros_pointcloud2/0.5.1")]
 #![warn(clippy::print_stderr)]
 #![warn(clippy::print_stdout)]
 #![warn(clippy::unwrap_used)]
@@ -137,6 +139,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 // Setup an allocator with #[global_allocator]
 // see: https://doc.rust-lang.org/std/alloc/trait.GlobalAlloc.html
+#![allow(unexpected_cfgs)]
 
 pub mod points;
 pub mod prelude;
@@ -146,12 +149,11 @@ pub mod iterator;
 
 use crate::ros::{HeaderMsg, PointFieldMsg};
 
-#[cfg(feature = "derive")]
-#[doc(hidden)]
-pub use memoffset;
-
 use core::str::FromStr;
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 #[macro_use]
 extern crate alloc;
 use alloc::string::String;
@@ -169,6 +171,7 @@ pub enum MsgConversionError {
     FieldsNotFound(Vec<String>),
     UnsupportedFieldCount,
     NumberConversion,
+    ExhaustedSource,
 }
 
 impl From<core::num::TryFromIntError> for MsgConversionError {
@@ -212,10 +215,17 @@ impl core::fmt::Display for MsgConversionError {
             MsgConversionError::NumberConversion => {
                 write!(f, "The number is too large to be converted into a PointCloud2 supported datatype.")
             }
+            MsgConversionError::ExhaustedSource => {
+                write!(
+                    f,
+                    "The conversion requests more data from the source type than is available."
+                )
+            }
         }
     }
 }
 
+#[allow(clippy::std_instead_of_core)] // will be stable soon (https://github.com/rust-lang/rust/issues/103765)
 #[cfg(feature = "std")]
 impl std::error::Error for MsgConversionError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
@@ -275,6 +285,7 @@ impl LayoutField {
 /// To assert consistency, the type should be build with the [`PointCloud2MsgBuilder`].
 /// See the offical [ROS message description](https://docs.ros2.org/latest/api/sensor_msgs/msg/PointCloud2.html) for more information on the fields.
 #[derive(Clone, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointCloud2Msg {
     pub header: HeaderMsg,
     pub dimensions: CloudDimensions,
@@ -288,6 +299,7 @@ pub struct PointCloud2Msg {
 
 /// Endianess encoding hint for the message.
 #[derive(Default, Clone, Debug, PartialEq, Copy)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum Endian {
     Big,
     #[default]
@@ -296,12 +308,14 @@ pub enum Endian {
 
 /// Density flag for the message. Writing sparse point clouds is not supported.
 #[derive(Default, Clone, Debug, PartialEq, Copy)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum Denseness {
     #[default]
     Dense,
     Sparse,
 }
 
+#[derive(Clone, Debug, PartialEq)]
 enum ByteSimilarity {
     Equal,
     Overlapping,
@@ -451,6 +465,7 @@ impl PointCloud2MsgBuilder {
 
 /// Dimensions of the point cloud as width and height.
 #[derive(Clone, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct CloudDimensions {
     pub width: u32,
     pub height: u32,
@@ -487,15 +502,11 @@ impl PointCloud2Msg {
     where
         C: PointConvertible<N>,
     {
-        let point: RPCL2Point<N> = C::default().into();
-        debug_assert!(point.fields.len() == N);
-
         let field_names = ordered_field_names::<N, C>();
-        debug_assert!(field_names.len() == N);
-
         let target_layout = KnownLayoutInfo::try_from(C::layout())?;
+
         debug_assert!(field_names.len() <= target_layout.fields.len());
-        debug_assert!(self.fields.len() <= target_layout.fields.len());
+        debug_assert!(self.fields.len() >= target_layout.fields.len());
 
         let mut offset: u32 = 0;
         let mut field_counter = 0;
@@ -506,8 +517,12 @@ impl PointCloud2Msg {
                     size,
                     count,
                 } => {
-                    let msg_f = &self.fields[field_counter];
+                    if field_counter >= self.fields.len() || field_counter >= field_names.len() {
-                    let f_translated = &field_names[field_counter];
+                        return Err(MsgConversionError::ExhaustedSource);
+                    }
+
+                    let msg_f = unsafe { self.fields.get_unchecked(field_counter) };
+                    let f_translated = unsafe { field_names.get_unchecked(field_counter) };
                     field_counter += 1;
 
                     if msg_f.name != *f_translated
@@ -533,7 +548,7 @@ impl PointCloud2Msg {
         })
     }
 
-    /// Create a [`PointCloud2Msg`] from any iterable type.
+    /// Create a [`PointCloud2Msg`] from any iterable type that implements [`PointConvertible`].
     ///
     /// # Example
     /// ```
@@ -687,7 +702,7 @@ impl PointCloud2Msg {
 
                 let bytes_total = vec.len() * point_step as usize;
                 cloud.data.resize(bytes_total, u8::default());
-                let raw_data: *mut C = cloud.data.as_ptr() as *mut C;
+                let raw_data: *mut C = cloud.data.as_mut_ptr() as *mut C;
                 unsafe {
                     core::ptr::copy_nonoverlapping(
                         vec.as_ptr().cast::<u8>(),
@@ -897,7 +912,7 @@ impl<const N: usize> From<[PointData; N]> for RPCL2Point<N> {
 ///     }
 /// }
 ///
-/// impl PointConvertible<4> for MyPointXYZL {
+/// unsafe impl PointConvertible<4> for MyPointXYZL {
 ///     fn layout() -> LayoutDescription {
 ///         LayoutDescription::new(&[
 ///             LayoutField::new("x", "f32", 4),
@@ -909,7 +924,10 @@ impl<const N: usize> From<[PointData; N]> for RPCL2Point<N> {
 ///     }
 /// }
 /// ```
-pub trait PointConvertible<const N: usize>:
+/// # Safety
+/// The layout is used for raw memory interpretation, where safety can not be guaranteed by the compiler.
+/// Take care when implementing the layout, especially in combination with `#[repr]` or use the `derive` feature when possible to prevent common errors.
+pub unsafe trait PointConvertible<const N: usize>:
     From<RPCL2Point<N>> + Into<RPCL2Point<N>> + Default + Sized
 {
     fn layout() -> LayoutDescription;
@@ -1006,11 +1024,10 @@ impl PointData {
     #[inline]
     fn from_buffer(data: &[u8], offset: usize, datatype: FieldDatatype, endian: Endian) -> Self {
         debug_assert!(data.len() >= offset + datatype.size());
-        let bytes = [u8::default(); core::mem::size_of::<f64>()];
+        let mut bytes = [u8::default(); core::mem::size_of::<f64>()];
         unsafe {
             let data_ptr = data.as_ptr().add(offset);
-            let bytes_ptr = bytes.as_ptr() as *mut u8;
+            core::ptr::copy_nonoverlapping(data_ptr, bytes.as_mut_ptr(), datatype.size());
-            core::ptr::copy_nonoverlapping(data_ptr, bytes_ptr, datatype.size());
         }
 
         Self {
@@ -1448,3 +1465,216 @@ impl FromBytes for u8 {
         Self::from_le_bytes([bytes[0]])
     }
 }
+
+mod test {
+    #![allow(clippy::unwrap_used)]
+
+    use crate::prelude::*;
+
+    #[derive(Debug, Default, Clone, PartialEq)]
+    #[repr(C)]
+    struct PointA {
+        x: f32,
+        y: f32,
+        z: f32,
+        intensity: f32,
+        t: u32,
+        reflectivity: u16,
+        ring: u16,
+        ambient: u16,
+        range: u32,
+    }
+
+    impl From<RPCL2Point<9>> for PointA {
+        fn from(point: RPCL2Point<9>) -> Self {
+            Self::new(point[0].get(), point[1].get(), point[2].get())
+        }
+    }
+
+    impl From<PointA> for RPCL2Point<9> {
+        fn from(point: PointA) -> Self {
+            [
+                point.x.into(),
+                point.y.into(),
+                point.z.into(),
+                point.intensity.into(),
+                point.t.into(),
+                point.reflectivity.into(),
+                point.ring.into(),
+                point.ambient.into(),
+                point.range.into(),
+            ]
+            .into()
+        }
+    }
+
+    unsafe impl PointConvertible<9> for PointA {
+        fn layout() -> LayoutDescription {
+            LayoutDescription::new(&[
+                LayoutField::new("x", "f32", 4),
+                LayoutField::new("y", "f32", 4),
+                LayoutField::new("z", "f32", 4),
+                LayoutField::new("intensity", "f32", 4),
+                LayoutField::new("t", "u32", 4),
+                LayoutField::new("reflectivity", "u16", 2),
+                LayoutField::padding(2),
+                LayoutField::new("ring", "u16", 2),
+                LayoutField::padding(2),
+                LayoutField::new("ambient", "u16", 2),
+                LayoutField::padding(2),
+                LayoutField::new("range", "u32", 4),
+            ])
+        }
+    }
+
+    impl PointA {
+        fn new(x: f32, y: f32, z: f32) -> Self {
+            Self {
+                x,
+                y,
+                z,
+                intensity: 0.0,
+                t: 0,
+                reflectivity: 0,
+                ring: 0,
+                ambient: 0,
+                range: 0,
+            }
+        }
+    }
+
+    #[derive(Debug, Clone, Default, PartialEq)]
+    #[repr(C)]
+    struct PointB {
+        pub x: f32,
+        pub y: f32,
+        pub z: f32,
+        pub t: u32,
+    }
+
+    impl PointB {
+        fn new(x: f32, y: f32, z: f32) -> Self {
+            Self { x, y, z, t: 0 }
+        }
+    }
+
+    impl From<RPCL2Point<4>> for PointB {
+        fn from(point: RPCL2Point<4>) -> Self {
+            Self::new(point[0].get(), point[1].get(), point[2].get())
+        }
+    }
+
+    impl From<PointB> for RPCL2Point<4> {
+        fn from(point: PointB) -> Self {
+            [
+                point.x.into(),
+                point.y.into(),
+                point.z.into(),
+                point.t.into(),
+            ]
+            .into()
+        }
+    }
+
+    unsafe impl PointConvertible<4> for PointB {
+        fn layout() -> LayoutDescription {
+            LayoutDescription::new(&[
+                LayoutField::new("x", "f32", 4),
+                LayoutField::new("y", "f32", 4),
+                LayoutField::new("z", "f32", 4),
+                LayoutField::new("t", "u32", 4),
+            ])
+        }
+    }
+
+    #[derive(Debug, Clone, Default, PartialEq)]
+    #[repr(C)]
+    struct PointD {
+        x: f32,
+        y: f32,
+        z: f32,
+        t: u32,
+        ring: u16,
+        range: u32,
+        signal: u16,
+        reflectivity: u16,
+        near_ir: u16,
+    }
+
+    impl From<RPCL2Point<9>> for PointD {
+        fn from(point: RPCL2Point<9>) -> Self {
+            Self::new(point[0].get(), point[1].get(), point[2].get())
+        }
+    }
+
+    impl From<PointD> for RPCL2Point<9> {
+        fn from(point: PointD) -> Self {
+            [
+                point.x.into(),
+                point.y.into(),
+                point.z.into(),
+                point.t.into(),
+                point.ring.into(),
+                point.range.into(),
+                point.signal.into(),
+                point.reflectivity.into(),
+                point.near_ir.into(),
+            ]
+            .into()
+        }
+    }
+
+    unsafe impl PointConvertible<9> for PointD {
+        fn layout() -> LayoutDescription {
+            LayoutDescription::new(&[
+                LayoutField::new("x", "f32", 4),
+                LayoutField::new("y", "f32", 4),
+                LayoutField::new("z", "f32", 4),
+                LayoutField::new("t", "u32", 4),
+                LayoutField::new("ring", "u16", 2),
+                LayoutField::padding(2),
+                LayoutField::new("range", "u32", 4),
+                LayoutField::new("signal", "u16", 2),
+                LayoutField::padding(2),
+                LayoutField::new("reflectivity", "u16", 2),
+                LayoutField::padding(2),
+                LayoutField::new("near_ir", "u16", 2),
+                LayoutField::padding(2),
+            ])
+        }
+    }
+
+    impl PointD {
+        fn new(x: f32, y: f32, z: f32) -> Self {
+            Self {
+                x,
+                y,
+                z,
+                t: 0,
+                ring: 0,
+                range: 0,
+                signal: 0,
+                reflectivity: 0,
+                near_ir: 0,
+            }
+        }
+    }
+
+    #[test]
+    fn subtype_iterator_fallback() {
+        let cloud_a = PointCloud2Msg::try_from_iter(vec![
+            PointA::new(1.0, 2.0, 3.0),
+            PointA::new(4.0, 5.0, 6.0),
+            PointA::new(7.0, 8.0, 9.0),
+        ])
+        .unwrap();
+
+        let cloud_c: PointB = cloud_a.clone().try_into_iter().unwrap().next().unwrap();
+        assert_eq!(cloud_c, PointB::new(1.0, 2.0, 3.0));
+
+        let cloud_b: Vec<PointB> = cloud_a.try_into_vec().unwrap();
+        assert_eq!(cloud_b[0], PointB::new(1.0, 2.0, 3.0));
+        assert_eq!(cloud_b[1], PointB::new(4.0, 5.0, 6.0));
+        assert_eq!(cloud_b[2], PointB::new(7.0, 8.0, 9.0));
+    }
+}

rpcl2/src/points.rs

@@ -1,7 +1,10 @@
 //! Predefined point types commonly used in ROS.
 use crate::{LayoutDescription, LayoutField, PointConvertible, RPCL2Point};
 
-/// A packed RGB color encoding as used in ROS tools.
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+/// Packed RGB color encoding as used in ROS tools.
 #[derive(Clone, Copy)]
 #[repr(C, align(4))]
 pub union RGB {
@@ -9,6 +12,29 @@ pub union RGB {
     unpacked: [u8; 4], // Padding
 }
 
+#[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+impl<'de> Deserialize<'de> for RGB {
+    fn deserialize<D>(deserializer: D) -> Result<RGB, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let packed = f32::deserialize(deserializer)?;
+        Ok(RGB::new_from_packed_f32(packed))
+    }
+}
+
+#[cfg(feature = "serde")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+impl Serialize for RGB {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        f32::from(*self).serialize(serializer)
+    }
+}
+
 unsafe impl Send for RGB {}
 unsafe impl Sync for RGB {}
 
@@ -103,10 +129,10 @@ impl From<f32> for RGB {
     }
 }
 
-/// Predefined point type commonly used in ROS with PCL.
+/// 3D point with x, y, z coordinates, commonly used in ROS with PCL.
-/// This is a 3D point with x, y, z coordinates.
 #[derive(Clone, Debug, PartialEq, Copy, Default)]
 #[repr(C, align(16))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointXYZ {
     pub x: f32,
     pub y: f32,
@@ -114,6 +140,7 @@ pub struct PointXYZ {
 }
 
 #[cfg(feature = "nalgebra")]
+#[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
 impl From<nalgebra::Point3<f32>> for PointXYZ {
     fn from(point: nalgebra::Point3<f32>) -> Self {
         Self {
@@ -125,12 +152,73 @@ impl From<nalgebra::Point3<f32>> for PointXYZ {
 }
 
 #[cfg(feature = "nalgebra")]
+#[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+impl From<&nalgebra::Point3<f32>> for PointXYZ {
+    fn from(point: &nalgebra::Point3<f32>) -> Self {
+        Self {
+            x: point.x,
+            y: point.y,
+            z: point.z,
+        }
+    }
+}
+
+#[cfg(feature = "nalgebra")]
+#[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+impl From<nalgebra::Point3<f64>> for PointXYZ {
+    fn from(point: nalgebra::Point3<f64>) -> Self {
+        Self {
+            x: point.x as f32,
+            y: point.y as f32,
+            z: point.z as f32,
+        }
+    }
+}
+
+#[cfg(feature = "nalgebra")]
+#[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+impl From<&nalgebra::Point3<f64>> for PointXYZ {
+    fn from(point: &nalgebra::Point3<f64>) -> Self {
+        Self {
+            x: point.x as f32,
+            y: point.y as f32,
+            z: point.z as f32,
+        }
+    }
+}
+
+#[cfg(feature = "nalgebra")]
+#[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
 impl From<PointXYZ> for nalgebra::Point3<f32> {
     fn from(point: PointXYZ) -> Self {
         nalgebra::Point3::new(point.x, point.y, point.z)
     }
 }
 
+#[cfg(feature = "nalgebra")]
+#[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+impl From<&PointXYZ> for nalgebra::Point3<f32> {
+    fn from(point: &PointXYZ) -> Self {
+        nalgebra::Point3::new(point.x, point.y, point.z)
+    }
+}
+
+#[cfg(feature = "nalgebra")]
+#[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+impl From<PointXYZ> for nalgebra::Point3<f64> {
+    fn from(point: PointXYZ) -> Self {
+        nalgebra::Point3::new(point.x as f64, point.y as f64, point.z as f64)
+    }
+}
+
+#[cfg(feature = "nalgebra")]
+#[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+impl From<&PointXYZ> for nalgebra::Point3<f64> {
+    fn from(point: &PointXYZ) -> Self {
+        nalgebra::Point3::new(point.x as f64, point.y as f64, point.z as f64)
+    }
+}
+
 impl PointXYZ {
     #[must_use]
     pub fn new(x: f32, y: f32, z: f32) -> Self {
@@ -139,9 +227,22 @@ impl PointXYZ {
 
     /// Get the coordinates as a nalgebra Point3.
     #[cfg(feature = "nalgebra")]
+    #[deprecated(since = "0.5.2", note = "please use `xyz_f32` instead")]
     #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
     pub fn xyz(&self) -> nalgebra::Point3<f32> {
-        nalgebra::Point3::new(self.x, self.y, self.z)
+        self.xyz_f32()
+    }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f32(&self) -> nalgebra::Point3<f32> {
+        self.into()
+    }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f64(&self) -> nalgebra::Point3<f64> {
+        self.into()
     }
 }
 
@@ -160,7 +261,7 @@ impl From<PointXYZ> for RPCL2Point<3> {
     }
 }
 
-impl PointConvertible<3> for PointXYZ {
+unsafe impl PointConvertible<3> for PointXYZ {
     fn layout() -> LayoutDescription {
         LayoutDescription::new(&[
             LayoutField::new("x", "f32", 4),
@@ -171,10 +272,10 @@ impl PointConvertible<3> for PointXYZ {
     }
 }
 
-/// Predefined point type commonly used in ROS with PCL.
+/// 3D point with x, y, z coordinates and an intensity value, commonly used in ROS with PCL.
-/// This is a 3D point with x, y, z coordinates and an intensity value.
 #[derive(Clone, Debug, PartialEq, Copy, Default)]
 #[repr(C, align(16))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointXYZI {
     pub x: f32,
     pub y: f32,
@@ -189,10 +290,23 @@ impl PointXYZI {
 
     /// Get the coordinates as a nalgebra Point3.
     #[cfg(feature = "nalgebra")]
+    #[deprecated(since = "0.5.2", note = "please use `xyz_f32` instead")]
     #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
     pub fn xyz(&self) -> nalgebra::Point3<f32> {
+        self.xyz_f32()
+    }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f32(&self) -> nalgebra::Point3<f32> {
         nalgebra::Point3::new(self.x, self.y, self.z)
     }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f64(&self) -> nalgebra::Point3<f64> {
+        nalgebra::Point3::new(self.x as f64, self.y as f64, self.z as f64)
+    }
 }
 
 unsafe impl Send for PointXYZI {}
@@ -221,7 +335,7 @@ impl From<PointXYZI> for RPCL2Point<4> {
     }
 }
 
-impl PointConvertible<4> for PointXYZI {
+unsafe impl PointConvertible<4> for PointXYZI {
     fn layout() -> LayoutDescription {
         LayoutDescription::new(&[
             LayoutField::new("x", "f32", 4),
@@ -232,10 +346,10 @@ impl PointConvertible<4> for PointXYZI {
     }
 }
 
-/// Predefined point type commonly used in ROS with PCL.
+/// 3D point with x, y, z coordinates and a label, commonly used in ROS with PCL.
-/// This is a 3D point with x, y, z coordinates and a label.
 #[derive(Clone, Debug, PartialEq, Copy, Default)]
 #[repr(C, align(16))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointXYZL {
     pub x: f32,
     pub y: f32,
@@ -250,10 +364,23 @@ impl PointXYZL {
 
     /// Get the coordinates as a nalgebra Point3.
     #[cfg(feature = "nalgebra")]
+    #[deprecated(since = "0.5.2", note = "please use `xyz_f32` instead")]
     #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
     pub fn xyz(&self) -> nalgebra::Point3<f32> {
+        self.xyz_f32()
+    }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f32(&self) -> nalgebra::Point3<f32> {
         nalgebra::Point3::new(self.x, self.y, self.z)
     }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f64(&self) -> nalgebra::Point3<f64> {
+        nalgebra::Point3::new(self.x as f64, self.y as f64, self.z as f64)
+    }
 }
 
 unsafe impl Send for PointXYZL {}
@@ -282,7 +409,7 @@ impl From<PointXYZL> for RPCL2Point<4> {
     }
 }
 
-impl PointConvertible<4> for PointXYZL {
+unsafe impl PointConvertible<4> for PointXYZL {
     fn layout() -> LayoutDescription {
         LayoutDescription::new(&[
             LayoutField::new("x", "f32", 4),
@@ -293,10 +420,10 @@ impl PointConvertible<4> for PointXYZL {
     }
 }
 
-/// Predefined point type commonly used in ROS with PCL.
+/// 3D point with x, y, z coordinates and an RGB color value, commonly used in ROS with PCL.
-/// This is a 3D point with x, y, z coordinates and an RGB color value.
 #[derive(Clone, Debug, PartialEq, Copy, Default)]
 #[repr(C, align(16))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointXYZRGB {
     pub x: f32,
     pub y: f32,
@@ -328,10 +455,23 @@ impl PointXYZRGB {
 
     /// Get the coordinates as a nalgebra Point3.
     #[cfg(feature = "nalgebra")]
+    #[deprecated(since = "0.5.2", note = "please use `xyz_f32` instead")]
     #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
     pub fn xyz(&self) -> nalgebra::Point3<f32> {
+        self.xyz_f32()
+    }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f32(&self) -> nalgebra::Point3<f32> {
         nalgebra::Point3::new(self.x, self.y, self.z)
     }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f64(&self) -> nalgebra::Point3<f64> {
+        nalgebra::Point3::new(self.x as f64, self.y as f64, self.z as f64)
+    }
 }
 
 unsafe impl Send for PointXYZRGB {}
@@ -360,7 +500,7 @@ impl From<PointXYZRGB> for RPCL2Point<4> {
     }
 }
 
-impl PointConvertible<4> for PointXYZRGB {
+unsafe impl PointConvertible<4> for PointXYZRGB {
     fn layout() -> LayoutDescription {
         LayoutDescription::new(&[
             LayoutField::new("x", "f32", 4),
@@ -371,11 +511,11 @@ impl PointConvertible<4> for PointXYZRGB {
     }
 }
 
-/// Predefined point type commonly used in ROS with PCL.
+/// 3D point with x, y, z coordinates and an RGBA color value, commonly used in ROS with PCL.
-/// This is a 3D point with x, y, z coordinates and an RGBA color value.
 /// The alpha channel is commonly used as padding but this crate uses every channel and no padding.
 #[derive(Clone, Debug, PartialEq, Copy, Default)]
 #[repr(C, align(16))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointXYZRGBA {
     pub x: f32,
     pub y: f32,
@@ -408,10 +548,23 @@ impl PointXYZRGBA {
 
     /// Get the coordinates as a nalgebra Point3.
     #[cfg(feature = "nalgebra")]
+    #[deprecated(since = "0.5.2", note = "please use `xyz_f32` instead")]
     #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
     pub fn xyz(&self) -> nalgebra::Point3<f32> {
+        self.xyz_f32()
+    }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f32(&self) -> nalgebra::Point3<f32> {
         nalgebra::Point3::new(self.x, self.y, self.z)
     }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f64(&self) -> nalgebra::Point3<f64> {
+        nalgebra::Point3::new(self.x as f64, self.y as f64, self.z as f64)
+    }
 }
 
 unsafe impl Send for PointXYZRGBA {}
@@ -442,7 +595,7 @@ impl From<PointXYZRGBA> for RPCL2Point<5> {
     }
 }
 
-impl PointConvertible<5> for PointXYZRGBA {
+unsafe impl PointConvertible<5> for PointXYZRGBA {
     fn layout() -> LayoutDescription {
         LayoutDescription::new(&[
             LayoutField::new("x", "f32", 4),
@@ -455,10 +608,10 @@ impl PointConvertible<5> for PointXYZRGBA {
     }
 }
 
-/// Predefined point type commonly used in ROS with PCL.
+/// 3D point with x, y, z coordinates, an RGB color value and a normal vector, commonly used in ROS with PCL.
-/// This is a 3D point with x, y, z coordinates, an RGB color value and a normal vector.
 #[derive(Clone, Debug, PartialEq, Copy, Default)]
 #[repr(C, align(16))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointXYZRGBNormal {
     pub x: f32,
     pub y: f32,
@@ -508,10 +661,23 @@ impl PointXYZRGBNormal {
 
     /// Get the coordinates as a nalgebra Point3.
     #[cfg(feature = "nalgebra")]
+    #[deprecated(since = "0.5.2", note = "please use `xyz_f32` instead")]
     #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
     pub fn xyz(&self) -> nalgebra::Point3<f32> {
+        self.xyz_f32()
+    }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f32(&self) -> nalgebra::Point3<f32> {
         nalgebra::Point3::new(self.x, self.y, self.z)
     }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f64(&self) -> nalgebra::Point3<f64> {
+        nalgebra::Point3::new(self.x as f64, self.y as f64, self.z as f64)
+    }
 }
 
 unsafe impl Send for PointXYZRGBNormal {}
@@ -546,7 +712,7 @@ impl From<PointXYZRGBNormal> for RPCL2Point<7> {
     }
 }
 
-impl PointConvertible<7> for PointXYZRGBNormal {
+unsafe impl PointConvertible<7> for PointXYZRGBNormal {
     fn layout() -> LayoutDescription {
         LayoutDescription::new(&[
             LayoutField::new("x", "f32", 4),
@@ -561,10 +727,10 @@ impl PointConvertible<7> for PointXYZRGBNormal {
     }
 }
 
-/// Predefined point type commonly used in ROS with PCL.
+/// 3D point with x, y, z coordinates, an intensity value and a normal vector, commonly used in ROS with PCL.
-/// This is a 3D point with x, y, z coordinates, an intensity value and a normal vector.
 #[derive(Clone, Debug, PartialEq, Copy, Default)]
 #[repr(C, align(16))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointXYZINormal {
     pub x: f32,
     pub y: f32,
@@ -599,10 +765,23 @@ impl PointXYZINormal {
 
     /// Get the coordinates as a nalgebra Point3.
     #[cfg(feature = "nalgebra")]
+    #[deprecated(since = "0.5.2", note = "please use `xyz_f32` instead")]
     #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
     pub fn xyz(&self) -> nalgebra::Point3<f32> {
+        self.xyz_f32()
+    }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f32(&self) -> nalgebra::Point3<f32> {
         nalgebra::Point3::new(self.x, self.y, self.z)
     }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f64(&self) -> nalgebra::Point3<f64> {
+        nalgebra::Point3::new(self.x as f64, self.y as f64, self.z as f64)
+    }
 }
 
 unsafe impl Send for PointXYZINormal {}
@@ -637,7 +816,7 @@ impl From<PointXYZINormal> for RPCL2Point<7> {
     }
 }
 
-impl PointConvertible<7> for PointXYZINormal {
+unsafe impl PointConvertible<7> for PointXYZINormal {
     fn layout() -> LayoutDescription {
         LayoutDescription::new(&[
             LayoutField::new("x", "f32", 4),
@@ -652,10 +831,10 @@ impl PointConvertible<7> for PointXYZINormal {
     }
 }
 
-/// Predefined point type commonly used in ROS with PCL.
+/// 3D point with x, y, z coordinates and a label, commonly used in ROS with PCL.
-/// This is a 3D point with x, y, z coordinates and a label.
 #[derive(Clone, Debug, PartialEq, Copy, Default)]
 #[repr(C, align(16))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointXYZRGBL {
     pub x: f32,
     pub y: f32,
@@ -697,10 +876,23 @@ impl PointXYZRGBL {
 
     /// Get the coordinates as a nalgebra Point3.
     #[cfg(feature = "nalgebra")]
+    #[deprecated(since = "0.5.2", note = "please use `xyz_f32` instead")]
     #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
     pub fn xyz(&self) -> nalgebra::Point3<f32> {
+        self.xyz_f32()
+    }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f32(&self) -> nalgebra::Point3<f32> {
         nalgebra::Point3::new(self.x, self.y, self.z)
     }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f64(&self) -> nalgebra::Point3<f64> {
+        nalgebra::Point3::new(self.x as f64, self.y as f64, self.z as f64)
+    }
 }
 
 impl From<RPCL2Point<5>> for PointXYZRGBL {
@@ -728,7 +920,7 @@ impl From<PointXYZRGBL> for RPCL2Point<5> {
     }
 }
 
-impl PointConvertible<5> for PointXYZRGBL {
+unsafe impl PointConvertible<5> for PointXYZRGBL {
     fn layout() -> LayoutDescription {
         LayoutDescription::new(&[
             LayoutField::new("x", "f32", 4),
@@ -741,10 +933,10 @@ impl PointConvertible<5> for PointXYZRGBL {
     }
 }
 
-/// Predefined point type commonly used in ROS with PCL.
+/// 3D point with x, y, z coordinates and a normal vector, commonly used in ROS with PCL.
-/// This is a 3D point with x, y, z coordinates and a normal vector.
 #[derive(Clone, Debug, PartialEq, Copy, Default)]
 #[repr(C, align(16))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointXYZNormal {
     pub x: f32,
     pub y: f32,
@@ -769,10 +961,23 @@ impl PointXYZNormal {
 
     /// Get the coordinates as a nalgebra Point3.
     #[cfg(feature = "nalgebra")]
+    #[deprecated(since = "0.5.2", note = "please use `xyz_f32` instead")]
     #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
     pub fn xyz(&self) -> nalgebra::Point3<f32> {
+        self.xyz_f32()
+    }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f32(&self) -> nalgebra::Point3<f32> {
         nalgebra::Point3::new(self.x, self.y, self.z)
     }
+
+    #[cfg(feature = "nalgebra")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "nalgebra")))]
+    pub fn xyz_f64(&self) -> nalgebra::Point3<f64> {
+        nalgebra::Point3::new(self.x as f64, self.y as f64, self.z as f64)
+    }
 }
 
 unsafe impl Send for PointXYZNormal {}
@@ -805,7 +1010,7 @@ impl From<PointXYZNormal> for RPCL2Point<6> {
     }
 }
 
-impl PointConvertible<6> for PointXYZNormal {
+unsafe impl PointConvertible<6> for PointXYZNormal {
     fn layout() -> LayoutDescription {
         LayoutDescription::new(&[
             LayoutField::new("x", "f32", 4),

rpcl2/src/ros.rs

@@ -25,16 +25,26 @@
 
 use alloc::string::String;
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 /// [Time](https://docs.ros2.org/latest/api/builtin_interfaces/msg/Time.html) representation for ROS messages.
-#[cfg(not(any(feature = "rclrs_msg")))]
+#[derive(Clone, Debug, Default, Copy)]
-#[derive(Clone, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct TimeMsg {
     pub sec: i32,
     pub nanosec: u32,
 }
 
-#[cfg(feature = "rclrs_msg")]
+#[cfg(feature = "ros2-interfaces-jazzy")]
-pub use builtin_interfaces::msg::Time as TimeMsg;
+impl From<ros2_interfaces_jazzy::builtin_interfaces::msg::Time> for TimeMsg {
+    fn from(time: ros2_interfaces_jazzy::builtin_interfaces::msg::Time) -> Self {
+        Self {
+            sec: time.sec,
+            nanosec: time.nanosec,
+        }
+    }
+}
 
 #[cfg(feature = "rosrust_msg")]
 impl From<rosrust::Time> for TimeMsg {
@@ -48,14 +58,27 @@ impl From<rosrust::Time> for TimeMsg {
 
 /// Represents the [header of a ROS message](https://docs.ros2.org/latest/api/std_msgs/msg/Header.html).
 #[derive(Clone, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct HeaderMsg {
     pub seq: u32,
     pub stamp: TimeMsg,
     pub frame_id: String,
 }
 
+#[cfg(feature = "ros2-interfaces-jazzy")]
+impl From<ros2_interfaces_jazzy::std_msgs::msg::Header> for HeaderMsg {
+    fn from(header: ros2_interfaces_jazzy::std_msgs::msg::Header) -> Self {
+        Self {
+            seq: 0,
+            stamp: header.stamp.into(),
+            frame_id: header.frame_id,
+        }
+    }
+}
+
 /// Describing a point encoded in the byte buffer of a PointCloud2 message. See the [official message description](https://docs.ros2.org/latest/api/sensor_msgs/msg/PointField.html) for more information.
 #[derive(Clone, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PointFieldMsg {
     pub name: String,
     pub offset: u32,
@@ -74,13 +97,16 @@ impl Default for PointFieldMsg {
     }
 }
 
-#[cfg(feature = "rclrs_msg")]
+#[cfg(feature = "ros2-interfaces-jazzy")]
-impl From<sensor_msgs::msg::PointCloud2> for crate::PointCloud2Msg {
+impl From<ros2_interfaces_jazzy::sensor_msgs::msg::PointCloud2> for crate::PointCloud2Msg {
-    fn from(msg: sensor_msgs::msg::PointCloud2) -> Self {
+    fn from(msg: ros2_interfaces_jazzy::sensor_msgs::msg::PointCloud2) -> Self {
         Self {
             header: HeaderMsg {
                 seq: 0,
-                stamp: msg.header.stamp,
+                stamp: TimeMsg {
+                    sec: msg.header.stamp.sec,
+                    nanosec: msg.header.stamp.nanosec,
+                },
                 frame_id: msg.header.frame_id,
             },
             dimensions: crate::CloudDimensions {
@@ -114,12 +140,15 @@ impl From<sensor_msgs::msg::PointCloud2> for crate::PointCloud2Msg {
     }
 }
 
-#[cfg(feature = "rclrs_msg")]
+#[cfg(feature = "ros2-interfaces-jazzy")]
-impl From<crate::PointCloud2Msg> for sensor_msgs::msg::PointCloud2 {
+impl From<crate::PointCloud2Msg> for ros2_interfaces_jazzy::sensor_msgs::msg::PointCloud2 {
     fn from(msg: crate::PointCloud2Msg) -> Self {
-        sensor_msgs::msg::PointCloud2 {
+        ros2_interfaces_jazzy::sensor_msgs::msg::PointCloud2 {
-            header: std_msgs::msg::Header {
+            header: ros2_interfaces_jazzy::std_msgs::msg::Header {
-                stamp: msg.header.stamp,
+                stamp: ros2_interfaces_jazzy::builtin_interfaces::msg::Time {
+                    sec: msg.header.stamp.sec,
+                    nanosec: msg.header.stamp.nanosec,
+                },
                 frame_id: msg.header.frame_id,
             },
             height: msg.dimensions.height,
@@ -127,12 +156,14 @@ impl From<crate::PointCloud2Msg> for sensor_msgs::msg::PointCloud2 {
             fields: msg
                 .fields
                 .into_iter()
-                .map(|field| sensor_msgs::msg::PointField {
+                .map(
+                    |field| ros2_interfaces_jazzy::sensor_msgs::msg::PointField {
                         name: field.name,
                         offset: field.offset,
                         datatype: field.datatype,
                         count: field.count,
-                })
+                    },
+                )
                 .collect(),
             is_bigendian: match msg.endian {
                 crate::Endian::Big => true,

rpcl2/tests/Dockerfile_r2r_galactic

@@ -18,5 +18,5 @@ RUN curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | bash -s -- -y
 RUN echo 'source $HOME/.cargo/env' >> $HOME/.bashrc
 
 COPY . /r2r
-RUN chmod +x /r2r/tests/r2r_test.bash
+RUN chmod +x /r2r/rpcl2/tests/r2r_test.bash
-ENTRYPOINT [ "/r2r/tests/r2r_test.bash" ]
+ENTRYPOINT [ "/r2r/rpcl2/tests/r2r_test.bash" ]

rpcl2/tests/Dockerfile_r2r_humble

@@ -18,5 +18,5 @@ RUN curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | bash -s -- -y
 RUN echo 'source $HOME/.cargo/env' >> $HOME/.bashrc
 
 COPY . /r2r
-RUN chmod +x /r2r/tests/r2r_test.bash
+RUN chmod +x /r2r/rpcl2/tests/r2r_test.bash
-ENTRYPOINT [ "/r2r/tests/r2r_test.bash" ]
+ENTRYPOINT [ "/r2r/rpcl2/tests/r2r_test.bash" ]

rpcl2/tests/Dockerfile_r2r_iron

@@ -18,5 +18,5 @@ RUN curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | bash -s -- -y
 RUN echo 'source $HOME/.cargo/env' >> $HOME/.bashrc
 
 COPY . /r2r
-RUN chmod +x /r2r/tests/r2r_test.bash
+RUN chmod +x /r2r/rpcl2/tests/r2r_test.bash
-ENTRYPOINT [ "/r2r/tests/r2r_test.bash" ]
+ENTRYPOINT [ "/r2r/rpcl2/tests/r2r_test.bash" ]

rpcl2/tests/Dockerfile_r2r_jazzy

@@ -0,0 +1,22 @@
+# syntax=docker/dockerfile:1
+FROM ros:jazzy
+
+# Update default packages
+RUN apt-get update
+
+# Get Ubuntu packages
+RUN apt-get install -y \
+    build-essential \
+    curl \
+    libclang-dev
+
+# Get ros test messages
+RUN apt-get install -y ros-jazzy-test-msgs ros-jazzy-example-interfaces
+
+# Get Rust
+RUN curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | bash -s -- -y
+RUN echo 'source $HOME/.cargo/env' >> $HOME/.bashrc
+
+COPY . /r2r
+RUN chmod +x /r2r/rpcl2/tests/r2r_test.bash
+ENTRYPOINT [ "/r2r/rpcl2/tests/r2r_test.bash" ]

rpcl2/tests/Dockerfile_rclrs_humble

@@ -30,5 +30,5 @@ COPY . .
 WORKDIR /ros2_rust_build
 RUN . $HOME/.cargo/env && . /opt/ros/humble/setup.sh && colcon build
 
-RUN chmod +x /ros2_rust_build/src/ros_pointcloud2_tests/tests/rclrs_test.bash
+RUN chmod +x /ros2_rust_build/src/ros_pointcloud2_tests/rpcl2/tests/rclrs_test.bash
-ENTRYPOINT [ "/ros2_rust_build/src/ros_pointcloud2_tests/tests/rclrs_test.bash" ]
+ENTRYPOINT [ "/ros2_rust_build/src/ros_pointcloud2_tests/rpcl2/tests/rclrs_test.bash" ]

rpcl2/tests/Dockerfile_rclrs_iron

@@ -30,5 +30,5 @@ COPY . .
 WORKDIR /ros2_rust_build
 RUN . $HOME/.cargo/env && . /opt/ros/iron/setup.sh && colcon build
 
-RUN chmod +x /ros2_rust_build/src/ros_pointcloud2_tests/tests/rclrs_test.bash
+RUN chmod +x /ros2_rust_build/src/ros_pointcloud2_tests/rpcl2/tests/rclrs_test.bash
-ENTRYPOINT [ "/ros2_rust_build/src/ros_pointcloud2_tests/tests/rclrs_test.bash" ]
+ENTRYPOINT [ "/ros2_rust_build/src/ros_pointcloud2_tests/rpcl2/tests/rclrs_test.bash" ]

rpcl2/tests/Dockerfile_rclrs_jazzy

@@ -0,0 +1,34 @@
+# syntax=docker/dockerfile:1
+FROM ros:jazzy
+
+# Update default packages
+RUN apt-get update
+
+# Get Ubuntu packages
+RUN apt-get install -y \
+    build-essential \
+    curl \
+    libclang-dev \
+    git \
+    python3-pip \
+    python3-vcstool
+
+# Get Rust
+RUN curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | bash -s -- -y
+RUN echo 'source $HOME/.cargo/env' >> $HOME/.bashrc
+RUN . $HOME/.cargo/env && cargo install --debug cargo-ament-build
+RUN pip install git+https://github.com/colcon/colcon-cargo.git
+RUN pip install git+https://github.com/colcon/colcon-ros-cargo.git
+
+WORKDIR /ros2_rust_build
+RUN git clone https://github.com/ros2-rust/ros2_rust.git src/ros2_rust
+RUN vcs import src < src/ros2_rust/ros2_rust_jazzy.repos
+
+WORKDIR /ros2_rust_build/src/ros_pointcloud2_tests
+COPY . .
+
+WORKDIR /ros2_rust_build
+RUN . $HOME/.cargo/env && . /opt/ros/jazzy/setup.sh && colcon build
+
+RUN chmod +x /ros2_rust_build/src/ros_pointcloud2_tests/rpcl2/tests/rclrs_test.bash
+ENTRYPOINT [ "/ros2_rust_build/src/ros_pointcloud2_tests/rpcl2/tests/rclrs_test.bash" ]

rpcl2/tests/e2e_test.rs

@@ -1,3 +1,4 @@
+use pretty_assertions::assert_eq;
 use ros_pointcloud2::prelude::*;
 
 #[cfg(feature = "derive")]
@@ -55,6 +56,19 @@ fn write_cloud() {
     let msg = PointCloud2Msg::try_from_iter(cloud);
     assert!(msg.is_ok());
 }
+/*
+#[test]
+fn collect_vec() {
+    let cloud = vec![
+        PointXYZ::new(0.0, 1.0, 5.0),
+        PointXYZ::new(1.0, 1.5, 5.0),
+        PointXYZ::new(1.3, 1.6, 5.7),
+        PointXYZ::new(f32::MAX, f32::MIN, f32::MAX),
+    ]
+    .into_iter();
+
+    let msg: Result<PointCloud2Msg, MsgConversionError> = cloud.collect();
+}*/
 
 #[test]
 fn write_cloud_from_vec() {
@@ -130,7 +144,7 @@ fn conv_cloud_par_par_iter() {
 #[cfg(feature = "derive")]
 fn custom_xyz_f32() {
     #[derive(Debug, PartialEq, Clone, Default)]
-    #[repr(C)]
+    #[repr(C, align(4))]
     struct CustomPoint {
         x: f32,
         y: f32,
@@ -153,7 +167,7 @@ fn custom_xyz_f32() {
         }
     }
 
-    impl PointConvertible<3> for CustomPoint {
+    unsafe impl PointConvertible<3> for CustomPoint {
         fn layout() -> LayoutDescription {
             LayoutDescription::new(&[
                 LayoutField::new("x", "f32", 4),
@@ -215,7 +229,7 @@ fn custom_xyzi_f32() {
     ];
 
     #[derive(Debug, PartialEq, Clone, Default)]
-    #[repr(C)]
+    #[repr(C, align(4))]
     struct CustomPointXYZI {
         x: f32,
         y: f32,
@@ -246,7 +260,7 @@ fn custom_xyzi_f32() {
         }
     }
 
-    impl PointConvertible<4> for CustomPointXYZI {
+    unsafe impl PointConvertible<4> for CustomPointXYZI {
         fn layout() -> LayoutDescription {
             LayoutDescription::new(&[
                 LayoutField::new("x", "f32", 4),
@@ -265,7 +279,7 @@ fn custom_xyzi_f32() {
 #[cfg(feature = "derive")]
 fn custom_rgba_f32() {
     #[derive(Debug, PartialEq, Clone, Default)]
-    #[repr(C)]
+    #[repr(C, align(4))]
     struct CustomPoint {
         x: f32,
         y: f32,
@@ -305,7 +319,7 @@ fn custom_rgba_f32() {
         }
     }
 
-    impl PointConvertible<7> for CustomPoint {
+    unsafe impl PointConvertible<7> for CustomPoint {
         fn layout() -> LayoutDescription {
             LayoutDescription::new(&[
                 LayoutField::new("x", "f32", 4),
@@ -556,7 +570,7 @@ fn write_xyzi_read_xyz_vec() {
 #[test]
 fn write_less_than_available() {
     #[derive(Debug, PartialEq, Clone, Default)]
-    #[repr(C)]
+    #[repr(C, align(4))]
     struct CustomPoint {
         x: f32,
         y: f32,
@@ -581,7 +595,7 @@ fn write_less_than_available() {
         }
     }
 
-    impl PointConvertible<3> for CustomPoint {
+    unsafe impl PointConvertible<3> for CustomPoint {
         fn layout() -> LayoutDescription {
             LayoutDescription::new(&[
                 LayoutField::new("x", "f32", 4),

rpcl2/tests/r2r_test.bash

@@ -5,6 +5,10 @@
 # run rustup to test with latest rust version
 rustup update
 
+if [ -e "/opt/ros/jazzy/setup.bash" ]; then
+    source "/opt/ros/jazzy/setup.bash"
+fi
+
 if [ -e "/opt/ros/iron/setup.bash" ]; then
     source "/opt/ros/iron/setup.bash"
 fi

rpcl2/tests/rclrs_test.bash

@@ -5,21 +5,19 @@
 # run rustup to test with latest rust version
 rustup update
 
+if [ -e "/opt/ros/jazzy/setup.bash" ]; then
+    . "/opt/ros/jazzy/setup.bash"
+fi
+
 if [ -e "/opt/ros/iron/setup.bash" ]; then
     . "/opt/ros/iron/setup.bash"
-    . "/ros2_rust_build/install/local_setup.bash"
 fi
 
 if [ -e "/opt/ros/humble/setup.bash" ]; then
     . "/opt/ros/humble/setup.bash"
-    . "/ros2_rust_build/install/local_setup.bash"
 fi
 
-if [ -e "/opt/ros/galactic/setup.bash" ]; then
-    . "/opt/ros/galactic/setup.bash"
 . "/ros2_rust_build/install/local_setup.bash"
-fi
-
 cd /ros2_rust_build/src/ros_pointcloud2_tests/ || exit
 
 "$@"

rpcl2/tests/ros2-interfaces-jazzy_test.rs

@@ -1,9 +1,9 @@
-#[cfg(feature = "rclrs_msg")]
+#[cfg(feature = "ros2-interfaces-jazzy")]
 #[test]
-fn convertxyz_rclrs_msg() {
+fn convertxyz_ros2_interfaces_jazzy_msg() {
     use ros_pointcloud2::{points::PointXYZ, PointCloud2Msg};
 
-    use sensor_msgs::msg::PointCloud2;
+    use ros2_interfaces_jazzy::sensor_msgs::msg::PointCloud2;
 
     let cloud = vec![
         PointXYZ {
@@ -24,8 +24,8 @@ fn convertxyz_rclrs_msg() {
     ];
     let copy = cloud.clone();
     let internal_cloud = PointCloud2Msg::try_from_iter(cloud).unwrap();
-    let rclrs_msg_cloud: PointCloud2 = internal_cloud.into();
+    let ros2_msg_cloud: PointCloud2 = internal_cloud.into();
-    let convert_back_internal: PointCloud2Msg = rclrs_msg_cloud.into();
+    let convert_back_internal: PointCloud2Msg = ros2_msg_cloud.into();
     let to_convert = convert_back_internal.try_into_iter().unwrap();
     let back_to_type = to_convert.collect::<Vec<PointXYZ>>();
     assert_eq!(copy, back_to_type);