pymomentum-cpu 0.1.77.post26__cp313-cp313-macosx_15_0_arm64.whl

include/rerun/components/opacity.hpp

@@ -0,0 +1,77 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/components/opacity.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Degree of transparency ranging from 0.0 (fully transparent) to 1.0 (fully opaque).
+    ///
+    /// The final opacity value may be a result of multiplication with alpha values as specified by other color sources.
+    /// Unless otherwise specified, the default value is 1.
+    struct Opacity {
+        rerun::datatypes::Float32 opacity;
+
+      public:
+        Opacity() = default;
+
+        Opacity(rerun::datatypes::Float32 opacity_) : opacity(opacity_) {}
+
+        Opacity& operator=(rerun::datatypes::Float32 opacity_) {
+            opacity = opacity_;
+            return *this;
+        }
+
+        Opacity(float value_) : opacity(value_) {}
+
+        Opacity& operator=(float value_) {
+            opacity = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float32 datatype
+        operator rerun::datatypes::Float32() const {
+            return opacity;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float32) == sizeof(components::Opacity));
+
+    /// \private
+    template <>
+    struct Loggable<components::Opacity> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Opacity";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Float32>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::Opacity` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Opacity* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Float32>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Float32>::to_arrow(
+                    &instances->opacity,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/pinhole_projection.hpp

@@ -0,0 +1,94 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/components/pinhole_projection.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/mat3x3.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Camera projection, from image coordinates to view coordinates.
+    ///
+    /// Child from parent.
+    /// Image coordinates from camera view coordinates.
+    ///
+    /// Example:
+    /// ```text
+    /// 1496.1     0.0  980.5
+    ///    0.0  1496.1  744.5
+    ///    0.0     0.0    1.0
+    /// ```
+    struct PinholeProjection {
+        rerun::datatypes::Mat3x3 image_from_camera;
+
+      public: // START of extensions from pinhole_projection_ext.cpp:
+        /// Construct a new 3x3 pinhole matrix from a pointer to 9 floats (in column major order).
+        static PinholeProjection from_mat3x3(const float* elements) {
+            return PinholeProjection(rerun::datatypes::Mat3x3(elements));
+        }
+
+        // END of extensions from pinhole_projection_ext.cpp, start of generated code:
+
+      public:
+        PinholeProjection() = default;
+
+        PinholeProjection(rerun::datatypes::Mat3x3 image_from_camera_)
+            : image_from_camera(image_from_camera_) {}
+
+        PinholeProjection& operator=(rerun::datatypes::Mat3x3 image_from_camera_) {
+            image_from_camera = image_from_camera_;
+            return *this;
+        }
+
+        PinholeProjection(std::array<float, 9> flat_columns_) : image_from_camera(flat_columns_) {}
+
+        PinholeProjection& operator=(std::array<float, 9> flat_columns_) {
+            image_from_camera = flat_columns_;
+            return *this;
+        }
+
+        /// Cast to the underlying Mat3x3 datatype
+        operator rerun::datatypes::Mat3x3() const {
+            return image_from_camera;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Mat3x3) == sizeof(components::PinholeProjection));
+
+    /// \private
+    template <>
+    struct Loggable<components::PinholeProjection> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.PinholeProjection";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Mat3x3>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::PinholeProjection` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::PinholeProjection* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Mat3x3>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Mat3x3>::to_arrow(
+                    &instances->image_from_camera,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/plane3d.hpp

@@ -0,0 +1,75 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/components/plane3d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/plane3d.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: An infinite 3D plane represented by a unit normal vector and a distance.
+    ///
+    /// Any point P on the plane fulfills the equation `dot(xyz, P) - d = 0`,
+    /// where `xyz` is the plane's normal and `d` the distance of the plane from the origin.
+    /// This representation is also known as the Hesse normal form.
+    ///
+    /// Note: although the normal will be passed through to the
+    /// datastore as provided, when used in the Viewer, planes will always be normalized.
+    /// I.e. the plane with xyz = (2, 0, 0), d = 1 is equivalent to xyz = (1, 0, 0), d = 0.5
+    struct Plane3D {
+        rerun::datatypes::Plane3D xyzd;
+
+      public:
+        Plane3D() = default;
+
+        Plane3D(rerun::datatypes::Plane3D xyzd_) : xyzd(xyzd_) {}
+
+        Plane3D& operator=(rerun::datatypes::Plane3D xyzd_) {
+            xyzd = xyzd_;
+            return *this;
+        }
+
+        /// Cast to the underlying Plane3D datatype
+        operator rerun::datatypes::Plane3D() const {
+            return xyzd;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Plane3D) == sizeof(components::Plane3D));
+
+    /// \private
+    template <>
+    struct Loggable<components::Plane3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Plane3D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Plane3D>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::Plane3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Plane3D* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Plane3D>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Plane3D>::to_arrow(
+                    &instances->xyzd,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/pose_rotation_axis_angle.hpp

@@ -0,0 +1,73 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/components/rotation_axis_angle.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/rotation_axis_angle.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: 3D rotation represented by a rotation around a given axis that doesn't propagate in the transform hierarchy.
+    ///
+    /// If normalization of the rotation axis fails the rotation is treated as an invalid transform, unless the
+    /// angle is zero in which case it is treated as an identity.
+    struct PoseRotationAxisAngle {
+        rerun::datatypes::RotationAxisAngle rotation;
+
+      public:
+        PoseRotationAxisAngle() = default;
+
+        PoseRotationAxisAngle(rerun::datatypes::RotationAxisAngle rotation_)
+            : rotation(rotation_) {}
+
+        PoseRotationAxisAngle& operator=(rerun::datatypes::RotationAxisAngle rotation_) {
+            rotation = rotation_;
+            return *this;
+        }
+
+        /// Cast to the underlying RotationAxisAngle datatype
+        operator rerun::datatypes::RotationAxisAngle() const {
+            return rotation;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::RotationAxisAngle) == sizeof(components::PoseRotationAxisAngle)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<components::PoseRotationAxisAngle> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.PoseRotationAxisAngle";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::RotationAxisAngle>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::PoseRotationAxisAngle` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::PoseRotationAxisAngle* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::RotationAxisAngle>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::RotationAxisAngle>::to_arrow(
+                    &instances->rotation,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/pose_rotation_quat.hpp

@@ -0,0 +1,71 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/components/rotation_quat.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/quaternion.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A 3D rotation expressed as a quaternion that doesn't propagate in the transform hierarchy.
+    ///
+    /// Note: although the x,y,z,w components of the quaternion will be passed through to the
+    /// datastore as provided, when used in the Viewer, quaternions will always be normalized.
+    /// If normalization fails the rotation is treated as an invalid transform.
+    struct PoseRotationQuat {
+        rerun::datatypes::Quaternion quaternion;
+
+      public:
+        PoseRotationQuat() = default;
+
+        PoseRotationQuat(rerun::datatypes::Quaternion quaternion_) : quaternion(quaternion_) {}
+
+        PoseRotationQuat& operator=(rerun::datatypes::Quaternion quaternion_) {
+            quaternion = quaternion_;
+            return *this;
+        }
+
+        /// Cast to the underlying Quaternion datatype
+        operator rerun::datatypes::Quaternion() const {
+            return quaternion;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Quaternion) == sizeof(components::PoseRotationQuat));
+
+    /// \private
+    template <>
+    struct Loggable<components::PoseRotationQuat> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.PoseRotationQuat";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Quaternion>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::PoseRotationQuat` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::PoseRotationQuat* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Quaternion>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Quaternion>::to_arrow(
+                    &instances->quaternion,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/pose_scale3d.hpp

@@ -0,0 +1,102 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/components/scale3d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/vec3d.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A 3D scale factor that doesn't propagate in the transform hierarchy.
+    ///
+    /// A scale of 1.0 means no scaling.
+    /// A scale of 2.0 means doubling the size.
+    /// Each component scales along the corresponding axis.
+    struct PoseScale3D {
+        rerun::datatypes::Vec3D scale;
+
+      public: // START of extensions from pose_scale3d_ext.cpp:
+        /// Construct `PoseScale3D` from x/y/z values.
+        PoseScale3D(float x, float y, float z) : scale{x, y, z} {}
+
+        /// Construct `PoseScale3D` from x/y/z float pointer.
+        explicit PoseScale3D(const float* xyz) : scale{xyz[0], xyz[1], xyz[2]} {}
+
+        /// Construct a `PoseScale3D` from a uniform scale factor.
+        explicit PoseScale3D(float uniform_scale)
+            : PoseScale3D(datatypes::Vec3D{uniform_scale, uniform_scale, uniform_scale}) {}
+
+        /// Explicitly construct a `PoseScale3D` from a uniform scale factor.
+        static PoseScale3D uniform(float uniform_scale) {
+            return PoseScale3D(uniform_scale);
+        }
+
+        /// Explicitly construct a `PoseScale3D` from a 3D scale factor.
+        static PoseScale3D three_d(datatypes::Vec3D scale) {
+            return PoseScale3D(scale);
+        }
+
+        // END of extensions from pose_scale3d_ext.cpp, start of generated code:
+
+      public:
+        PoseScale3D() = default;
+
+        PoseScale3D(rerun::datatypes::Vec3D scale_) : scale(scale_) {}
+
+        PoseScale3D& operator=(rerun::datatypes::Vec3D scale_) {
+            scale = scale_;
+            return *this;
+        }
+
+        PoseScale3D(std::array<float, 3> xyz_) : scale(xyz_) {}
+
+        PoseScale3D& operator=(std::array<float, 3> xyz_) {
+            scale = xyz_;
+            return *this;
+        }
+
+        /// Cast to the underlying Vec3D datatype
+        operator rerun::datatypes::Vec3D() const {
+            return scale;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Vec3D) == sizeof(components::PoseScale3D));
+
+    /// \private
+    template <>
+    struct Loggable<components::PoseScale3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.PoseScale3D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Vec3D>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::PoseScale3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::PoseScale3D* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Vec3D>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Vec3D>::to_arrow(
+                    &instances->scale,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/pose_transform_mat3x3.hpp

@@ -0,0 +1,87 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/components/transform_mat3x3.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/mat3x3.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A 3x3 transformation matrix Matrix that doesn't propagate in the transform hierarchy.
+    ///
+    /// 3x3 matrixes are able to represent any affine transformation in 3D space,
+    /// i.e. rotation, scaling, shearing, reflection etc.
+    ///
+    /// Matrices in Rerun are stored as flat list of coefficients in column-major order:
+    /// ```text
+    ///             column 0       column 1       column 2
+    ///        -------------------------------------------------
+    /// row 0 | flat_columns[0] flat_columns[3] flat_columns[6]
+    /// row 1 | flat_columns[1] flat_columns[4] flat_columns[7]
+    /// row 2 | flat_columns[2] flat_columns[5] flat_columns[8]
+    /// ```
+    struct PoseTransformMat3x3 {
+        rerun::datatypes::Mat3x3 matrix;
+
+      public:
+        PoseTransformMat3x3() = default;
+
+        PoseTransformMat3x3(rerun::datatypes::Mat3x3 matrix_) : matrix(matrix_) {}
+
+        PoseTransformMat3x3& operator=(rerun::datatypes::Mat3x3 matrix_) {
+            matrix = matrix_;
+            return *this;
+        }
+
+        PoseTransformMat3x3(std::array<float, 9> flat_columns_) : matrix(flat_columns_) {}
+
+        PoseTransformMat3x3& operator=(std::array<float, 9> flat_columns_) {
+            matrix = flat_columns_;
+            return *this;
+        }
+
+        /// Cast to the underlying Mat3x3 datatype
+        operator rerun::datatypes::Mat3x3() const {
+            return matrix;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Mat3x3) == sizeof(components::PoseTransformMat3x3));
+
+    /// \private
+    template <>
+    struct Loggable<components::PoseTransformMat3x3> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.PoseTransformMat3x3";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Mat3x3>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::PoseTransformMat3x3` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::PoseTransformMat3x3* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Mat3x3>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Mat3x3>::to_arrow(
+                    &instances->matrix,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/pose_translation3d.hpp

@@ -0,0 +1,96 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/components/translation3d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/vec3d.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A translation vector in 3D space that doesn't propagate in the transform hierarchy.
+    struct PoseTranslation3D {
+        rerun::datatypes::Vec3D vector;
+
+      public: // START of extensions from pose_translation3d_ext.cpp:
+        /// Construct `PoseTranslation3D` from x/y/z values.
+        PoseTranslation3D(float x, float y, float z) : vector{x, y, z} {}
+
+        /// Construct `PoseTranslation3D` from x/y/z float pointer.
+        explicit PoseTranslation3D(const float* xyz) : vector{xyz[0], xyz[1], xyz[2]} {}
+
+        float x() const {
+            return vector.x();
+        }
+
+        float y() const {
+            return vector.y();
+        }
+
+        float z() const {
+            return vector.z();
+        }
+
+        // END of extensions from pose_translation3d_ext.cpp, start of generated code:
+
+      public:
+        PoseTranslation3D() = default;
+
+        PoseTranslation3D(rerun::datatypes::Vec3D vector_) : vector(vector_) {}
+
+        PoseTranslation3D& operator=(rerun::datatypes::Vec3D vector_) {
+            vector = vector_;
+            return *this;
+        }
+
+        PoseTranslation3D(std::array<float, 3> xyz_) : vector(xyz_) {}
+
+        PoseTranslation3D& operator=(std::array<float, 3> xyz_) {
+            vector = xyz_;
+            return *this;
+        }
+
+        /// Cast to the underlying Vec3D datatype
+        operator rerun::datatypes::Vec3D() const {
+            return vector;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Vec3D) == sizeof(components::PoseTranslation3D));
+
+    /// \private
+    template <>
+    struct Loggable<components::PoseTranslation3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.PoseTranslation3D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Vec3D>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::PoseTranslation3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::PoseTranslation3D* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Vec3D>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Vec3D>::to_arrow(
+                    &instances->vector,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun