pymomentum-cpu 0.1.78.post11__cp313-cp313-win_amd64.whl

include/rerun/components/triangle_indices.hpp

@@ -0,0 +1,85 @@
+// 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/triangle_indices.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/uvec3d.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: The three indices of a triangle in a triangle mesh.
+    struct TriangleIndices {
+        rerun::datatypes::UVec3D indices;
+
+      public: // START of extensions from triangle_indices_ext.cpp:
+        /// Construct TriangleIndices from v0/v1/v2 values.
+        TriangleIndices(uint32_t v0, uint32_t v1, uint32_t v2) : indices{v0, v1, v2} {}
+
+        /// Construct UVec3D from v0/v1/v2 uint32_t pointer.
+        explicit TriangleIndices(const uint32_t* indices_)
+            : indices{indices_[0], indices_[1], indices_[2]} {}
+
+        // END of extensions from triangle_indices_ext.cpp, start of generated code:
+
+      public:
+        TriangleIndices() = default;
+
+        TriangleIndices(rerun::datatypes::UVec3D indices_) : indices(indices_) {}
+
+        TriangleIndices& operator=(rerun::datatypes::UVec3D indices_) {
+            indices = indices_;
+            return *this;
+        }
+
+        TriangleIndices(std::array<uint32_t, 3> xyz_) : indices(xyz_) {}
+
+        TriangleIndices& operator=(std::array<uint32_t, 3> xyz_) {
+            indices = xyz_;
+            return *this;
+        }
+
+        /// Cast to the underlying UVec3D datatype
+        operator rerun::datatypes::UVec3D() const {
+            return indices;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::UVec3D) == sizeof(components::TriangleIndices));
+
+    /// \private
+    template <>
+    struct Loggable<components::TriangleIndices> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.TriangleIndices";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::UVec3D>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::TriangleIndices` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::TriangleIndices* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::UVec3D>::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::UVec3D>::to_arrow(
+                    &instances->indices,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/value_range.hpp

@@ -0,0 +1,78 @@
+// 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/value_range.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/range1d.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Range of expected or valid values, specifying a lower and upper bound.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ValueRange {
+        rerun::datatypes::Range1D range;
+
+      public:
+        ValueRange() = default;
+
+        ValueRange(rerun::datatypes::Range1D range_) : range(range_) {}
+
+        ValueRange& operator=(rerun::datatypes::Range1D range_) {
+            range = range_;
+            return *this;
+        }
+
+        ValueRange(std::array<double, 2> range_) : range(range_) {}
+
+        ValueRange& 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::ValueRange));
+
+    /// \private
+    template <>
+    struct Loggable<components::ValueRange> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.ValueRange";
+
+        /// 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::ValueRange` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::ValueRange* 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/vector2d.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/vector2d.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 vector in 2D space.
+    struct Vector2D {
+        rerun::datatypes::Vec2D vector;
+
+      public: // START of extensions from vector2d_ext.cpp:
+        /// Construct Vector2D from x/y values.
+        Vector2D(float x, float y) : vector{x, y} {}
+
+        /// Construct Vec2D from x/y float pointer.
+        explicit Vector2D(const float* xy) : vector{xy[0], xy[1]} {}
+
+        float x() const {
+            return vector.x();
+        }
+
+        float y() const {
+            return vector.y();
+        }
+
+        // END of extensions from vector2d_ext.cpp, start of generated code:
+
+      public:
+        Vector2D() = default;
+
+        Vector2D(rerun::datatypes::Vec2D vector_) : vector(vector_) {}
+
+        Vector2D& operator=(rerun::datatypes::Vec2D vector_) {
+            vector = vector_;
+            return *this;
+        }
+
+        Vector2D(std::array<float, 2> xy_) : vector(xy_) {}
+
+        Vector2D& operator=(std::array<float, 2> xy_) {
+            vector = xy_;
+            return *this;
+        }
+
+        /// Cast to the underlying Vec2D datatype
+        operator rerun::datatypes::Vec2D() const {
+            return vector;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Vec2D) == sizeof(components::Vector2D));
+
+    /// \private
+    template <>
+    struct Loggable<components::Vector2D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Vector2D";
+
+        /// 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::Vector2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Vector2D* 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->vector,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

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

include/rerun/components/video_timestamp.hpp

@@ -0,0 +1,120 @@
+// 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/video_timestamp.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/video_timestamp.hpp"
+#include "../result.hpp"
+
+#include <chrono>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Timestamp inside a `archetypes::AssetVideo`.
+    struct VideoTimestamp {
+        rerun::datatypes::VideoTimestamp timestamp;
+
+      public: // START of extensions from video_timestamp_ext.cpp:
+        /// Creates a new `VideoTimestamp` from a presentation timestamp as a chrono duration.
+        template <typename TRep, typename TPeriod>
+        VideoTimestamp(std::chrono::duration<TRep, TPeriod> time) {
+            timestamp.timestamp_ns =
+                std::chrono::duration_cast<std::chrono::nanoseconds>(time).count();
+        }
+
+        /// Creates a new `VideoTimestamp` from a presentation timestamp in seconds.
+        static VideoTimestamp from_secs(double seconds) {
+            return VideoTimestamp(std::chrono::duration<double>(seconds));
+        }
+
+        /// Creates a new `VideoTimestamp` from a presentation timestamp in seconds.
+        [[deprecated("Renamed to `from_secs`")]] static VideoTimestamp from_seconds(double seconds
+        ) {
+            return VideoTimestamp(std::chrono::duration<double>(seconds));
+        }
+
+        /// Creates a new `VideoTimestamp` from a presentation timestamp in milliseconds.
+        static VideoTimestamp from_millis(double milliseconds) {
+            return VideoTimestamp(std::chrono::duration<double, std::milli>(milliseconds));
+        }
+
+        /// Creates a new `VideoTimestamp` from a presentation timestamp in milliseconds.
+        [[deprecated("Renamed to `from_millis`")]] static VideoTimestamp from_milliseconds(
+            double milliseconds
+        ) {
+            return VideoTimestamp(std::chrono::duration<double, std::milli>(milliseconds));
+        }
+
+        /// Creates a new `VideoTimestamp` from a presentation timestamp in nanoseconds.
+        static VideoTimestamp from_nanos(int64_t nanoseconds) {
+            return VideoTimestamp(std::chrono::nanoseconds(nanoseconds));
+        }
+
+        /// Creates a new `VideoTimestamp` from a presentation timestamp in nanoseconds.
+        [[deprecated("Renamed to `from_nanos`")]] static VideoTimestamp from_nanoseconds(
+            int64_t nanoseconds
+        ) {
+            return VideoTimestamp(std::chrono::nanoseconds(nanoseconds));
+        }
+
+        // END of extensions from video_timestamp_ext.cpp, start of generated code:
+
+      public:
+        VideoTimestamp() = default;
+
+        VideoTimestamp(rerun::datatypes::VideoTimestamp timestamp_) : timestamp(timestamp_) {}
+
+        VideoTimestamp& operator=(rerun::datatypes::VideoTimestamp timestamp_) {
+            timestamp = timestamp_;
+            return *this;
+        }
+
+        VideoTimestamp(int64_t timestamp_ns_) : timestamp(timestamp_ns_) {}
+
+        VideoTimestamp& operator=(int64_t timestamp_ns_) {
+            timestamp = timestamp_ns_;
+            return *this;
+        }
+
+        /// Cast to the underlying VideoTimestamp datatype
+        operator rerun::datatypes::VideoTimestamp() const {
+            return timestamp;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::VideoTimestamp) == sizeof(components::VideoTimestamp));
+
+    /// \private
+    template <>
+    struct Loggable<components::VideoTimestamp> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.VideoTimestamp";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::VideoTimestamp>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::VideoTimestamp` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::VideoTimestamp* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::VideoTimestamp>::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::VideoTimestamp>::to_arrow(
+                    &instances->timestamp,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun