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

include/rerun/components/position2d.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/position2d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/vec2d.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A position in 2D space.
+    struct Position2D {
+        rerun::datatypes::Vec2D xy;
+
+      public: // START of extensions from position2d_ext.cpp:
+        /// Construct Position2D from x/y values.
+        Position2D(float x, float y) : xy{x, y} {}
+
+        float x() const {
+            return xy.x();
+        }
+
+        float y() const {
+            return xy.y();
+        }
+
+        // END of extensions from position2d_ext.cpp, start of generated code:
+
+      public:
+        Position2D() = default;
+
+        Position2D(rerun::datatypes::Vec2D xy_) : xy(xy_) {}
+
+        Position2D& operator=(rerun::datatypes::Vec2D xy_) {
+            xy = xy_;
+            return *this;
+        }
+
+        Position2D(std::array<float, 2> xy_) : xy(xy_) {}
+
+        Position2D& 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::Position2D));
+
+    /// \private
+    template <>
+    struct Loggable<components::Position2D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Position2D";
+
+        /// 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::Position2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Position2D* 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/position3d.hpp

@@ -0,0 +1,90 @@
+// 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/position3d.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 position in 3D space.
+    struct Position3D {
+        rerun::datatypes::Vec3D xyz;
+
+      public: // START of extensions from position3d_ext.cpp:
+        /// Construct Position3D from x/y/z values.
+        Position3D(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 position3d_ext.cpp, start of generated code:
+
+      public:
+        Position3D() = default;
+
+        Position3D(rerun::datatypes::Vec3D xyz_) : xyz(xyz_) {}
+
+        Position3D& operator=(rerun::datatypes::Vec3D xyz_) {
+            xyz = xyz_;
+            return *this;
+        }
+
+        Position3D(std::array<float, 3> xyz_) : xyz(xyz_) {}
+
+        Position3D& 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::Position3D));
+
+    /// \private
+    template <>
+    struct Loggable<components::Position3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Position3D";
+
+        /// 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::Position3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Position3D* 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/radius.hpp

@@ -0,0 +1,98 @@
+// 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/radius.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: The radius of something, e.g. a point.
+    ///
+    /// Internally, positive values indicate scene units, whereas negative values
+    /// are interpreted as UI points.
+    ///
+    /// UI points are independent of zooming in Views, but are sensitive to the application UI scaling.
+    /// at 100% UI scaling, UI points are equal to pixels
+    /// The Viewer's UI scaling defaults to the OS scaling which typically is 100% for full HD screens and 200% for 4k screens.
+    struct Radius {
+        rerun::datatypes::Float32 value;
+
+      public: // START of extensions from radius_ext.cpp:
+        /// Creates a new radius in scene units.
+        ///
+        /// Values passed must be finite positive.
+        static Radius scene_units(float radius_in_scene_units) {
+            return Radius(radius_in_scene_units);
+        }
+
+        /// Creates a new radius in ui points.
+        ///
+        /// Values passed must be finite positive.
+        static Radius ui_points(float radius_in_ui_points) {
+            return Radius(-radius_in_ui_points);
+        }
+
+        // END of extensions from radius_ext.cpp, start of generated code:
+
+      public:
+        Radius() = default;
+
+        Radius(rerun::datatypes::Float32 value_) : value(value_) {}
+
+        Radius& operator=(rerun::datatypes::Float32 value_) {
+            value = value_;
+            return *this;
+        }
+
+        Radius(float value_) : value(value_) {}
+
+        Radius& operator=(float value_) {
+            value = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float32 datatype
+        operator rerun::datatypes::Float32() const {
+            return value;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float32) == sizeof(components::Radius));
+
+    /// \private
+    template <>
+    struct Loggable<components::Radius> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Radius";
+
+        /// 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::Radius` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Radius* 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->value,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/range1d.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/range1d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/range1d.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A 1D range, specifying a lower and upper bound.
+    struct Range1D {
+        rerun::datatypes::Range1D range;
+
+      public:
+        Range1D() = default;
+
+        Range1D(rerun::datatypes::Range1D range_) : range(range_) {}
+
+        Range1D& operator=(rerun::datatypes::Range1D range_) {
+            range = range_;
+            return *this;
+        }
+
+        Range1D(std::array<double, 2> range_) : range(range_) {}
+
+        Range1D& operator=(std::array<double, 2> range_) {
+            range = range_;
+            return *this;
+        }
+
+        /// Cast to the underlying Range1D datatype
+        operator rerun::datatypes::Range1D() const {
+            return range;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Range1D) == sizeof(components::Range1D));
+
+    /// \private
+    template <>
+    struct Loggable<components::Range1D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Range1D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Range1D>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::Range1D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Range1D* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Range1D>::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::Range1D>::to_arrow(
+                    &instances->range,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/resolution.hpp

@@ -0,0 +1,88 @@
+// 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/resolution.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/vec2d.hpp"
+#include "../rerun_sdk_export.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Pixel resolution width & height, e.g. of a camera sensor.
+    ///
+    /// Typically in integer units, but for some use cases floating point may be used.
+    struct Resolution {
+        rerun::datatypes::Vec2D resolution;
+
+      public: // START of extensions from resolution_ext.cpp:
+        /// Construct resolution from width and height floats.
+        Resolution(float width, float height) : resolution{width, height} {}
+
+        /// Construct resolution from width and height integers.
+        Resolution(int width, int height)
+            : resolution{static_cast<float>(width), static_cast<float>(height)} {}
+
+        // END of extensions from resolution_ext.cpp, start of generated code:
+
+      public:
+        Resolution() = default;
+
+        Resolution(rerun::datatypes::Vec2D resolution_) : resolution(resolution_) {}
+
+        Resolution& operator=(rerun::datatypes::Vec2D resolution_) {
+            resolution = resolution_;
+            return *this;
+        }
+
+        Resolution(std::array<float, 2> xy_) : resolution(xy_) {}
+
+        Resolution& operator=(std::array<float, 2> xy_) {
+            resolution = xy_;
+            return *this;
+        }
+
+        /// Cast to the underlying Vec2D datatype
+        operator rerun::datatypes::Vec2D() const {
+            return resolution;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Vec2D) == sizeof(components::Resolution));
+
+    /// \private
+    template <>
+    struct Loggable<components::Resolution> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Resolution";
+
+        /// 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::Resolution` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Resolution* 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->resolution,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/rotation_axis_angle.hpp

@@ -0,0 +1,72 @@
+// 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.
+    ///
+    /// 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 RotationAxisAngle {
+        rerun::datatypes::RotationAxisAngle rotation;
+
+      public:
+        RotationAxisAngle() = default;
+
+        RotationAxisAngle(rerun::datatypes::RotationAxisAngle rotation_) : rotation(rotation_) {}
+
+        RotationAxisAngle& 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::RotationAxisAngle)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<components::RotationAxisAngle> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.RotationAxisAngle";
+
+        /// 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::RotationAxisAngle` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::RotationAxisAngle* 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/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.
+    ///
+    /// 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 RotationQuat {
+        rerun::datatypes::Quaternion quaternion;
+
+      public:
+        RotationQuat() = default;
+
+        RotationQuat(rerun::datatypes::Quaternion quaternion_) : quaternion(quaternion_) {}
+
+        RotationQuat& 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::RotationQuat));
+
+    /// \private
+    template <>
+    struct Loggable<components::RotationQuat> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.RotationQuat";
+
+        /// 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::RotationQuat` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::RotationQuat* 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/scalar.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/scalar.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float64.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A scalar value, encoded as a 64-bit floating point.
+    ///
+    /// Used for time series plots.
+    struct Scalar {
+        rerun::datatypes::Float64 value;
+
+      public:
+        Scalar() = default;
+
+        Scalar(rerun::datatypes::Float64 value_) : value(value_) {}
+
+        Scalar& operator=(rerun::datatypes::Float64 value_) {
+            value = value_;
+            return *this;
+        }
+
+        Scalar(double value_) : value(value_) {}
+
+        Scalar& operator=(double value_) {
+            value = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float64 datatype
+        operator rerun::datatypes::Float64() const {
+            return value;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float64) == sizeof(components::Scalar));
+
+    /// \private
+    template <>
+    struct Loggable<components::Scalar> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Scalar";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Float64>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::Scalar` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Scalar* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Float64>::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::Float64>::to_arrow(
+                    &instances->value,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun