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

include/rerun/datatypes/annotation_info.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/datatypes/annotation_info.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "rgba32.hpp"
+#include "utf8.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: Annotation info annotating a class id or key-point id.
+    ///
+    /// Color and label will be used to annotate entities/keypoints which reference the id.
+    /// The id refers either to a class or key-point id
+    struct AnnotationInfo {
+        /// `datatypes::ClassId` or `datatypes::KeypointId` to which this annotation info belongs.
+        uint16_t id;
+
+        /// The label that will be shown in the UI.
+        std::optional<rerun::datatypes::Utf8> label;
+
+        /// The color that will be applied to the annotated entity.
+        std::optional<rerun::datatypes::Rgba32> color;
+
+      public: // START of extensions from annotation_info_ext.cpp:
+        AnnotationInfo(
+            uint16_t _id, std::optional<std::string> _label = std::nullopt,
+            std::optional<datatypes::Rgba32> _color = std::nullopt
+        )
+            : id(_id), label(std::move(_label)), color(_color) {}
+
+        AnnotationInfo(uint16_t _id, datatypes::Rgba32 _color)
+            : id(_id), label(std::nullopt), color(_color) {}
+
+        // END of extensions from annotation_info_ext.cpp, start of generated code:
+
+      public:
+        AnnotationInfo() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::AnnotationInfo> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.AnnotationInfo";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::AnnotationInfo` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::AnnotationInfo* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StructBuilder* builder, const datatypes::AnnotationInfo* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/blob.hpp

@@ -0,0 +1,67 @@
+// 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/datatypes/blob.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class ListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A binary blob of data.
+    struct Blob {
+        rerun::Collection<uint8_t> data;
+
+      public: // START of extensions from blob_ext.cpp:
+        /// Number of bytes
+        size_t size() const {
+            return data.size();
+        }
+
+        // END of extensions from blob_ext.cpp, start of generated code:
+
+      public:
+        Blob() = default;
+
+        Blob(rerun::Collection<uint8_t> data_) : data(std::move(data_)) {}
+
+        Blob& operator=(rerun::Collection<uint8_t> data_) {
+            data = std::move(data_);
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Blob> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Blob";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Blob` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Blob* 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 datatypes::Blob* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/bool.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/datatypes/bool.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class BooleanBuilder;
+    class DataType;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A single boolean.
+    struct Bool {
+        bool value;
+
+      public:
+        Bool() = default;
+
+        Bool(bool value_) : value(value_) {}
+
+        Bool& operator=(bool value_) {
+            value = value_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Bool> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Bool";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Bool` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Bool* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::BooleanBuilder* builder, const datatypes::Bool* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/channel_datatype.hpp

@@ -0,0 +1,87 @@
+// 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/datatypes/channel_datatype.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::datatypes {
+    /// **Datatype**: The innermost datatype of an image.
+    ///
+    /// How individual color channel components are encoded.
+    enum class ChannelDatatype : uint8_t {
+
+        /// 8-bit unsigned integer.
+        U8 = 6,
+
+        /// 8-bit signed integer.
+        I8 = 7,
+
+        /// 16-bit unsigned integer.
+        U16 = 8,
+
+        /// 16-bit signed integer.
+        I16 = 9,
+
+        /// 32-bit unsigned integer.
+        U32 = 10,
+
+        /// 32-bit signed integer.
+        I32 = 11,
+
+        /// 64-bit unsigned integer.
+        U64 = 12,
+
+        /// 64-bit signed integer.
+        I64 = 13,
+
+        /// 16-bit IEEE-754 floating point, also known as `half`.
+        F16 = 33,
+
+        /// 32-bit IEEE-754 floating point, also known as `float` or `single`.
+        F32 = 34,
+
+        /// 64-bit IEEE-754 floating point, also known as `double`.
+        F64 = 35,
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::ChannelDatatype> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.ChannelDatatype";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::ChannelDatatype` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::ChannelDatatype* 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 datatypes::ChannelDatatype* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/class_description.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/datatypes/class_description.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "annotation_info.hpp"
+#include "keypoint_pair.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: The description of a semantic Class.
+    ///
+    /// If an entity is annotated with a corresponding `components::ClassId`, Rerun will use
+    /// the attached `datatypes::AnnotationInfo` to derive labels and colors.
+    ///
+    /// Keypoints within an annotation class can similarly be annotated with a
+    /// `components::KeypointId` in which case we should defer to the label and color for the
+    /// `datatypes::AnnotationInfo` specifically associated with the Keypoint.
+    ///
+    /// Keypoints within the class can also be decorated with skeletal edges.
+    /// Keypoint-connections are pairs of `components::KeypointId`s. If an edge is
+    /// defined, and both keypoints exist within the instance of the class, then the
+    /// keypoints should be connected with an edge. The edge should be labeled and
+    /// colored as described by the class's `datatypes::AnnotationInfo`.
+    struct ClassDescription {
+        /// The `datatypes::AnnotationInfo` for the class.
+        rerun::datatypes::AnnotationInfo info;
+
+        /// The `datatypes::AnnotationInfo` for all of the keypoints.
+        rerun::Collection<rerun::datatypes::AnnotationInfo> keypoint_annotations;
+
+        /// The connections between keypoints.
+        rerun::Collection<rerun::datatypes::KeypointPair> keypoint_connections;
+
+      public: // START of extensions from class_description_ext.cpp:
+        /// Create a new `ClassDescription` from a single annotation info.
+        ClassDescription(
+            uint16_t id, std::optional<std::string> label = std::nullopt,
+            std::optional<datatypes::Rgba32> color = std::nullopt
+        )
+            : info(id, label, color) {}
+
+        ClassDescription(
+            AnnotationInfo info_, Collection<AnnotationInfo> keypoint_annotations_ = {},
+            Collection<KeypointPair> keypoint_connections_ = {}
+        )
+            : info(std::move(info_)),
+              keypoint_annotations(std::move(keypoint_annotations_)),
+              keypoint_connections(std::move(keypoint_connections_)) {}
+
+        // END of extensions from class_description_ext.cpp, start of generated code:
+
+      public:
+        ClassDescription() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::ClassDescription> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.ClassDescription";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::ClassDescription` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::ClassDescription* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StructBuilder* builder, const datatypes::ClassDescription* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/class_description_map_elem.hpp

@@ -0,0 +1,69 @@
+// 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/datatypes/class_description_map_elem.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "class_description.hpp"
+#include "class_id.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A helper type for mapping `datatypes::ClassId`s to class descriptions.
+    ///
+    /// This is internal to `components::AnnotationContext`.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ClassDescriptionMapElem {
+        /// The key: the `components::ClassId`.
+        rerun::datatypes::ClassId class_id;
+
+        /// The value: class name, color, etc.
+        rerun::datatypes::ClassDescription class_description;
+
+      public: // START of extensions from class_description_map_elem_ext.cpp:
+        ClassDescriptionMapElem(ClassDescription _class_description)
+            : class_id(_class_description.info.id),
+              class_description(std::move(_class_description)) {}
+
+        // END of extensions from class_description_map_elem_ext.cpp, start of generated code:
+
+      public:
+        ClassDescriptionMapElem() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::ClassDescriptionMapElem> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.ClassDescriptionMapElem";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::ClassDescriptionMapElem` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::ClassDescriptionMapElem* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StructBuilder* builder, const datatypes::ClassDescriptionMapElem* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/class_id.hpp

@@ -0,0 +1,62 @@
+// 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/datatypes/class_id.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 UInt16Type;
+    using UInt16Builder = NumericBuilder<UInt16Type>;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A 16-bit ID representing a type of semantic class.
+    struct ClassId {
+        uint16_t id;
+
+      public:
+        ClassId() = default;
+
+        ClassId(uint16_t id_) : id(id_) {}
+
+        ClassId& operator=(uint16_t id_) {
+            id = id_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::ClassId> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.ClassId";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::ClassId` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::ClassId* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::UInt16Builder* builder, const datatypes::ClassId* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/color_model.hpp

@@ -0,0 +1,68 @@
+// 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/datatypes/color_model.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::datatypes {
+    /// **Datatype**: Specified what color components are present in an `archetypes::Image`.
+    ///
+    /// This combined with `datatypes::ChannelDatatype` determines the pixel format of an image.
+    enum class ColorModel : uint8_t {
+
+        /// Grayscale luminance intencity/brightness/value, sometimes called `Y`
+        L = 1,
+
+        /// Red, Green, Blue
+        RGB = 2,
+
+        /// Red, Green, Blue, Alpha
+        RGBA = 3,
+
+        /// Blue, Green, Red
+        BGR = 4,
+
+        /// Blue, Green, Red, Alpha
+        BGRA = 5,
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::ColorModel> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.ColorModel";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::ColorModel` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::ColorModel* 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 datatypes::ColorModel* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/dvec2d.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/datatypes/dvec2d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A double-precision vector in 2D space.
+    struct DVec2D {
+        std::array<double, 2> xy;
+
+      public: // START of extensions from dvec2d_ext.cpp:
+        /// Construct DVec2D from x/y values.
+        DVec2D(double x, double y) : xy{x, y} {}
+
+        /// Construct DVec2D from x/y double pointer.
+        explicit DVec2D(const double* xy_) : xy{xy_[0], xy_[1]} {}
+
+        double x() const {
+            return xy[0];
+        }
+
+        double y() const {
+            return xy[1];
+        }
+
+        // END of extensions from dvec2d_ext.cpp, start of generated code:
+
+      public:
+        DVec2D() = default;
+
+        DVec2D(std::array<double, 2> xy_) : xy(xy_) {}
+
+        DVec2D& operator=(std::array<double, 2> xy_) {
+            xy = xy_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::DVec2D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.DVec2D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::DVec2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::DVec2D* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::FixedSizeListBuilder* builder, const datatypes::DVec2D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun