pymomentum-cpu 0.1.78.post11__cp312-cp312-win_amd64.whl

include/rerun/components/annotation_context.hpp

@@ -0,0 +1,102 @@
+// 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/annotation_context.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_descriptor.hpp"
+#include "../datatypes/class_description_map_elem.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class ListBuilder;
+} // namespace arrow
+
+namespace rerun::components {
+    /// **Component**: The annotation context provides additional information on how to display entities.
+    ///
+    /// Entities can use `datatypes::ClassId`s and `datatypes::KeypointId`s to provide annotations, and
+    /// the labels and colors will be looked up in the appropriate
+    /// annotation context. We use the *first* annotation context we find in the
+    /// path-hierarchy when searching up through the ancestors of a given entity
+    /// path.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct AnnotationContext {
+        /// List of class descriptions, mapping class indices to class names, colors etc.
+        rerun::Collection<rerun::datatypes::ClassDescriptionMapElem> class_map;
+
+      public: // START of extensions from annotation_context_ext.cpp:
+        /// Construct from an initializer list of elements from which `rerun::datatypes::ClassDescriptionMapElem`s can be constructed.
+        ///
+        /// This will then create a new collection of `rerun::datatypes::ClassDescriptionMapElem`.
+        ///
+        /// _Implementation note_:
+        /// We handle this type of conversion in a generic `rerun::ContainerAdapter`.
+        /// However, it is *still* necessary since initializer list overload resolution is handled
+        /// in a special way by the compiler, making this case not being covered by the general container case.
+        template <
+            typename TElement, //
+            typename = std::enable_if_t<
+                std::is_constructible_v<datatypes::ClassDescriptionMapElem, TElement>> //
+            >
+        AnnotationContext(std::initializer_list<TElement> class_descriptions) {
+            std::vector<datatypes::ClassDescriptionMapElem> class_map_new;
+            class_map_new.reserve(class_descriptions.size());
+            for (const auto& class_description : class_descriptions) {
+                class_map_new.emplace_back(std::move(class_description));
+            }
+            class_map = Collection<datatypes::ClassDescriptionMapElem>::take_ownership(
+                std::move(class_map_new)
+            );
+        }
+
+        // END of extensions from annotation_context_ext.cpp, start of generated code:
+
+      public:
+        AnnotationContext() = default;
+
+        AnnotationContext(rerun::Collection<rerun::datatypes::ClassDescriptionMapElem> class_map_)
+            : class_map(std::move(class_map_)) {}
+
+        AnnotationContext& operator=(
+            rerun::Collection<rerun::datatypes::ClassDescriptionMapElem> class_map_
+        ) {
+            class_map = std::move(class_map_);
+            return *this;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::AnnotationContext> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.AnnotationContext";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::AnnotationContext` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::AnnotationContext* 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::AnnotationContext* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/components/axis_length.hpp

@@ -0,0 +1,74 @@
+// 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/axis_length.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: The length of an axis in local units of the space.
+    struct AxisLength {
+        rerun::datatypes::Float32 length;
+
+      public:
+        AxisLength() = default;
+
+        AxisLength(rerun::datatypes::Float32 length_) : length(length_) {}
+
+        AxisLength& operator=(rerun::datatypes::Float32 length_) {
+            length = length_;
+            return *this;
+        }
+
+        AxisLength(float value_) : length(value_) {}
+
+        AxisLength& operator=(float value_) {
+            length = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float32 datatype
+        operator rerun::datatypes::Float32() const {
+            return length;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float32) == sizeof(components::AxisLength));
+
+    /// \private
+    template <>
+    struct Loggable<components::AxisLength> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.AxisLength";
+
+        /// 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::AxisLength` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::AxisLength* 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->length,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/blob.hpp

@@ -0,0 +1,73 @@
+// 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/blob.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_descriptor.hpp"
+#include "../datatypes/blob.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace rerun::components {
+    /// **Component**: A binary blob of data.
+    struct Blob {
+        rerun::datatypes::Blob data;
+
+      public:
+        Blob() = default;
+
+        Blob(rerun::datatypes::Blob data_) : data(std::move(data_)) {}
+
+        Blob& operator=(rerun::datatypes::Blob data_) {
+            data = std::move(data_);
+            return *this;
+        }
+
+        Blob(rerun::Collection<uint8_t> data_) : data(std::move(data_)) {}
+
+        Blob& operator=(rerun::Collection<uint8_t> data_) {
+            data = std::move(data_);
+            return *this;
+        }
+
+        /// Cast to the underlying Blob datatype
+        operator rerun::datatypes::Blob() const {
+            return data;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Blob) == sizeof(components::Blob));
+
+    /// \private
+    template <>
+    struct Loggable<components::Blob> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Blob";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Blob>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::Blob` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Blob* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Blob>::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::Blob>::to_arrow(&instances->data, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/class_id.hpp

@@ -0,0 +1,71 @@
+// 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/class_id.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/class_id.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A 16-bit ID representing a type of semantic class.
+    struct ClassId {
+        rerun::datatypes::ClassId id;
+
+      public:
+        ClassId() = default;
+
+        ClassId(rerun::datatypes::ClassId id_) : id(id_) {}
+
+        ClassId& operator=(rerun::datatypes::ClassId id_) {
+            id = id_;
+            return *this;
+        }
+
+        ClassId(uint16_t id_) : id(id_) {}
+
+        ClassId& operator=(uint16_t id_) {
+            id = id_;
+            return *this;
+        }
+
+        /// Cast to the underlying ClassId datatype
+        operator rerun::datatypes::ClassId() const {
+            return id;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::ClassId) == sizeof(components::ClassId));
+
+    /// \private
+    template <>
+    struct Loggable<components::ClassId> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.ClassId";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::ClassId>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::ClassId` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::ClassId* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::ClassId>::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::ClassId>::to_arrow(&instances->id, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/clear_is_recursive.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/clear_is_recursive.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/bool.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Configures how a clear operation should behave - recursive or not.
+    struct ClearIsRecursive {
+        /// If true, also clears all recursive children entities.
+        rerun::datatypes::Bool recursive;
+
+      public:
+        ClearIsRecursive() = default;
+
+        ClearIsRecursive(rerun::datatypes::Bool recursive_) : recursive(recursive_) {}
+
+        ClearIsRecursive& operator=(rerun::datatypes::Bool recursive_) {
+            recursive = recursive_;
+            return *this;
+        }
+
+        ClearIsRecursive(bool value_) : recursive(value_) {}
+
+        ClearIsRecursive& operator=(bool value_) {
+            recursive = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Bool datatype
+        operator rerun::datatypes::Bool() const {
+            return recursive;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Bool) == sizeof(components::ClearIsRecursive));
+
+    /// \private
+    template <>
+    struct Loggable<components::ClearIsRecursive> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.ClearIsRecursive";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Bool>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::ClearIsRecursive` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::ClearIsRecursive* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Bool>::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::Bool>::to_arrow(
+                    &instances->recursive,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/color.hpp

@@ -0,0 +1,99 @@
+// 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/color.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/rgba32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: 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 Color {
+        rerun::datatypes::Rgba32 rgba;
+
+      public: // START of extensions from color_ext.cpp:
+        /// Construct Color from unmultiplied RGBA values.
+        Color(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) : rgba(r, g, b, a) {}
+
+        uint8_t r() const {
+            return rgba.r();
+        }
+
+        uint8_t g() const {
+            return rgba.g();
+        }
+
+        uint8_t b() const {
+            return rgba.b();
+        }
+
+        uint8_t a() const {
+            return rgba.a();
+        }
+
+        // END of extensions from color_ext.cpp, start of generated code:
+
+      public:
+        Color() = default;
+
+        Color(rerun::datatypes::Rgba32 rgba_) : rgba(rgba_) {}
+
+        Color& operator=(rerun::datatypes::Rgba32 rgba_) {
+            rgba = rgba_;
+            return *this;
+        }
+
+        Color(uint32_t rgba_) : rgba(rgba_) {}
+
+        Color& operator=(uint32_t rgba_) {
+            rgba = rgba_;
+            return *this;
+        }
+
+        /// Cast to the underlying Rgba32 datatype
+        operator rerun::datatypes::Rgba32() const {
+            return rgba;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Rgba32) == sizeof(components::Color));
+
+    /// \private
+    template <>
+    struct Loggable<components::Color> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Color";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Rgba32>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::Color` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Color* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Rgba32>::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::Rgba32>::to_arrow(
+                    &instances->rgba,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/colormap.hpp

@@ -0,0 +1,99 @@
+// 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/colormap.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**: Colormap for mapping scalar values within a given range to a color.
+    ///
+    /// This provides a number of popular pre-defined colormaps.
+    /// In the future, the Rerun Viewer will allow users to define their own colormaps,
+    /// but currently the Viewer is limited to the types defined here.
+    enum class Colormap : uint8_t {
+
+        /// A simple black to white gradient.
+        ///
+        /// This is a sRGB gray gradient which is perceptually uniform.
+        Grayscale = 1,
+
+        /// The Inferno colormap from Matplotlib.
+        ///
+        /// This is a perceptually uniform colormap.
+        /// It interpolates from black to red to bright yellow.
+        Inferno = 2,
+
+        /// The Magma colormap from Matplotlib.
+        ///
+        /// This is a perceptually uniform colormap.
+        /// It interpolates from black to purple to white.
+        Magma = 3,
+
+        /// The Plasma colormap from Matplotlib.
+        ///
+        /// This is a perceptually uniform colormap.
+        /// It interpolates from dark blue to purple to yellow.
+        Plasma = 4,
+
+        /// Google's Turbo colormap map.
+        ///
+        /// This is a perceptually non-uniform rainbow colormap addressing many issues of
+        /// more traditional rainbow colormaps like Jet.
+        /// It is more perceptually uniform without sharp transitions and is more colorblind-friendly.
+        /// Details: <https://research.google/blog/turbo-an-improved-rainbow-colormap-for-visualization/>
+        Turbo = 5,
+
+        /// The Viridis colormap from Matplotlib
+        ///
+        /// This is a perceptually uniform colormap which is robust to color blindness.
+        /// It interpolates from dark purple to green to yellow.
+        Viridis = 6,
+
+        /// Rasmusgo's Cyan to Yellow colormap
+        ///
+        /// This is a perceptually uniform colormap which is robust to color blindness.
+        /// It is especially suited for visualizing signed values.
+        /// It interpolates from cyan to blue to dark gray to brass to yellow.
+        CyanToYellow = 7,
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::Colormap> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Colormap";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::Colormap` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Colormap* 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::Colormap* elements, size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/components/depth_meter.hpp

@@ -0,0 +1,84 @@
+// 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/depth_meter.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: The world->depth map scaling factor.
+    ///
+    /// This measures how many depth map units are in a world unit.
+    /// For instance, if a depth map uses millimeters and the world uses meters,
+    /// this value would be `1000`.
+    ///
+    /// Note that the only effect on 2D views is the physical depth values shown when hovering the image.
+    /// In 3D views on the other hand, this affects where the points of the point cloud are placed.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct DepthMeter {
+        rerun::datatypes::Float32 value;
+
+      public:
+        DepthMeter() = default;
+
+        DepthMeter(rerun::datatypes::Float32 value_) : value(value_) {}
+
+        DepthMeter& operator=(rerun::datatypes::Float32 value_) {
+            value = value_;
+            return *this;
+        }
+
+        DepthMeter(float value_) : value(value_) {}
+
+        DepthMeter& 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::DepthMeter));
+
+    /// \private
+    template <>
+    struct Loggable<components::DepthMeter> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.DepthMeter";
+
+        /// 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::DepthMeter` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::DepthMeter* 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