pymomentum-cpu 0.1.82.post0__cp312-cp312-macosx_14_0_arm64.whl

include/rerun/components/texcoord2d.hpp

@@ -0,0 +1,101 @@
+// 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/texcoord2d.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 2D texture UV coordinate.
+    ///
+    /// Texture coordinates specify a position on a 2D texture.
+    /// A range from 0-1 covers the entire texture in the respective dimension.
+    /// Unless configured otherwise, the texture repeats outside of this range.
+    /// Rerun uses top-left as the origin for UV coordinates.
+    ///
+    ///   0     U     1
+    /// 0 + --------- →
+    ///   |           .
+    /// V |           .
+    ///   |           .
+    /// 1 ↓ . . . . . .
+    ///
+    /// This is the same convention as in Vulkan/Metal/DX12/WebGPU, but (!) unlike OpenGL,
+    /// which places the origin at the bottom-left.
+    struct Texcoord2D {
+        rerun::datatypes::Vec2D uv;
+
+      public: // START of extensions from texcoord2d_ext.cpp:
+        /// Construct Texcoord2D from u/v values.
+        Texcoord2D(float u, float v) : uv{u, v} {}
+
+        float u() const {
+            return uv.x();
+        }
+
+        float v() const {
+            return uv.y();
+        }
+
+        // END of extensions from texcoord2d_ext.cpp, start of generated code:
+
+      public:
+        Texcoord2D() = default;
+
+        Texcoord2D(rerun::datatypes::Vec2D uv_) : uv(uv_) {}
+
+        Texcoord2D& operator=(rerun::datatypes::Vec2D uv_) {
+            uv = uv_;
+            return *this;
+        }
+
+        Texcoord2D(std::array<float, 2> xy_) : uv(xy_) {}
+
+        Texcoord2D& operator=(std::array<float, 2> xy_) {
+            uv = xy_;
+            return *this;
+        }
+
+        /// Cast to the underlying Vec2D datatype
+        operator rerun::datatypes::Vec2D() const {
+            return uv;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Vec2D) == sizeof(components::Texcoord2D));
+
+    /// \private
+    template <>
+    struct Loggable<components::Texcoord2D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Texcoord2D";
+
+        /// 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::Texcoord2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Texcoord2D* 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->uv, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/text.hpp

@@ -0,0 +1,83 @@
+// 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/text.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/utf8.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::components {
+    /// **Component**: A string of text, e.g. for labels and text documents.
+    struct Text {
+        rerun::datatypes::Utf8 value;
+
+      public: // START of extensions from text_ext.cpp:
+        /// Construct `Text` from a null-terminated UTF8 string.
+        Text(const char* str) : value(str) {}
+
+        const char* c_str() const {
+            return value.c_str();
+        }
+
+        // END of extensions from text_ext.cpp, start of generated code:
+
+      public:
+        Text() = default;
+
+        Text(rerun::datatypes::Utf8 value_) : value(std::move(value_)) {}
+
+        Text& operator=(rerun::datatypes::Utf8 value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        Text(std::string value_) : value(std::move(value_)) {}
+
+        Text& operator=(std::string value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        /// Cast to the underlying Utf8 datatype
+        operator rerun::datatypes::Utf8() const {
+            return value;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Utf8) == sizeof(components::Text));
+
+    /// \private
+    template <>
+    struct Loggable<components::Text> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Text";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Utf8>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::Text` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Text* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Utf8>::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::Utf8>::to_arrow(&instances->value, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/text_log_level.hpp

@@ -0,0 +1,110 @@
+// 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/text_log_level.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/utf8.hpp"
+#include "../rerun_sdk_export.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::components {
+    /// **Component**: The severity level of a text log message.
+    ///
+    /// Recommended to be one of:
+    /// * `"CRITICAL"`
+    /// * `"ERROR"`
+    /// * `"WARN"`
+    /// * `"INFO"`
+    /// * `"DEBUG"`
+    /// * `"TRACE"`
+    struct TextLogLevel {
+        rerun::datatypes::Utf8 value;
+
+      public: // START of extensions from text_log_level_ext.cpp:
+        /// Designates catastrophic failures.
+        RERUN_SDK_EXPORT static const TextLogLevel Critical;
+
+        /// Designates very serious errors.
+        RERUN_SDK_EXPORT static const TextLogLevel Error;
+
+        /// Designates hazardous situations.
+        RERUN_SDK_EXPORT static const TextLogLevel Warning;
+
+        /// Designates useful information.
+        RERUN_SDK_EXPORT static const TextLogLevel Info;
+
+        /// Designates lower priority information.
+        RERUN_SDK_EXPORT static const TextLogLevel Debug;
+
+        /// Designates very low priority, often extremely verbose, information.
+        RERUN_SDK_EXPORT static const TextLogLevel Trace;
+
+        /// Construct `TextLogLevel` from a null-terminated UTF8 string.
+        TextLogLevel(const char* str) : value(str) {}
+
+        const char* c_str() const {
+            return value.c_str();
+        }
+
+        // END of extensions from text_log_level_ext.cpp, start of generated code:
+
+      public:
+        TextLogLevel() = default;
+
+        TextLogLevel(rerun::datatypes::Utf8 value_) : value(std::move(value_)) {}
+
+        TextLogLevel& operator=(rerun::datatypes::Utf8 value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        TextLogLevel(std::string value_) : value(std::move(value_)) {}
+
+        TextLogLevel& operator=(std::string value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        /// Cast to the underlying Utf8 datatype
+        operator rerun::datatypes::Utf8() const {
+            return value;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Utf8) == sizeof(components::TextLogLevel));
+
+    /// \private
+    template <>
+    struct Loggable<components::TextLogLevel> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.TextLogLevel";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Utf8>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::TextLogLevel` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::TextLogLevel* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Utf8>::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::Utf8>::to_arrow(&instances->value, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/timestamp.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/timestamp.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/time_int.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: When the recording started.
+    ///
+    /// Should be an absolute time, i.e. relative to Unix Epoch.
+    struct Timestamp {
+        rerun::datatypes::TimeInt timestamp;
+
+      public:
+        Timestamp() = default;
+
+        Timestamp(rerun::datatypes::TimeInt timestamp_) : timestamp(timestamp_) {}
+
+        Timestamp& operator=(rerun::datatypes::TimeInt timestamp_) {
+            timestamp = timestamp_;
+            return *this;
+        }
+
+        Timestamp(int64_t value_) : timestamp(value_) {}
+
+        Timestamp& operator=(int64_t value_) {
+            timestamp = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying TimeInt datatype
+        operator rerun::datatypes::TimeInt() const {
+            return timestamp;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::TimeInt) == sizeof(components::Timestamp));
+
+    /// \private
+    template <>
+    struct Loggable<components::Timestamp> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Timestamp";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::TimeInt>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::Timestamp` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Timestamp* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::TimeInt>::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::TimeInt>::to_arrow(
+                    &instances->timestamp,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/transform_mat3x3.hpp

@@ -0,0 +1,92 @@
+// 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.
+    ///
+    /// 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 TransformMat3x3 {
+        rerun::datatypes::Mat3x3 matrix;
+
+      public: // START of extensions from transform_mat3x3_ext.cpp:
+        TransformMat3x3(const rerun::datatypes::Vec3D (&columns)[3]) : matrix(columns) {}
+
+        // END of extensions from transform_mat3x3_ext.cpp, start of generated code:
+
+      public:
+        TransformMat3x3() = default;
+
+        TransformMat3x3(rerun::datatypes::Mat3x3 matrix_) : matrix(matrix_) {}
+
+        TransformMat3x3& operator=(rerun::datatypes::Mat3x3 matrix_) {
+            matrix = matrix_;
+            return *this;
+        }
+
+        TransformMat3x3(std::array<float, 9> flat_columns_) : matrix(flat_columns_) {}
+
+        TransformMat3x3& 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::TransformMat3x3));
+
+    /// \private
+    template <>
+    struct Loggable<components::TransformMat3x3> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.TransformMat3x3";
+
+        /// 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::TransformMat3x3` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::TransformMat3x3* 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/transform_relation.hpp

@@ -0,0 +1,66 @@
+// 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_relation.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    /// \private
+    template <typename T>
+    class NumericBuilder;
+
+    class Array;
+    class DataType;
+    class UInt8Type;
+    using UInt8Builder = NumericBuilder<UInt8Type>;
+} // namespace arrow
+
+namespace rerun::components {
+    /// **Component**: Specifies relation a spatial transform describes.
+    enum class TransformRelation : uint8_t {
+
+        /// The transform describes how to transform into the parent entity's space.
+        ///
+        /// E.g. a translation of (0, 1, 0) with this `components::TransformRelation` logged at `parent/child` means
+        /// that from the point of view of `parent`, `parent/child` is translated 1 unit along `parent`'s Y axis.
+        /// From perspective of `parent/child`, the `parent` entity is translated -1 unit along `parent/child`'s Y axis.
+        ParentFromChild = 1,
+
+        /// The transform describes how to transform into the child entity's space.
+        ///
+        /// E.g. a translation of (0, 1, 0) with this `components::TransformRelation` logged at `parent/child` means
+        /// that from the point of view of `parent`, `parent/child` is translated -1 unit along `parent`'s Y axis.
+        /// From perspective of `parent/child`, the `parent` entity is translated 1 unit along `parent/child`'s Y axis.
+        ChildFromParent = 2,
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::TransformRelation> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.TransformRelation";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::TransformRelation` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::TransformRelation* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::UInt8Builder* builder, const components::TransformRelation* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/components/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.
+    struct Translation3D {
+        rerun::datatypes::Vec3D vector;
+
+      public: // START of extensions from translation3d_ext.cpp:
+        /// Construct `Translation3D` from x/y/z values.
+        Translation3D(float x, float y, float z) : vector{x, y, z} {}
+
+        /// Construct `Translation3D` from x/y/z float pointer.
+        explicit Translation3D(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 translation3d_ext.cpp, start of generated code:
+
+      public:
+        Translation3D() = default;
+
+        Translation3D(rerun::datatypes::Vec3D vector_) : vector(vector_) {}
+
+        Translation3D& operator=(rerun::datatypes::Vec3D vector_) {
+            vector = vector_;
+            return *this;
+        }
+
+        Translation3D(std::array<float, 3> xyz_) : vector(xyz_) {}
+
+        Translation3D& 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::Translation3D));
+
+    /// \private
+    template <>
+    struct Loggable<components::Translation3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Translation3D";
+
+        /// 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::Translation3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Translation3D* 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