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

include/rerun/components/length.hpp

@@ -0,0 +1,77 @@
+// 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/length.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Length, or one-dimensional size.
+    ///
+    /// Measured in its local coordinate system; consult the archetype in use to determine which
+    /// axis or part of the entity this is the length of.
+    struct Length {
+        rerun::datatypes::Float32 length;
+
+      public:
+        Length() = default;
+
+        Length(rerun::datatypes::Float32 length_) : length(length_) {}
+
+        Length& operator=(rerun::datatypes::Float32 length_) {
+            length = length_;
+            return *this;
+        }
+
+        Length(float value_) : length(value_) {}
+
+        Length& 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::Length));
+
+    /// \private
+    template <>
+    struct Loggable<components::Length> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Length";
+
+        /// 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::Length` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Length* 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/line_strip2d.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/line_strip2d.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_descriptor.hpp"
+#include "../datatypes/vec2d.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class ListBuilder;
+} // namespace arrow
+
+namespace rerun::components {
+    /// **Component**: A line strip in 2D space.
+    ///
+    /// A line strip is a list of points connected by line segments. It can be used to draw
+    /// approximations of smooth curves.
+    ///
+    /// The points will be connected in order, like so:
+    /// ```text
+    ///        2------3     5
+    ///       /        \   /
+    /// 0----1          \ /
+    ///                  4
+    /// ```
+    struct LineStrip2D {
+        rerun::Collection<rerun::datatypes::Vec2D> points;
+
+      public:
+        LineStrip2D() = default;
+
+        LineStrip2D(rerun::Collection<rerun::datatypes::Vec2D> points_)
+            : points(std::move(points_)) {}
+
+        LineStrip2D& operator=(rerun::Collection<rerun::datatypes::Vec2D> points_) {
+            points = std::move(points_);
+            return *this;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::LineStrip2D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.LineStrip2D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::LineStrip2D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::LineStrip2D* 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::LineStrip2D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/components/line_strip3d.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/line_strip3d.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_descriptor.hpp"
+#include "../datatypes/vec3d.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class ListBuilder;
+} // namespace arrow
+
+namespace rerun::components {
+    /// **Component**: A line strip in 3D space.
+    ///
+    /// A line strip is a list of points connected by line segments. It can be used to draw
+    /// approximations of smooth curves.
+    ///
+    /// The points will be connected in order, like so:
+    /// ```text
+    ///        2------3     5
+    ///       /        \   /
+    /// 0----1          \ /
+    ///                  4
+    /// ```
+    struct LineStrip3D {
+        rerun::Collection<rerun::datatypes::Vec3D> points;
+
+      public:
+        LineStrip3D() = default;
+
+        LineStrip3D(rerun::Collection<rerun::datatypes::Vec3D> points_)
+            : points(std::move(points_)) {}
+
+        LineStrip3D& operator=(rerun::Collection<rerun::datatypes::Vec3D> points_) {
+            points = std::move(points_);
+            return *this;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::LineStrip3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.LineStrip3D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::LineStrip3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::LineStrip3D* 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::LineStrip3D* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/components/magnification_filter.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/magnification_filter.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**: Filter used when magnifying an image/texture such that a single pixel/texel is displayed as multiple pixels on screen.
+    enum class MagnificationFilter : uint8_t {
+
+        /// Show the nearest pixel value.
+        ///
+        /// This will give a blocky appearance when zooming in.
+        /// Used as default when rendering 2D images.
+        Nearest = 1,
+
+        /// Linearly interpolate the nearest neighbors, creating a smoother look when zooming in.
+        ///
+        /// Used as default for mesh rendering.
+        Linear = 2,
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::MagnificationFilter> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.MagnificationFilter";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::MagnificationFilter` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::MagnificationFilter* 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::MagnificationFilter* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/components/marker_shape.hpp

@@ -0,0 +1,82 @@
+// 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/marker_shape.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**: The visual appearance of a point in e.g. a 2D plot.
+    enum class MarkerShape : uint8_t {
+
+        /// `⏺`
+        Circle = 1,
+
+        /// `◆`
+        Diamond = 2,
+
+        /// `◼\u{fe0f}`
+        Square = 3,
+
+        /// `x`
+        Cross = 4,
+
+        /// `+`
+        Plus = 5,
+
+        /// `▲`
+        Up = 6,
+
+        /// `▼`
+        Down = 7,
+
+        /// `◀`
+        Left = 8,
+
+        /// `▶`
+        Right = 9,
+
+        /// `*`
+        Asterisk = 10,
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::MarkerShape> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.MarkerShape";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::MarkerShape` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::MarkerShape* 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::MarkerShape* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/components/marker_size.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/marker_size.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Radius of a marker of a point in e.g. a 2D plot, measured in UI points.
+    struct MarkerSize {
+        rerun::datatypes::Float32 value;
+
+      public:
+        MarkerSize() = default;
+
+        MarkerSize(rerun::datatypes::Float32 value_) : value(value_) {}
+
+        MarkerSize& operator=(rerun::datatypes::Float32 value_) {
+            value = value_;
+            return *this;
+        }
+
+        MarkerSize(float value_) : value(value_) {}
+
+        MarkerSize& 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::MarkerSize));
+
+    /// \private
+    template <>
+    struct Loggable<components::MarkerSize> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.MarkerSize";
+
+        /// 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::MarkerSize` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::MarkerSize* 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/media_type.hpp

@@ -0,0 +1,157 @@
+// 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/media_type.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/utf8.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::components {
+    /// **Component**: A standardized media type (RFC2046, formerly known as MIME types), encoded as a string.
+    ///
+    /// The complete reference of officially registered media types is maintained by the IANA and can be
+    /// consulted at <https://www.iana.org/assignments/media-types/media-types.xhtml>.
+    struct MediaType {
+        rerun::datatypes::Utf8 value;
+
+      public: // START of extensions from media_type_ext.cpp:
+        /// Construct media type from a null-terminated UTF8 string.
+        MediaType(const char* media_type) : value(media_type) {}
+
+        // TODO(#2388): come up with some DSL in our flatbuffers definitions so that we can
+        // declare these constants directly in there.
+
+        /// `text/plain`
+        static MediaType plain_text() {
+            return "text/plain";
+        }
+
+        /// `text/markdown`
+        ///
+        /// <https://www.iana.org/assignments/media-types/text/markdown>
+        static MediaType markdown() {
+            return "text/markdown";
+        }
+
+        // ------------------------------------------------
+        // Images:
+
+        /// [JPEG image](https://en.wikipedia.org/wiki/JPEG): `image/jpeg`.
+        static MediaType jpeg() {
+            return "image/jpeg";
+        }
+
+        /// [PNG image](https://en.wikipedia.org/wiki/PNG): `image/png`.
+        ///
+        /// <https://www.iana.org/assignments/media-types/image/png>
+        static MediaType png() {
+            return "image/png";
+        }
+
+        // ------------------------------------------------
+        // Meshes:
+
+        /// [`glTF`](https://en.wikipedia.org/wiki/GlTF): `model/gltf+json`.
+        ///
+        /// <https://www.iana.org/assignments/media-types/model/gltf+json>
+        static MediaType gltf() {
+            return "model/gltf+json";
+        }
+
+        /// [Binary `glTF`](https://en.wikipedia.org/wiki/GlTF): `model/gltf-binary`.
+        ///
+        /// <https://www.iana.org/assignments/media-types/model/gltf-binary>
+        static MediaType glb() {
+            return "model/gltf-binary";
+        }
+
+        /// [Wavefront `obj`](https://en.wikipedia.org/wiki/Wavefront_.obj_file): `model/obj`.
+        ///
+        /// <https://www.iana.org/assignments/media-types/model/obj>
+        static MediaType obj() {
+            return "model/obj";
+        }
+
+        /// [Stereolithography Model `stl`](https://en.wikipedia.org/wiki/STL_(file_format)): `model/stl`.
+        ///
+        /// Either binary or ASCII.
+        /// <https://www.iana.org/assignments/media-types/model/stl>
+        static MediaType stl() {
+            return "model/stl";
+        }
+
+        // -------------------------------------------------------
+        /// Videos:
+
+        /// [MP4 video](https://en.wikipedia.org/wiki/MP4_file_format): `video/mp4`.
+        ///
+        /// <https://www.iana.org/assignments/media-types/video/mp4>
+        static MediaType mp4() {
+            return "video/mp4";
+        }
+
+        static std::optional<MediaType> guess_from_path(const std::filesystem::path& path);
+
+        // END of extensions from media_type_ext.cpp, start of generated code:
+
+      public:
+        MediaType() = default;
+
+        MediaType(rerun::datatypes::Utf8 value_) : value(std::move(value_)) {}
+
+        MediaType& operator=(rerun::datatypes::Utf8 value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        MediaType(std::string value_) : value(std::move(value_)) {}
+
+        MediaType& operator=(std::string value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        /// Cast to the underlying Utf8 datatype
+        operator rerun::datatypes::Utf8() const {
+            return value;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Utf8) == sizeof(components::MediaType));
+
+    /// \private
+    template <>
+    struct Loggable<components::MediaType> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.MediaType";
+
+        /// 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::MediaType` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::MediaType* 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->value, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/name.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/name.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 display name, typically for an entity or a item like a plot series.
+    struct Name {
+        rerun::datatypes::Utf8 value;
+
+      public: // START of extensions from name_ext.cpp:
+        /// Construct `Name` from a null-terminated UTF8 string.
+        Name(const char* str) : value(str) {}
+
+        const char* c_str() const {
+            return value.c_str();
+        }
+
+        // END of extensions from name_ext.cpp, start of generated code:
+
+      public:
+        Name() = default;
+
+        Name(rerun::datatypes::Utf8 value_) : value(std::move(value_)) {}
+
+        Name& operator=(rerun::datatypes::Utf8 value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        Name(std::string value_) : value(std::move(value_)) {}
+
+        Name& operator=(std::string value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        /// Cast to the underlying Utf8 datatype
+        operator rerun::datatypes::Utf8() const {
+            return value;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Utf8) == sizeof(components::Name));
+
+    /// \private
+    template <>
+    struct Loggable<components::Name> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Name";
+
+        /// 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::Name` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Name* 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->value, num_instances);
+            }
+        }
+    };
+} // namespace rerun