pymomentum-cpu 0.1.84.post0__cp313-cp313-macosx_14_0_arm64.whl

include/rerun/datatypes/entity_path.hpp

@@ -0,0 +1,60 @@
+// 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/entity_path.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StringBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A path to an entity in the `ChunkStore`.
+    struct EntityPath {
+        std::string path;
+
+      public:
+        EntityPath() = default;
+
+        EntityPath(std::string path_) : path(std::move(path_)) {}
+
+        EntityPath& operator=(std::string path_) {
+            path = std::move(path_);
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::EntityPath> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.EntityPath";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::EntityPath` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::EntityPath* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StringBuilder* builder, const datatypes::EntityPath* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/float32.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/float32.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 FloatType;
+    using FloatBuilder = NumericBuilder<FloatType>;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A single-precision 32-bit IEEE 754 floating point number.
+    struct Float32 {
+        float value;
+
+      public:
+        Float32() = default;
+
+        Float32(float value_) : value(value_) {}
+
+        Float32& operator=(float value_) {
+            value = value_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Float32> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Float32";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Float32` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Float32* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::FloatBuilder* builder, const datatypes::Float32* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/float64.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/float64.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 DoubleType;
+    using DoubleBuilder = NumericBuilder<DoubleType>;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A double-precision 64-bit IEEE 754 floating point number.
+    struct Float64 {
+        double value;
+
+      public:
+        Float64() = default;
+
+        Float64(double value_) : value(value_) {}
+
+        Float64& operator=(double value_) {
+            value = value_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Float64> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Float64";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Float64` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Float64* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::DoubleBuilder* builder, const datatypes::Float64* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/image_format.hpp

@@ -0,0 +1,107 @@
+// 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/image_format.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../image_utils.hpp"
+#include "../result.hpp"
+#include "channel_datatype.hpp"
+#include "color_model.hpp"
+#include "pixel_format.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: The metadata describing the contents of a `components::ImageBuffer`.
+    struct ImageFormat {
+        /// The width of the image in pixels.
+        uint32_t width;
+
+        /// The height of the image in pixels.
+        uint32_t height;
+
+        /// Used mainly for chroma downsampled formats and differing number of bits per channel.
+        ///
+        /// If specified, this takes precedence over both `datatypes::ColorModel` and `datatypes::ChannelDatatype` (which are ignored).
+        std::optional<rerun::datatypes::PixelFormat> pixel_format;
+
+        /// L, RGB, RGBA, …
+        ///
+        /// Also requires a `datatypes::ChannelDatatype` to fully specify the pixel format.
+        std::optional<rerun::datatypes::ColorModel> color_model;
+
+        /// The data type of each channel (e.g. the red channel) of the image data (U8, F16, …).
+        ///
+        /// Also requires a `datatypes::ColorModel` to fully specify the pixel format.
+        std::optional<rerun::datatypes::ChannelDatatype> channel_datatype;
+
+      public: // START of extensions from image_format_ext.cpp:
+        /// From a specific pixel format.
+        ImageFormat(rerun::WidthHeight resolution, datatypes::PixelFormat pixel_format_)
+            : width(resolution.width), height(resolution.height), pixel_format(pixel_format_) {}
+
+        /// Create a new image format for depth or segmentation images with the given resolution and datatype.
+        ImageFormat(rerun::WidthHeight resolution, datatypes::ChannelDatatype datatype_)
+            : width(resolution.width), height(resolution.height), channel_datatype(datatype_) {}
+
+        ImageFormat(
+            rerun::WidthHeight resolution, datatypes::ColorModel color_model_,
+            datatypes::ChannelDatatype datatype_
+        )
+            : width(resolution.width),
+              height(resolution.height),
+              color_model(color_model_),
+              channel_datatype(datatype_) {}
+
+        /// How many bytes will this image occupy?
+        size_t num_bytes() const {
+            if (pixel_format) {
+                return pixel_format_num_bytes({width, height}, *pixel_format);
+            } else {
+                auto cm = color_model.value_or(datatypes::ColorModel::L);
+                auto dt = channel_datatype.value_or(datatypes::ChannelDatatype::U8);
+                auto bits_per_pixel = color_model_channel_count(cm) * datatype_bits(dt);
+                return (width * height * bits_per_pixel + 7) / 8; // Rounding up
+            }
+        }
+
+        // END of extensions from image_format_ext.cpp, start of generated code:
+
+      public:
+        ImageFormat() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::ImageFormat> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.ImageFormat";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::ImageFormat` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::ImageFormat* 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::ImageFormat* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/keypoint_id.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/datatypes/keypoint_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 keypoint within a class.
+    struct KeypointId {
+        uint16_t id;
+
+      public:
+        KeypointId() = default;
+
+        KeypointId(uint16_t id_) : id(id_) {}
+
+        KeypointId& operator=(uint16_t id_) {
+            id = id_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::KeypointId> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.KeypointId";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::KeypointId` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::KeypointId* 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::KeypointId* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/keypoint_pair.hpp

@@ -0,0 +1,65 @@
+// 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/keypoint_pair.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "keypoint_id.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A connection between two `datatypes::KeypointId`s.
+    struct KeypointPair {
+        /// The first point of the pair.
+        rerun::datatypes::KeypointId keypoint0;
+
+        /// The second point of the pair.
+        rerun::datatypes::KeypointId keypoint1;
+
+      public: // START of extensions from keypoint_pair_ext.cpp:
+        KeypointPair(uint16_t _keypoint0, uint16_t _keypoint1)
+            : keypoint0(_keypoint0), keypoint1(_keypoint1) {}
+
+        KeypointPair(std::pair<uint16_t, uint16_t> pair)
+            : keypoint0(pair.first), keypoint1(pair.second) {}
+
+        // END of extensions from keypoint_pair_ext.cpp, start of generated code:
+
+      public:
+        KeypointPair() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::KeypointPair> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.KeypointPair";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::KeypointPair` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::KeypointPair* 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::KeypointPair* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/mat3x3.hpp

@@ -0,0 +1,105 @@
+// 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/mat3x3.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../rerun_sdk_export.hpp"
+#include "../result.hpp"
+#include "vec3d.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A 3x3 Matrix.
+    ///
+    /// 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 Mat3x3 {
+        /// Flat list of matrix coefficients in column-major order.
+        std::array<float, 9> flat_columns;
+
+      public: // START of extensions from mat3x3_ext.cpp:
+        static const Mat3x3 IDENTITY;
+        static const Mat3x3 INVALID;
+
+        /// Creates a new 3x3 matrix from 3 *columns* of 3 elements each.
+        Mat3x3(const Vec3D (&columns)[3])
+            : flat_columns{
+                  columns[0].x(),
+                  columns[0].y(),
+                  columns[0].z(),
+                  columns[1].x(),
+                  columns[1].y(),
+                  columns[1].z(),
+                  columns[2].x(),
+                  columns[2].y(),
+                  columns[2].z(),
+              } {}
+
+        /// Construct a new 3x3 matrix from a pointer to 9 floats (in column major order).
+        explicit Mat3x3(const float* elements)
+            : flat_columns{
+                  elements[0],
+                  elements[1],
+                  elements[2],
+                  elements[3],
+                  elements[4],
+                  elements[5],
+                  elements[6],
+                  elements[7],
+                  elements[8],
+              } {}
+
+        // END of extensions from mat3x3_ext.cpp, start of generated code:
+
+      public:
+        Mat3x3() = default;
+
+        Mat3x3(std::array<float, 9> flat_columns_) : flat_columns(flat_columns_) {}
+
+        Mat3x3& operator=(std::array<float, 9> flat_columns_) {
+            flat_columns = flat_columns_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Mat3x3> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Mat3x3";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Mat3x3` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Mat3x3* 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::Mat3x3* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/mat4x4.hpp

@@ -0,0 +1,119 @@
+// 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/mat4x4.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../rerun_sdk_export.hpp"
+#include "../result.hpp"
+#include "vec4d.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class FixedSizeListBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: A 4x4 Matrix.
+    ///
+    /// Matrices in Rerun are stored as flat list of coefficients in column-major order:
+    /// ```text
+    ///            column 0         column 1         column 2         column 3
+    ///        --------------------------------------------------------------------
+    /// row 0 | flat_columns[0]  flat_columns[4]  flat_columns[8]  flat_columns[12]
+    /// row 1 | flat_columns[1]  flat_columns[5]  flat_columns[9]  flat_columns[13]
+    /// row 2 | flat_columns[2]  flat_columns[6]  flat_columns[10] flat_columns[14]
+    /// row 3 | flat_columns[3]  flat_columns[7]  flat_columns[11] flat_columns[15]
+    /// ```
+    struct Mat4x4 {
+        /// Flat list of matrix coefficients in column-major order.
+        std::array<float, 16> flat_columns;
+
+      public: // START of extensions from mat4x4_ext.cpp:
+        RERUN_SDK_EXPORT static const Mat4x4 IDENTITY;
+
+        /// Creates a new 4x4 matrix from 3 *columns* of 4 elements each.
+        Mat4x4(const Vec4D (&columns)[4])
+            : flat_columns{
+                  columns[0].x(),
+                  columns[0].y(),
+                  columns[0].z(),
+                  columns[0].w(),
+                  columns[1].x(),
+                  columns[1].y(),
+                  columns[1].z(),
+                  columns[1].w(),
+                  columns[2].x(),
+                  columns[2].y(),
+                  columns[2].z(),
+                  columns[2].w(),
+                  columns[3].x(),
+                  columns[3].y(),
+                  columns[3].z(),
+                  columns[3].w(),
+              } {}
+
+        /// Construct a new 4x4 matrix from a pointer to 16 floats (in column major order).
+        explicit Mat4x4(const float* elements)
+            : flat_columns{
+                  elements[0],
+                  elements[1],
+                  elements[2],
+                  elements[3],
+                  elements[4],
+                  elements[5],
+                  elements[6],
+                  elements[7],
+                  elements[8],
+                  elements[9],
+                  elements[10],
+                  elements[11],
+                  elements[12],
+                  elements[13],
+                  elements[14],
+                  elements[15],
+              } {}
+
+        // END of extensions from mat4x4_ext.cpp, start of generated code:
+
+      public:
+        Mat4x4() = default;
+
+        Mat4x4(std::array<float, 16> flat_columns_) : flat_columns(flat_columns_) {}
+
+        Mat4x4& operator=(std::array<float, 16> flat_columns_) {
+            flat_columns = flat_columns_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Mat4x4> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Mat4x4";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Mat4x4` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Mat4x4* 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::Mat4x4* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun