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

include/rerun/datatypes/pixel_format.hpp

@@ -0,0 +1,142 @@
+// 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/pixel_format.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**: Specifieds a particular format of an `archetypes::Image`.
+    ///
+    /// Most images can be described by a `datatypes::ColorModel` and a `datatypes::ChannelDatatype`,
+    /// e.g. `RGB` and `U8` respectively.
+    ///
+    /// However, some image formats has chroma downsampling and/or
+    /// use differing number of bits per channel, and that is what this `datatypes::PixelFormat` is for.
+    ///
+    /// All these formats support random access.
+    ///
+    /// For more compressed image formats, see `archetypes::EncodedImage`.
+    enum class PixelFormat : uint8_t {
+
+        /// `Y_U_V12` is a YUV 4:2:0 fully planar YUV format without chroma downsampling, also known as `I420`.
+        ///
+        /// This uses limited range YUV, i.e. Y is expected to be within [16, 235] and U/V within [16, 240].
+        ///
+        /// First comes entire image in Y in one plane, followed by the U and V planes, which each only have half
+        /// the resolution of the Y plane.
+        Y_U_V12_LimitedRange = 20,
+
+        /// `NV12` (aka `Y_UV12`) is a YUV 4:2:0 chroma downsampled form at with 12 bits per pixel and 8 bits per channel.
+        ///
+        /// This uses limited range YUV, i.e. Y is expected to be within [16, 235] and U/V within [16, 240].
+        ///
+        /// First comes entire image in Y in one plane,
+        /// followed by a plane with interleaved lines ordered as U0, V0, U1, V1, etc.
+        NV12 = 26,
+
+        /// `YUY2` (aka 'YUYV', 'YUYV16' or 'NV21'), is a YUV 4:2:2 chroma downsampled format with 16 bits per pixel and 8 bits per channel.
+        ///
+        /// This uses limited range YUV, i.e. Y is expected to be within [16, 235] and U/V within [16, 240].
+        ///
+        /// The order of the channels is Y0, U0, Y1, V0, all in the same plane.
+        YUY2 = 27,
+
+        /// Monochrome Y plane only, essentially a YUV 4:0:0 planar format.
+        ///
+        /// Also known as just "gray". This is virtually identical to a 8bit luminance/grayscale (see `datatypes::ColorModel`).
+        ///
+        /// This uses entire range YUV, i.e. Y is expected to be within [0, 255].
+        /// (as opposed to "limited range" YUV as used e.g. in NV12).
+        Y8_FullRange = 30,
+
+        /// `Y_U_V24` is a YUV 4:4:4 fully planar YUV format without chroma downsampling, also known as `I444`.
+        ///
+        /// This uses limited range YUV, i.e. Y is expected to be within [16, 235] and U/V within [16, 240].
+        ///
+        /// First comes entire image in Y in one plane, followed by the U and V planes.
+        Y_U_V24_LimitedRange = 39,
+
+        /// `Y_U_V24` is a YUV 4:4:4 fully planar YUV format without chroma downsampling, also known as `I444`.
+        ///
+        /// This uses full range YUV with all components ranging from 0 to 255
+        /// (as opposed to "limited range" YUV as used e.g. in NV12).
+        ///
+        /// First comes entire image in Y in one plane, followed by the U and V planes.
+        Y_U_V24_FullRange = 40,
+
+        /// Monochrome Y plane only, essentially a YUV 4:0:0 planar format.
+        ///
+        /// Also known as just "gray".
+        ///
+        /// This uses limited range YUV, i.e. Y is expected to be within [16, 235].
+        /// If not for this range limitation/remapping, this is almost identical to 8bit luminace/grayscale (see `datatypes::ColorModel`).
+        Y8_LimitedRange = 41,
+
+        /// `Y_U_V12` is a YUV 4:2:0 fully planar YUV format without chroma downsampling, also known as `I420`.
+        ///
+        /// This uses full range YUV with all components ranging from 0 to 255
+        /// (as opposed to "limited range" YUV as used e.g. in NV12).
+        ///
+        /// First comes entire image in Y in one plane, followed by the U and V planes, which each only have half
+        /// the resolution of the Y plane.
+        Y_U_V12_FullRange = 44,
+
+        /// `Y_U_V16` is a YUV 4:2:2 fully planar YUV format without chroma downsampling, also known as `I422`.
+        ///
+        /// This uses limited range YUV, i.e. Y is expected to be within [16, 235] and U/V within [16, 240].
+        ///
+        /// First comes entire image in Y in one plane, followed by the U and V planes, which each only have half
+        /// the horizontal resolution of the Y plane.
+        Y_U_V16_LimitedRange = 49,
+
+        /// `Y_U_V16` is a YUV 4:2:2 fully planar YUV format without chroma downsampling, also known as `I422`.
+        ///
+        /// This uses full range YUV with all components ranging from 0 to 255
+        /// (as opposed to "limited range" YUV as used e.g. in NV12).
+        ///
+        /// First comes entire image in Y in one plane, followed by the U and V planes, which each only have half
+        /// the horizontal resolution of the Y plane.
+        Y_U_V16_FullRange = 50,
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::PixelFormat> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.PixelFormat";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::PixelFormat` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::PixelFormat* 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::PixelFormat* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/plane3d.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/plane3d.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**: An infinite 3D plane represented by a unit normal vector and a distance.
+    ///
+    /// Any point P on the plane fulfills the equation `dot(xyz, P) - d = 0`,
+    /// where `xyz` is the plane's normal and `d` the distance of the plane from the origin.
+    /// This representation is also known as the Hesse normal form.
+    ///
+    /// Note: although the normal will be passed through to the
+    /// datastore as provided, when used in the Viewer, planes will always be normalized.
+    /// I.e. the plane with xyz = (2, 0, 0), d = 1 is equivalent to xyz = (1, 0, 0), d = 0.5
+    struct Plane3D {
+        std::array<float, 4> xyzd;
+
+      public:
+        Plane3D() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Plane3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Plane3D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Plane3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Plane3D* 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::Plane3D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/quaternion.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/datatypes/quaternion.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../rerun_sdk_export.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 Quaternion represented by 4 real numbers.
+    ///
+    /// Note: although the x,y,z,w components of the quaternion will be passed through to the
+    /// datastore as provided, when used in the Viewer Quaternions will always be normalized.
+    struct Quaternion {
+        std::array<float, 4> xyzw;
+
+      public: // START of extensions from quaternion_ext.cpp:
+        RERUN_SDK_EXPORT static const Quaternion IDENTITY;
+        RERUN_SDK_EXPORT static const Quaternion INVALID;
+
+        /// Construct Quaternion from x/y/z/w values.
+        static Quaternion from_xyzw(float x, float y, float z, float w) {
+            return Quaternion::from_xyzw({x, y, z, w});
+        }
+
+        /// Construct Quaternion from w/x/y/z values.
+        static Quaternion from_wxyz(float w, float x, float y, float z) {
+            return Quaternion::from_xyzw(x, y, z, w);
+        }
+
+        /// Construct Quaternion from x/y/z/w array.
+        static Quaternion from_xyzw(std::array<float, 4> xyzw_) {
+            Quaternion q;
+            q.xyzw = xyzw_;
+            return q;
+        }
+
+        /// Construct Quaternion from w/x/y/z array.
+        static Quaternion from_wxyz(std::array<float, 4> wxyz_) {
+            return Quaternion::from_xyzw(wxyz_[1], wxyz_[2], wxyz_[3], wxyz_[0]);
+        }
+
+        /// Construct Quaternion from x/y/z/w float pointer.
+        static Quaternion from_xyzw(const float* xyzw_) {
+            return Quaternion::from_xyzw(xyzw_[0], xyzw_[1], xyzw_[2], xyzw_[3]);
+        }
+
+        /// Construct Quaternion from w/x/y/z float pointer.
+        static Quaternion from_wxyz(const float* wxyz_) {
+            return Quaternion::from_xyzw(wxyz_[1], wxyz_[2], wxyz_[3], wxyz_[0]);
+        }
+
+        float x() const {
+            return xyzw[0];
+        }
+
+        float y() const {
+            return xyzw[1];
+        }
+
+        float z() const {
+            return xyzw[2];
+        }
+
+        float w() const {
+            return xyzw[3];
+        }
+
+        // END of extensions from quaternion_ext.cpp, start of generated code:
+
+      public:
+        Quaternion() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Quaternion> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Quaternion";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Quaternion` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Quaternion* 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::Quaternion* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/range1d.hpp

@@ -0,0 +1,59 @@
+// 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/range1d.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 1D range, specifying a lower and upper bound.
+    struct Range1D {
+        std::array<double, 2> range;
+
+      public:
+        Range1D() = default;
+
+        Range1D(std::array<double, 2> range_) : range(range_) {}
+
+        Range1D& operator=(std::array<double, 2> range_) {
+            range = range_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Range1D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Range1D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Range1D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Range1D* 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::Range1D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/range2d.hpp

@@ -0,0 +1,55 @@
+// 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/range2d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "range1d.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: An Axis-Aligned Bounding Box in 2D space, implemented as the minimum and maximum corners.
+    struct Range2D {
+        /// The range of the X-axis (usually left and right bounds).
+        rerun::datatypes::Range1D x_range;
+
+        /// The range of the Y-axis (usually top and bottom bounds).
+        rerun::datatypes::Range1D y_range;
+
+      public:
+        Range2D() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Range2D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Range2D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Range2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Range2D* 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::Range2D* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/rgba32.hpp

@@ -0,0 +1,94 @@
+// 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/rgba32.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 UInt32Type;
+    using UInt32Builder = NumericBuilder<UInt32Type>;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: An RGBA color with unmultiplied/separate alpha, in sRGB gamma space with linear alpha.
+    ///
+    /// The color is stored as a 32-bit integer, where the most significant
+    /// byte is `R` and the least significant byte is `A`.
+    struct Rgba32 {
+        uint32_t rgba;
+
+      public: // START of extensions from rgba32_ext.cpp:
+        /// Construct Rgba32 from unmultiplied RGBA values.
+        Rgba32(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
+            : Rgba32(static_cast<uint32_t>((r << 24) | (g << 16) | (b << 8) | a)) {}
+
+        /// Construct Rgba32 from unmultiplied RGBA values.
+        Rgba32(const uint8_t (&_rgba)[4]) : Rgba32(_rgba[0], _rgba[1], _rgba[2], _rgba[3]) {}
+
+        /// Construct Rgba32 from RGB values, setting alpha to 255.
+        Rgba32(const uint8_t (&_rgb)[3]) : Rgba32(_rgb[0], _rgb[1], _rgb[2]) {}
+
+        uint8_t r() const {
+            return static_cast<uint8_t>((rgba >> 24) & 0xFF);
+        }
+
+        uint8_t g() const {
+            return static_cast<uint8_t>((rgba >> 16) & 0xFF);
+        }
+
+        uint8_t b() const {
+            return static_cast<uint8_t>((rgba >> 8) & 0xFF);
+        }
+
+        uint8_t a() const {
+            return static_cast<uint8_t>(rgba & 0xFF);
+        }
+
+        // END of extensions from rgba32_ext.cpp, start of generated code:
+
+      public:
+        Rgba32() = default;
+
+        Rgba32(uint32_t rgba_) : rgba(rgba_) {}
+
+        Rgba32& operator=(uint32_t rgba_) {
+            rgba = rgba_;
+            return *this;
+        }
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::Rgba32> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.Rgba32";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::Rgba32` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::Rgba32* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::UInt32Builder* builder, const datatypes::Rgba32* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/rotation_axis_angle.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/rotation_axis_angle.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "angle.hpp"
+#include "vec3d.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: 3D rotation represented by a rotation around a given axis.
+    struct RotationAxisAngle {
+        /// Axis to rotate around.
+        ///
+        /// This is not required to be normalized.
+        /// However, if normalization of the rotation axis fails (typically due to a zero vector)
+        /// the rotation is treated as an invalid transform, unless the angle is zero in which case
+        /// it is treated as an identity.
+        rerun::datatypes::Vec3D axis;
+
+        /// How much to rotate around the axis.
+        rerun::datatypes::Angle angle;
+
+      public: // START of extensions from rotation_axis_angle_ext.cpp:
+        RotationAxisAngle(const Vec3D& _axis, const Angle& _angle) : axis(_axis), angle(_angle) {}
+
+        // END of extensions from rotation_axis_angle_ext.cpp, start of generated code:
+
+      public:
+        RotationAxisAngle() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::RotationAxisAngle> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.RotationAxisAngle";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::RotationAxisAngle` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::RotationAxisAngle* 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::RotationAxisAngle* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun