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

include/rerun/components/half_size2d.hpp

@@ -0,0 +1,91 @@
+// 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/half_size2d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/vec2d.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Half-size (radius) of a 2D box.
+    ///
+    /// Measured in its local coordinate system.
+    ///
+    /// The box extends both in negative and positive direction along each axis.
+    /// Negative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed.
+    struct HalfSize2D {
+        rerun::datatypes::Vec2D xy;
+
+      public: // START of extensions from half_size2d_ext.cpp:
+        /// Construct HalfSize2D from x/y values.
+        HalfSize2D(float x, float y) : xy{x, y} {}
+
+        float x() const {
+            return xy.x();
+        }
+
+        float y() const {
+            return xy.y();
+        }
+
+        // END of extensions from half_size2d_ext.cpp, start of generated code:
+
+      public:
+        HalfSize2D() = default;
+
+        HalfSize2D(rerun::datatypes::Vec2D xy_) : xy(xy_) {}
+
+        HalfSize2D& operator=(rerun::datatypes::Vec2D xy_) {
+            xy = xy_;
+            return *this;
+        }
+
+        HalfSize2D(std::array<float, 2> xy_) : xy(xy_) {}
+
+        HalfSize2D& operator=(std::array<float, 2> xy_) {
+            xy = xy_;
+            return *this;
+        }
+
+        /// Cast to the underlying Vec2D datatype
+        operator rerun::datatypes::Vec2D() const {
+            return xy;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Vec2D) == sizeof(components::HalfSize2D));
+
+    /// \private
+    template <>
+    struct Loggable<components::HalfSize2D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.HalfSize2D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Vec2D>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::HalfSize2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::HalfSize2D* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Vec2D>::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::Vec2D>::to_arrow(&instances->xy, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/half_size3d.hpp

@@ -0,0 +1,95 @@
+// 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/half_size3d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/vec3d.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Half-size (radius) of a 3D box.
+    ///
+    /// Measured in its local coordinate system.
+    ///
+    /// The box extends both in negative and positive direction along each axis.
+    /// Negative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed.
+    struct HalfSize3D {
+        rerun::datatypes::Vec3D xyz;
+
+      public: // START of extensions from half_size3d_ext.cpp:
+        /// Construct HalfSize3D from x/y/z values.
+        HalfSize3D(float x, float y, float z) : xyz{x, y, z} {}
+
+        float x() const {
+            return xyz.x();
+        }
+
+        float y() const {
+            return xyz.y();
+        }
+
+        float z() const {
+            return xyz.z();
+        }
+
+        // END of extensions from half_size3d_ext.cpp, start of generated code:
+
+      public:
+        HalfSize3D() = default;
+
+        HalfSize3D(rerun::datatypes::Vec3D xyz_) : xyz(xyz_) {}
+
+        HalfSize3D& operator=(rerun::datatypes::Vec3D xyz_) {
+            xyz = xyz_;
+            return *this;
+        }
+
+        HalfSize3D(std::array<float, 3> xyz_) : xyz(xyz_) {}
+
+        HalfSize3D& operator=(std::array<float, 3> xyz_) {
+            xyz = xyz_;
+            return *this;
+        }
+
+        /// Cast to the underlying Vec3D datatype
+        operator rerun::datatypes::Vec3D() const {
+            return xyz;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Vec3D) == sizeof(components::HalfSize3D));
+
+    /// \private
+    template <>
+    struct Loggable<components::HalfSize3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.HalfSize3D";
+
+        /// 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::HalfSize3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::HalfSize3D* 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->xyz, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/image_buffer.hpp

@@ -0,0 +1,86 @@
+// 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/image_buffer.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_descriptor.hpp"
+#include "../datatypes/blob.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace rerun::components {
+    /// **Component**: A buffer that is known to store image data.
+    ///
+    /// To interpret the contents of this buffer, see, `components::ImageFormat`.
+    struct ImageBuffer {
+        rerun::datatypes::Blob buffer;
+
+      public: // START of extensions from image_buffer_ext.cpp:
+        /// Number of bytes
+        size_t size() const {
+            return buffer.size();
+        }
+
+        // END of extensions from image_buffer_ext.cpp, start of generated code:
+
+      public:
+        ImageBuffer() = default;
+
+        ImageBuffer(rerun::datatypes::Blob buffer_) : buffer(std::move(buffer_)) {}
+
+        ImageBuffer& operator=(rerun::datatypes::Blob buffer_) {
+            buffer = std::move(buffer_);
+            return *this;
+        }
+
+        ImageBuffer(rerun::Collection<uint8_t> data_) : buffer(std::move(data_)) {}
+
+        ImageBuffer& operator=(rerun::Collection<uint8_t> data_) {
+            buffer = std::move(data_);
+            return *this;
+        }
+
+        /// Cast to the underlying Blob datatype
+        operator rerun::datatypes::Blob() const {
+            return buffer;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Blob) == sizeof(components::ImageBuffer));
+
+    /// \private
+    template <>
+    struct Loggable<components::ImageBuffer> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.ImageBuffer";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Blob>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::ImageBuffer` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::ImageBuffer* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Blob>::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::Blob>::to_arrow(
+                    &instances->buffer,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/image_format.hpp

@@ -0,0 +1,84 @@
+// 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/image_format.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/image_format.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: The metadata describing the contents of a `components::ImageBuffer`.
+    struct ImageFormat {
+        rerun::datatypes::ImageFormat image_format;
+
+      public: // START of extensions from image_format_ext.cpp:
+        /// From a specific pixel format.
+        ImageFormat(rerun::WidthHeight resolution, datatypes::PixelFormat pixel_format)
+            : image_format(resolution, pixel_format) {}
+
+        /// Create a new image format for depth or segmentation images with the given resolution and datatype.
+        ImageFormat(rerun::WidthHeight resolution, datatypes::ChannelDatatype datatype)
+            : image_format(resolution, datatype) {}
+
+        ImageFormat(
+            rerun::WidthHeight resolution, datatypes::ColorModel color_model,
+            datatypes::ChannelDatatype datatype
+        )
+            : image_format(resolution, color_model, datatype) {}
+
+        // END of extensions from image_format_ext.cpp, start of generated code:
+
+      public:
+        ImageFormat() = default;
+
+        ImageFormat(rerun::datatypes::ImageFormat image_format_) : image_format(image_format_) {}
+
+        ImageFormat& operator=(rerun::datatypes::ImageFormat image_format_) {
+            image_format = image_format_;
+            return *this;
+        }
+
+        /// Cast to the underlying ImageFormat datatype
+        operator rerun::datatypes::ImageFormat() const {
+            return image_format;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::ImageFormat) == sizeof(components::ImageFormat));
+
+    /// \private
+    template <>
+    struct Loggable<components::ImageFormat> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.ImageFormat";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::ImageFormat>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::ImageFormat` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::ImageFormat* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::ImageFormat>::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::ImageFormat>::to_arrow(
+                    &instances->image_format,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/image_plane_distance.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/image_plane_distance.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: The distance from the camera origin to the image plane when the projection is shown in a 3D viewer.
+    ///
+    /// This is only used for visualization purposes, and does not affect the projection itself.
+    struct ImagePlaneDistance {
+        rerun::datatypes::Float32 image_from_camera;
+
+      public:
+        ImagePlaneDistance() = default;
+
+        ImagePlaneDistance(rerun::datatypes::Float32 image_from_camera_)
+            : image_from_camera(image_from_camera_) {}
+
+        ImagePlaneDistance& operator=(rerun::datatypes::Float32 image_from_camera_) {
+            image_from_camera = image_from_camera_;
+            return *this;
+        }
+
+        ImagePlaneDistance(float value_) : image_from_camera(value_) {}
+
+        ImagePlaneDistance& operator=(float value_) {
+            image_from_camera = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float32 datatype
+        operator rerun::datatypes::Float32() const {
+            return image_from_camera;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float32) == sizeof(components::ImagePlaneDistance));
+
+    /// \private
+    template <>
+    struct Loggable<components::ImagePlaneDistance> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.ImagePlaneDistance";
+
+        /// 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::ImagePlaneDistance` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::ImagePlaneDistance* 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->image_from_camera,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/interactive.hpp

@@ -0,0 +1,76 @@
+// 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/interactive.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/bool.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Whether the entity can be interacted with.
+    ///
+    /// Non interactive components are still visible, but mouse interactions in the view are disabled.
+    struct Interactive {
+        rerun::datatypes::Bool interactive;
+
+      public:
+        Interactive() = default;
+
+        Interactive(rerun::datatypes::Bool interactive_) : interactive(interactive_) {}
+
+        Interactive& operator=(rerun::datatypes::Bool interactive_) {
+            interactive = interactive_;
+            return *this;
+        }
+
+        Interactive(bool value_) : interactive(value_) {}
+
+        Interactive& operator=(bool value_) {
+            interactive = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Bool datatype
+        operator rerun::datatypes::Bool() const {
+            return interactive;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Bool) == sizeof(components::Interactive));
+
+    /// \private
+    template <>
+    struct Loggable<components::Interactive> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Interactive";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Bool>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::Interactive` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Interactive* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Bool>::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::Bool>::to_arrow(
+                    &instances->interactive,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/keypoint_id.hpp

@@ -0,0 +1,74 @@
+// 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/keypoint_id.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/keypoint_id.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A 16-bit ID representing a type of semantic keypoint within a class.
+    struct KeypointId {
+        rerun::datatypes::KeypointId id;
+
+      public:
+        KeypointId() = default;
+
+        KeypointId(rerun::datatypes::KeypointId id_) : id(id_) {}
+
+        KeypointId& operator=(rerun::datatypes::KeypointId id_) {
+            id = id_;
+            return *this;
+        }
+
+        KeypointId(uint16_t id_) : id(id_) {}
+
+        KeypointId& operator=(uint16_t id_) {
+            id = id_;
+            return *this;
+        }
+
+        /// Cast to the underlying KeypointId datatype
+        operator rerun::datatypes::KeypointId() const {
+            return id;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::KeypointId) == sizeof(components::KeypointId));
+
+    /// \private
+    template <>
+    struct Loggable<components::KeypointId> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.KeypointId";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::KeypointId>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::KeypointId` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::KeypointId* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::KeypointId>::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::KeypointId>::to_arrow(
+                    &instances->id,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/lat_lon.hpp

@@ -0,0 +1,89 @@
+// 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/latlon.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/dvec2d.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A geospatial position expressed in [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees).
+    struct LatLon {
+        rerun::datatypes::DVec2D lat_lon;
+
+      public: // START of extensions from lat_lon_ext.cpp:
+        /// Construct LatLon from x/y values.
+        LatLon(double lat, double lon) : lat_lon{lat, lon} {}
+
+        double latitude() const {
+            return lat_lon.x();
+        }
+
+        double longitude() const {
+            return lat_lon.y();
+        }
+
+        // END of extensions from lat_lon_ext.cpp, start of generated code:
+
+      public:
+        LatLon() = default;
+
+        LatLon(rerun::datatypes::DVec2D lat_lon_) : lat_lon(lat_lon_) {}
+
+        LatLon& operator=(rerun::datatypes::DVec2D lat_lon_) {
+            lat_lon = lat_lon_;
+            return *this;
+        }
+
+        LatLon(std::array<double, 2> xy_) : lat_lon(xy_) {}
+
+        LatLon& operator=(std::array<double, 2> xy_) {
+            lat_lon = xy_;
+            return *this;
+        }
+
+        /// Cast to the underlying DVec2D datatype
+        operator rerun::datatypes::DVec2D() const {
+            return lat_lon;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::DVec2D) == sizeof(components::LatLon));
+
+    /// \private
+    template <>
+    struct Loggable<components::LatLon> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.LatLon";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::DVec2D>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::LatLon` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::LatLon* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::DVec2D>::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::DVec2D>::to_arrow(
+                    &instances->lat_lon,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun