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

include/rerun/components/draw_order.hpp

@@ -0,0 +1,79 @@
+// 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/draw_order.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Draw order of 2D elements. Higher values are drawn on top of lower values.
+    ///
+    /// An entity can have only a single draw order component.
+    /// Within an entity draw order is governed by the order of the components.
+    ///
+    /// Draw order for entities with the same draw order is generally undefined.
+    struct DrawOrder {
+        rerun::datatypes::Float32 value;
+
+      public:
+        DrawOrder() = default;
+
+        DrawOrder(rerun::datatypes::Float32 value_) : value(value_) {}
+
+        DrawOrder& operator=(rerun::datatypes::Float32 value_) {
+            value = value_;
+            return *this;
+        }
+
+        DrawOrder(float value_) : value(value_) {}
+
+        DrawOrder& 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::DrawOrder));
+
+    /// \private
+    template <>
+    struct Loggable<components::DrawOrder> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.DrawOrder";
+
+        /// 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::DrawOrder` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::DrawOrder* 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/entity_path.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/entity_path.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/entity_path.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::components {
+    /// **Component**: A path to an entity, usually to reference some data that is part of the target entity.
+    struct EntityPath {
+        rerun::datatypes::EntityPath value;
+
+      public: // START of extensions from entity_path_ext.cpp:
+        EntityPath(std::string_view path_) : value(std::string(path_)) {}
+
+        EntityPath(const char* path_) : value(std::string(path_)) {}
+
+        // END of extensions from entity_path_ext.cpp, start of generated code:
+
+      public:
+        EntityPath() = default;
+
+        EntityPath(rerun::datatypes::EntityPath value_) : value(std::move(value_)) {}
+
+        EntityPath& operator=(rerun::datatypes::EntityPath value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        EntityPath(std::string path_) : value(std::move(path_)) {}
+
+        EntityPath& operator=(std::string path_) {
+            value = std::move(path_);
+            return *this;
+        }
+
+        /// Cast to the underlying EntityPath datatype
+        operator rerun::datatypes::EntityPath() const {
+            return value;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::EntityPath) == sizeof(components::EntityPath));
+
+    /// \private
+    template <>
+    struct Loggable<components::EntityPath> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.EntityPath";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::EntityPath>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::EntityPath` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::EntityPath* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::EntityPath>::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::EntityPath>::to_arrow(
+                    &instances->value,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/fill_mode.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/fill_mode.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**: How a geometric shape is drawn and colored.
+    enum class FillMode : uint8_t {
+
+        /// Lines are drawn around the parts of the shape which directly correspond to the logged data.
+        ///
+        /// Examples of what this means:
+        ///
+        /// * An `archetypes::Ellipsoids3D` will draw three axis-aligned ellipses that are cross-sections
+        ///   of each ellipsoid, each of which displays two out of three of the sizes of the ellipsoid.
+        /// * For `archetypes::Boxes3D`, it is the edges of the box, identical to `components::FillMode::DenseWireframe`.
+        MajorWireframe = 1,
+
+        /// Many lines are drawn to represent the surface of the shape in a see-through fashion.
+        ///
+        /// Examples of what this means:
+        ///
+        /// * An `archetypes::Ellipsoids3D` will draw a wireframe triangle mesh that approximates each
+        ///   ellipsoid.
+        /// * For `archetypes::Boxes3D`, it is the edges of the box, identical to `components::FillMode::MajorWireframe`.
+        DenseWireframe = 2,
+
+        /// The surface of the shape is filled in with a solid color. No lines are drawn.
+        Solid = 3,
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::FillMode> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.FillMode";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::FillMode` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::FillMode* 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::FillMode* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/components/fill_ratio.hpp

@@ -0,0 +1,79 @@
+// 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/fill_ratio.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: How much a primitive fills out the available space.
+    ///
+    /// Used for instance to scale the points of the point cloud created from `archetypes::DepthImage` projection in 3D views.
+    /// Valid range is from 0 to max float although typically values above 1.0 are not useful.
+    ///
+    /// Defaults to 1.0.
+    struct FillRatio {
+        rerun::datatypes::Float32 value;
+
+      public:
+        FillRatio() = default;
+
+        FillRatio(rerun::datatypes::Float32 value_) : value(value_) {}
+
+        FillRatio& operator=(rerun::datatypes::Float32 value_) {
+            value = value_;
+            return *this;
+        }
+
+        FillRatio(float value_) : value(value_) {}
+
+        FillRatio& 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::FillRatio));
+
+    /// \private
+    template <>
+    struct Loggable<components::FillRatio> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.FillRatio";
+
+        /// 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::FillRatio` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::FillRatio* 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/gamma_correction.hpp

@@ -0,0 +1,80 @@
+// 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/gamma_correction.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A gamma correction value to be used with a scalar value or color.
+    ///
+    /// Used to adjust the gamma of a color or scalar value between 0 and 1 before rendering.
+    /// `new_value = old_value ^ gamma`
+    ///
+    /// Must be a positive number.
+    /// Defaults to 1.0 unless otherwise specified.
+    struct GammaCorrection {
+        rerun::datatypes::Float32 gamma;
+
+      public:
+        GammaCorrection() = default;
+
+        GammaCorrection(rerun::datatypes::Float32 gamma_) : gamma(gamma_) {}
+
+        GammaCorrection& operator=(rerun::datatypes::Float32 gamma_) {
+            gamma = gamma_;
+            return *this;
+        }
+
+        GammaCorrection(float value_) : gamma(value_) {}
+
+        GammaCorrection& operator=(float value_) {
+            gamma = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float32 datatype
+        operator rerun::datatypes::Float32() const {
+            return gamma;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float32) == sizeof(components::GammaCorrection));
+
+    /// \private
+    template <>
+    struct Loggable<components::GammaCorrection> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.GammaCorrection";
+
+        /// 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::GammaCorrection` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::GammaCorrection* 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->gamma,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/geo_line_string.hpp

@@ -0,0 +1,63 @@
+// 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/geo_line_string.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_descriptor.hpp"
+#include "../datatypes/dvec2d.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class ListBuilder;
+} // namespace arrow
+
+namespace rerun::components {
+    /// **Component**: A geospatial line string expressed in [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees).
+    struct GeoLineString {
+        rerun::Collection<rerun::datatypes::DVec2D> lat_lon;
+
+      public: // START of extensions from geo_line_string_ext.cpp:
+        /// Creates a new GeoLineString object based on [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees).
+        static GeoLineString from_lat_lon(Collection<datatypes::DVec2D> lat_lon_) {
+            GeoLineString line_string;
+            line_string.lat_lon = std::move(lat_lon_);
+            return line_string;
+        }
+
+        // END of extensions from geo_line_string_ext.cpp, start of generated code:
+
+      public:
+        GeoLineString() = default;
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::GeoLineString> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.GeoLineString";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::GeoLineString` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::GeoLineString* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::ListBuilder* builder, const components::GeoLineString* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/components/graph_edge.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/graph_edge.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/utf8pair.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace rerun::components {
+    /// **Component**: An edge in a graph connecting two nodes.
+    struct GraphEdge {
+        rerun::datatypes::Utf8Pair edge;
+
+      public: // START of extensions from graph_edge_ext.cpp:
+        /// Create a new graph edge from a pair of strings.
+        GraphEdge(rerun::datatypes::Utf8 first_, rerun::datatypes::Utf8 second_)
+            : edge(std::move(first_), std::move(second_)) {}
+
+        // END of extensions from graph_edge_ext.cpp, start of generated code:
+
+      public:
+        GraphEdge() = default;
+
+        GraphEdge(rerun::datatypes::Utf8Pair edge_) : edge(std::move(edge_)) {}
+
+        GraphEdge& operator=(rerun::datatypes::Utf8Pair edge_) {
+            edge = std::move(edge_);
+            return *this;
+        }
+
+        /// Cast to the underlying Utf8Pair datatype
+        operator rerun::datatypes::Utf8Pair() const {
+            return edge;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Utf8Pair) == sizeof(components::GraphEdge));
+
+    /// \private
+    template <>
+    struct Loggable<components::GraphEdge> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.GraphEdge";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Utf8Pair>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::GraphEdge` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::GraphEdge* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Utf8Pair>::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::Utf8Pair>::to_arrow(
+                    &instances->edge,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/graph_node.hpp

@@ -0,0 +1,79 @@
+// 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/graph_node.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-based ID representing a node in a graph.
+    struct GraphNode {
+        rerun::datatypes::Utf8 id;
+
+      public: // START of extensions from graph_node_ext.cpp:
+        /// Create a new graph edge from a c string.
+        GraphNode(const char* value_) : id(value_) {}
+
+        // END of extensions from graph_node_ext.cpp, start of generated code:
+
+      public:
+        GraphNode() = default;
+
+        GraphNode(rerun::datatypes::Utf8 id_) : id(std::move(id_)) {}
+
+        GraphNode& operator=(rerun::datatypes::Utf8 id_) {
+            id = std::move(id_);
+            return *this;
+        }
+
+        GraphNode(std::string value_) : id(std::move(value_)) {}
+
+        GraphNode& operator=(std::string value_) {
+            id = std::move(value_);
+            return *this;
+        }
+
+        /// Cast to the underlying Utf8 datatype
+        operator rerun::datatypes::Utf8() const {
+            return id;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Utf8) == sizeof(components::GraphNode));
+
+    /// \private
+    template <>
+    struct Loggable<components::GraphNode> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.GraphNode";
+
+        /// 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::GraphNode` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::GraphNode* 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->id, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/graph_type.hpp

@@ -0,0 +1,57 @@
+// 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/graph_type.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 if a graph has directed or undirected edges.
+    enum class GraphType : uint8_t {
+
+        /// The graph has undirected edges.
+        Undirected = 1,
+
+        /// The graph has directed edges.
+        Directed = 2,
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::GraphType> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.GraphType";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::GraphType` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::GraphType* 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::GraphType* elements, size_t num_elements
+        );
+    };
+} // namespace rerun