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

include/rerun/components/scale3d.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/scale3d.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/vec3d.hpp"
+#include "../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A 3D scale factor.
+    ///
+    /// A scale of 1.0 means no scaling.
+    /// A scale of 2.0 means doubling the size.
+    /// Each component scales along the corresponding axis.
+    struct Scale3D {
+        rerun::datatypes::Vec3D scale;
+
+      public: // START of extensions from scale3d_ext.cpp:
+        /// Construct `Scale3D` from x/y/z values.
+        Scale3D(float x, float y, float z) : scale{x, y, z} {}
+
+        /// Construct `Scale3D` from x/y/z float pointer.
+        explicit Scale3D(const float* xyz) : scale{xyz[0], xyz[1], xyz[2]} {}
+
+        /// Construct a `Scale3D` from a uniform scale factor.
+        explicit Scale3D(float uniform_scale)
+            : Scale3D(datatypes::Vec3D{uniform_scale, uniform_scale, uniform_scale}) {}
+
+        /// Explicitly construct a `Scale3D` from a uniform scale factor.
+        static Scale3D uniform(float uniform_scale) {
+            return Scale3D(uniform_scale);
+        }
+
+        /// Explicitly construct a `Scale3D` from a 3D scale factor.
+        static Scale3D three_d(datatypes::Vec3D scale) {
+            return Scale3D(scale);
+        }
+
+        // END of extensions from scale3d_ext.cpp, start of generated code:
+
+      public:
+        Scale3D() = default;
+
+        Scale3D(rerun::datatypes::Vec3D scale_) : scale(scale_) {}
+
+        Scale3D& operator=(rerun::datatypes::Vec3D scale_) {
+            scale = scale_;
+            return *this;
+        }
+
+        Scale3D(std::array<float, 3> xyz_) : scale(xyz_) {}
+
+        Scale3D& operator=(std::array<float, 3> xyz_) {
+            scale = xyz_;
+            return *this;
+        }
+
+        /// Cast to the underlying Vec3D datatype
+        operator rerun::datatypes::Vec3D() const {
+            return scale;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Vec3D) == sizeof(components::Scale3D));
+
+    /// \private
+    template <>
+    struct Loggable<components::Scale3D> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.Scale3D";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Vec3D>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::Scale3D` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::Scale3D* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Vec3D>::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::Vec3D>::to_arrow(
+                    &instances->scale,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/series_visible.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/components/SeriesVisible.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/bool.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Like `components::Visible`, but for time series.
+    ///
+    /// TODO(#6889): This is a temporary workaround. Right now we can't use `components::Visible` since it would conflict with the entity-wide visibility state.
+    struct SeriesVisible {
+        rerun::datatypes::Bool visible;
+
+      public:
+        SeriesVisible() = default;
+
+        SeriesVisible(rerun::datatypes::Bool visible_) : visible(visible_) {}
+
+        SeriesVisible& operator=(rerun::datatypes::Bool visible_) {
+            visible = visible_;
+            return *this;
+        }
+
+        SeriesVisible(bool value_) : visible(value_) {}
+
+        SeriesVisible& operator=(bool value_) {
+            visible = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Bool datatype
+        operator rerun::datatypes::Bool() const {
+            return visible;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Bool) == sizeof(components::SeriesVisible));
+
+    /// \private
+    template <>
+    struct Loggable<components::SeriesVisible> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.SeriesVisible";
+
+        /// 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::SeriesVisible` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::SeriesVisible* 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->visible,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/show_labels.hpp

@@ -0,0 +1,79 @@
+// 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/show_labels.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/bool.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Whether the entity's `components::Text` label is shown.
+    ///
+    /// The main purpose of this component existing separately from the labels themselves
+    /// is to be overridden when desired, to allow hiding and showing from the viewer and
+    /// blueprints.
+    struct ShowLabels {
+        /// Whether the entity's `components::Text` label is shown.
+        rerun::datatypes::Bool show_labels;
+
+      public:
+        ShowLabels() = default;
+
+        ShowLabels(rerun::datatypes::Bool show_labels_) : show_labels(show_labels_) {}
+
+        ShowLabels& operator=(rerun::datatypes::Bool show_labels_) {
+            show_labels = show_labels_;
+            return *this;
+        }
+
+        ShowLabels(bool value_) : show_labels(value_) {}
+
+        ShowLabels& operator=(bool value_) {
+            show_labels = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Bool datatype
+        operator rerun::datatypes::Bool() const {
+            return show_labels;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Bool) == sizeof(components::ShowLabels));
+
+    /// \private
+    template <>
+    struct Loggable<components::ShowLabels> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.ShowLabels";
+
+        /// 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::ShowLabels` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::ShowLabels* 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->show_labels,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/stroke_width.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/stroke_width.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/float32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: The width of a stroke specified in UI points.
+    struct StrokeWidth {
+        rerun::datatypes::Float32 width;
+
+      public:
+        StrokeWidth() = default;
+
+        StrokeWidth(rerun::datatypes::Float32 width_) : width(width_) {}
+
+        StrokeWidth& operator=(rerun::datatypes::Float32 width_) {
+            width = width_;
+            return *this;
+        }
+
+        StrokeWidth(float value_) : width(value_) {}
+
+        StrokeWidth& operator=(float value_) {
+            width = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float32 datatype
+        operator rerun::datatypes::Float32() const {
+            return width;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float32) == sizeof(components::StrokeWidth));
+
+    /// \private
+    template <>
+    struct Loggable<components::StrokeWidth> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.StrokeWidth";
+
+        /// 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::StrokeWidth` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::StrokeWidth* 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->width,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/tensor_data.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/components/tensor_data.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/tensor_data.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace rerun::components {
+    /// **Component**: An N-dimensional array of numbers.
+    ///
+    /// The number of dimensions and their respective lengths is specified by the `shape` field.
+    /// The dimensions are ordered from outermost to innermost. For example, in the common case of
+    /// a 2D RGB Image, the shape would be `[height, width, channel]`.
+    ///
+    /// These dimensions are combined with an index to look up values from the `buffer` field,
+    /// which stores a contiguous array of typed values.
+    struct TensorData {
+        rerun::datatypes::TensorData data;
+
+      public: // START of extensions from tensor_data_ext.cpp:
+        /// New tensor data from shape and tensor buffer.
+        ///
+        /// \param shape Shape of the tensor.
+        /// \param buffer The tensor buffer containing the tensor's data.
+        TensorData(rerun::Collection<uint64_t> shape, rerun::datatypes::TensorBuffer buffer)
+            : data(rerun::datatypes::TensorData(std::move(shape), std::move(buffer))) {}
+
+        /// New tensor data from dimensions and pointer to tensor data.
+        ///
+        /// Type must be one of the types supported by `rerun::datatypes::TensorData`.
+        /// \param shape Shape of the tensor. Determines the number of elements expected to be in `data_`.
+        /// \param data_ Target of the pointer must outlive the archetype.
+        template <typename TElement>
+        explicit TensorData(Collection<uint64_t> shape, const TElement* data_)
+            : data(rerun::datatypes::TensorData(std::move(shape), data_)) {}
+
+        // END of extensions from tensor_data_ext.cpp, start of generated code:
+
+      public:
+        TensorData() = default;
+
+        TensorData(rerun::datatypes::TensorData data_) : data(std::move(data_)) {}
+
+        TensorData& operator=(rerun::datatypes::TensorData data_) {
+            data = std::move(data_);
+            return *this;
+        }
+
+        /// Cast to the underlying TensorData datatype
+        operator rerun::datatypes::TensorData() const {
+            return data;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::TensorData) == sizeof(components::TensorData));
+
+    /// \private
+    template <>
+    struct Loggable<components::TensorData> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.TensorData";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::TensorData>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::TensorData` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::TensorData* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::TensorData>::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::TensorData>::to_arrow(
+                    &instances->data,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/tensor_dimension_index_selection.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/tensor_dimension_selection.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/tensor_dimension_index_selection.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Specifies a concrete index on a tensor dimension.
+    struct TensorDimensionIndexSelection {
+        rerun::datatypes::TensorDimensionIndexSelection selection;
+
+      public:
+        TensorDimensionIndexSelection() = default;
+
+        TensorDimensionIndexSelection(rerun::datatypes::TensorDimensionIndexSelection selection_)
+            : selection(selection_) {}
+
+        TensorDimensionIndexSelection& operator=(
+            rerun::datatypes::TensorDimensionIndexSelection selection_
+        ) {
+            selection = selection_;
+            return *this;
+        }
+
+        /// Cast to the underlying TensorDimensionIndexSelection datatype
+        operator rerun::datatypes::TensorDimensionIndexSelection() const {
+            return selection;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::TensorDimensionIndexSelection) ==
+        sizeof(components::TensorDimensionIndexSelection)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<components::TensorDimensionIndexSelection> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.components.TensorDimensionIndexSelection";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::TensorDimensionIndexSelection>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::TensorDimensionIndexSelection` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::TensorDimensionIndexSelection* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::TensorDimensionIndexSelection>::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::TensorDimensionIndexSelection>::to_arrow(
+                    &instances->selection,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/tensor_height_dimension.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/tensor_dimension_selection.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/tensor_dimension_selection.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Specifies which dimension to use for height.
+    struct TensorHeightDimension {
+        rerun::datatypes::TensorDimensionSelection dimension;
+
+      public:
+        TensorHeightDimension() = default;
+
+        TensorHeightDimension(rerun::datatypes::TensorDimensionSelection dimension_)
+            : dimension(dimension_) {}
+
+        TensorHeightDimension& operator=(rerun::datatypes::TensorDimensionSelection dimension_) {
+            dimension = dimension_;
+            return *this;
+        }
+
+        /// Cast to the underlying TensorDimensionSelection datatype
+        operator rerun::datatypes::TensorDimensionSelection() const {
+            return dimension;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::TensorDimensionSelection) ==
+        sizeof(components::TensorHeightDimension)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<components::TensorHeightDimension> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.TensorHeightDimension";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::TensorDimensionSelection>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::TensorHeightDimension` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::TensorHeightDimension* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::TensorDimensionSelection>::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::TensorDimensionSelection>::to_arrow(
+                    &instances->dimension,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/components/tensor_width_dimension.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/tensor_dimension_selection.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/tensor_dimension_selection.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: Specifies which dimension to use for width.
+    struct TensorWidthDimension {
+        rerun::datatypes::TensorDimensionSelection dimension;
+
+      public:
+        TensorWidthDimension() = default;
+
+        TensorWidthDimension(rerun::datatypes::TensorDimensionSelection dimension_)
+            : dimension(dimension_) {}
+
+        TensorWidthDimension& operator=(rerun::datatypes::TensorDimensionSelection dimension_) {
+            dimension = dimension_;
+            return *this;
+        }
+
+        /// Cast to the underlying TensorDimensionSelection datatype
+        operator rerun::datatypes::TensorDimensionSelection() const {
+            return dimension;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::datatypes::TensorDimensionSelection) ==
+        sizeof(components::TensorWidthDimension)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<components::TensorWidthDimension> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.TensorWidthDimension";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::TensorDimensionSelection>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::TensorWidthDimension` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::TensorWidthDimension* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::TensorDimensionSelection>::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::TensorDimensionSelection>::to_arrow(
+                    &instances->dimension,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun