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 run r2r_galactic cargo test --features r2r_msg,derive,nalgebra,rayon
+      - 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,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 run r2r_humble cargo test --features r2r_msg,derive,nalgebra,rayon
+      - 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,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 run r2r_iron cargo test --features r2r_msg,derive,nalgebra,rayon
+      - 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,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 run rclrs_humble cargo test --features derive,nalgebra,rayon
+      - run: docker build . --file ./rpcl2/tests/Dockerfile_rclrs_humble --tag rclrs_humble
+      - 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 run rclrs_iron cargo test --features derive,nalgebra,rayon
+      - run: docker build . --file ./rpcl2/tests/Dockerfile_rclrs_iron --tag rclrs_iron
+      - 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
-      - name: Install latest Rust
-        run: |
-          curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh -s -- -y
-          rustc --version
-          cargo --version
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
       - name: Linting
-        run: cargo clippy --all-targets --features derive,nalgebra,rayon -- -D warnings
-      - name: Tests
-        run: cargo test --features derive,nalgebra,rayon
-      - name: no_std Tests
-        run: cargo test --no-default-features --features nalgebra
+        run: cargo clippy --all-targets --features derive,nalgebra,rayon,serde -- -D warnings
+      - name: Build examples with features
+        run: cargo build --examples --features derive,nalgebra,rayon,serde,ros2-interfaces-jazzy
+      - name: Test library
+        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]
-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"
+[workspace]
 
-[dependencies]
-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 }
+members = [ "derive-test","rpcl2", "rpcl2-derive"]
 
-sensor_msgs = { version = "*", optional = true }
-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"]
+resolver = "2"

LICENSE-APACHE

@@ -1,201 +1,176 @@
-i                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
 
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
-   1. Definitions.
+1. Definitions.
 
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
 
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
 
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
 
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
 
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
 
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
 
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
 
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
 
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
 
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
 
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
 
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
 
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
 
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
+   (a) You must give any other recipients of the Work or
+   Derivative Works a copy of this License; and
 
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
+   (b) You must cause any modified files to carry prominent notices
+   stating that You changed the files; and
 
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
+   (c) You must retain, in the Source form of any Derivative Works
+   that You distribute, all copyright, patent, trademark, and
+   attribution notices from the Source form of the Work,
+   excluding those notices that do not pertain to any part of
+   the Derivative Works; and
 
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
+   (d) If the Work includes a "NOTICE" text file as part of its
+   distribution, then any Derivative Works that You distribute must
+   include a readable copy of the attribution notices contained
+   within such NOTICE file, excluding those notices that do not
+   pertain to any part of the Derivative Works, in at least one
+   of the following places: within a NOTICE text file distributed
+   as part of the Derivative Works; within the Source form or
+   documentation, if provided along with the Derivative Works; or,
+   within a display generated by the Derivative Works, if and
+   wherever such third-party notices normally appear. The contents
+   of the NOTICE file are for informational purposes only and
+   do not modify the License. You may add Your own attribution
+   notices within Derivative Works that You distribute, alongside
+   or as an addendum to the NOTICE text from the Work, provided
+   that such additional attribution notices cannot be construed
+   as modifying the License.
 
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
 
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
 
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
 
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
 
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
 
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   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.
+END OF TERMS AND CONDITIONS

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
-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:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of 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.
+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
 //! ```
@@ -32,9 +32,9 @@
 //!     PointXYZI::new(46.0, 5.47, 0.5, 0.1),
 //! ];
 //! let cloud_copy = cloud_points.clone(); // For equality test later.
-//!     
+//!
 //! let out_msg = PointCloud2Msg::try_from_iter(cloud_points).unwrap();
-//!     
+//!
 //! // Convert to your ROS crate message type.
 //! // let msg: r2r::sensor_msgs::msg::PointCloud2 = in_msg.into();
 //! // Publish ...
@@ -42,7 +42,7 @@
 //! // ... now incoming from a topic.
 //! // let in_msg: PointCloud2Msg = msg.into();
 //! let in_msg = out_msg;
-//!     
+//!
 //! let processed_cloud = in_msg.try_into_iter().unwrap()
 //!     .map(|point: PointXYZ| { // Define the data you want from the point.
 //!         // Some logic here.
@@ -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];
-                    let f_translated = &field_names[field_counter];
+                    if field_counter >= self.fields.len() || field_counter >= field_names.len() {
+                        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_ptr, datatype.size());
+            core::ptr::copy_nonoverlapping(data_ptr, bytes.as_mut_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.
-/// This is a 3D point with x, y, z coordinates.
+/// 3D point with x, y, z coordinates, commonly used in ROS with PCL.
 #[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.
-/// This is a 3D point with x, y, z coordinates and an intensity value.
+/// 3D point with x, y, z coordinates and an intensity value, commonly used in ROS with PCL.
 #[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.
-/// This is a 3D point with x, y, z coordinates and a label.
+/// 3D point with x, y, z coordinates and a label, commonly used in ROS with PCL.
 #[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.
-/// This is a 3D point with x, y, z coordinates and an RGB color value.
+/// 3D point with x, y, z coordinates and an RGB color value, commonly used in ROS with PCL.
 #[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.
-/// This is a 3D point with x, y, z coordinates and an RGBA color value.
+/// 3D point with x, y, z coordinates and an RGBA color value, commonly used in ROS with PCL.
 /// 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.
-/// This is a 3D point with x, y, z coordinates, an RGB color value and a normal vector.
+/// 3D point with x, y, z coordinates, an RGB color value and a normal vector, commonly used in ROS with PCL.
 #[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.
-/// This is a 3D point with x, y, z coordinates, an intensity value and a normal vector.
+/// 3D point with x, y, z coordinates, an intensity value and a normal vector, commonly used in ROS with PCL.
 #[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.
-/// This is a 3D point with x, y, z coordinates and a label.
+/// 3D point with x, y, z coordinates and a label, commonly used in ROS with PCL.
 #[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.
-/// This is a 3D point with x, y, z coordinates and a normal vector.
+/// 3D point with x, y, z coordinates and a normal vector, commonly used in ROS with PCL.
 #[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)]
+#[derive(Clone, Debug, Default, Copy)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct TimeMsg {
     pub sec: i32,
     pub nanosec: u32,
 }
 
-#[cfg(feature = "rclrs_msg")]
-pub use builtin_interfaces::msg::Time as TimeMsg;
+#[cfg(feature = "ros2-interfaces-jazzy")]
+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")]
-impl From<sensor_msgs::msg::PointCloud2> for crate::PointCloud2Msg {
-    fn from(msg: sensor_msgs::msg::PointCloud2) -> Self {
+#[cfg(feature = "ros2-interfaces-jazzy")]
+impl From<ros2_interfaces_jazzy::sensor_msgs::msg::PointCloud2> for crate::PointCloud2Msg {
+    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")]
-impl From<crate::PointCloud2Msg> for sensor_msgs::msg::PointCloud2 {
+#[cfg(feature = "ros2-interfaces-jazzy")]
+impl From<crate::PointCloud2Msg> for ros2_interfaces_jazzy::sensor_msgs::msg::PointCloud2 {
     fn from(msg: crate::PointCloud2Msg) -> Self {
-        sensor_msgs::msg::PointCloud2 {
-            header: std_msgs::msg::Header {
-                stamp: msg.header.stamp,
+        ros2_interfaces_jazzy::sensor_msgs::msg::PointCloud2 {
+            header: ros2_interfaces_jazzy::std_msgs::msg::Header {
+                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 {
-                    name: field.name,
-                    offset: field.offset,
-                    datatype: field.datatype,
-                    count: field.count,
-                })
+                .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
-ENTRYPOINT [ "/r2r/tests/r2r_test.bash" ]
+RUN chmod +x /r2r/rpcl2/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
-ENTRYPOINT [ "/r2r/tests/r2r_test.bash" ]
+RUN chmod +x /r2r/rpcl2/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
-ENTRYPOINT [ "/r2r/tests/r2r_test.bash" ]
+RUN chmod +x /r2r/rpcl2/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
-ENTRYPOINT [ "/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/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
-ENTRYPOINT [ "/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/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),
@@ -634,4 +648,4 @@ fn write_less_than_available() {
     ];
 
     convert_from_into_in_out_cloud!(write_cloud, CustomPoint, read_cloud, CustomPoint);
-}
+}

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
 
+. "/ros2_rust_build/install/local_setup.bash"
 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 convert_back_internal: PointCloud2Msg = rclrs_msg_cloud.into();
+    let ros2_msg_cloud: PointCloud2 = internal_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);