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

include/rerun/datatypes/visible_time_range.hpp

@@ -0,0 +1,57 @@
+// 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/visible_time_range.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "time_range.hpp"
+#include "utf8.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: Visible time range bounds for a specific timeline.
+    struct VisibleTimeRange {
+        /// Name of the timeline this applies to.
+        rerun::datatypes::Utf8 timeline;
+
+        /// Time range to use for this timeline.
+        rerun::datatypes::TimeRange range;
+
+      public:
+        VisibleTimeRange() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::VisibleTimeRange> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.VisibleTimeRange";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::VisibleTimeRange` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::VisibleTimeRange* 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::VisibleTimeRange* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes.hpp

@@ -0,0 +1,51 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+
+#pragma once
+
+#include "datatypes/angle.hpp"
+#include "datatypes/annotation_info.hpp"
+#include "datatypes/blob.hpp"
+#include "datatypes/bool.hpp"
+#include "datatypes/channel_datatype.hpp"
+#include "datatypes/class_description.hpp"
+#include "datatypes/class_description_map_elem.hpp"
+#include "datatypes/class_id.hpp"
+#include "datatypes/color_model.hpp"
+#include "datatypes/dvec2d.hpp"
+#include "datatypes/entity_path.hpp"
+#include "datatypes/float32.hpp"
+#include "datatypes/float64.hpp"
+#include "datatypes/image_format.hpp"
+#include "datatypes/keypoint_id.hpp"
+#include "datatypes/keypoint_pair.hpp"
+#include "datatypes/mat3x3.hpp"
+#include "datatypes/mat4x4.hpp"
+#include "datatypes/pixel_format.hpp"
+#include "datatypes/plane3d.hpp"
+#include "datatypes/quaternion.hpp"
+#include "datatypes/range1d.hpp"
+#include "datatypes/range2d.hpp"
+#include "datatypes/rgba32.hpp"
+#include "datatypes/rotation_axis_angle.hpp"
+#include "datatypes/tensor_buffer.hpp"
+#include "datatypes/tensor_data.hpp"
+#include "datatypes/tensor_dimension_index_selection.hpp"
+#include "datatypes/tensor_dimension_selection.hpp"
+#include "datatypes/time_int.hpp"
+#include "datatypes/time_range.hpp"
+#include "datatypes/time_range_boundary.hpp"
+#include "datatypes/uint16.hpp"
+#include "datatypes/uint32.hpp"
+#include "datatypes/uint64.hpp"
+#include "datatypes/utf8.hpp"
+#include "datatypes/utf8pair.hpp"
+#include "datatypes/uuid.hpp"
+#include "datatypes/uvec2d.hpp"
+#include "datatypes/uvec3d.hpp"
+#include "datatypes/uvec4d.hpp"
+#include "datatypes/vec2d.hpp"
+#include "datatypes/vec3d.hpp"
+#include "datatypes/vec4d.hpp"
+#include "datatypes/video_timestamp.hpp"
+#include "datatypes/view_coordinates.hpp"
+#include "datatypes/visible_time_range.hpp"

include/rerun/demo_utils.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+// Utilities used in examples.
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+#include "components/color.hpp"
+#include "components/position3d.hpp"
+
+namespace rerun {
+    namespace demo {
+        constexpr float PI = 3.14159265358979323846264338327950288f;
+        constexpr float TAU = 6.28318530717958647692528676655900577f;
+
+        /// A linear interpolator that bounces between `a` and `b` as `t` goes above `1.0`.
+        inline float bounce_lerp(float a, float b, float t) {
+            auto tf = t - floorf(t);
+            if (static_cast<int32_t>(t) % 2 == 0) {
+                return (1.0f - tf) * a + tf * b;
+            } else {
+                return tf * a + (1.0f - tf) * b;
+            }
+        }
+
+        /// Linearly interpolates from `a` through `b` in `n` steps, returning the intermediate result at
+        /// each step.
+        template <typename T>
+        inline std::vector<T> linspace(T start, T end, size_t num) {
+            std::vector<T> linspaced(num);
+            std::generate(linspaced.begin(), linspaced.end(), [&, i = 0]() mutable {
+                return static_cast<T>(
+                    start + static_cast<T>(i++) * (end - start) / static_cast<T>(num - 1)
+                );
+            });
+            return linspaced;
+        }
+
+        /// Given a range `from`-`to`, linearly interpolates between them in `n` steps along
+        /// three axes each, returning the intermediate result at each step.
+        template <typename T, typename Elem>
+        std::vector<T> grid3d(Elem from, Elem to, size_t n) {
+            std::vector<T> output;
+            for (Elem z : linspace(from, to, n)) {
+                for (Elem y : linspace(from, to, n)) {
+                    for (Elem x : linspace(from, to, n)) {
+                        output.emplace_back(
+                            static_cast<Elem>(x),
+                            static_cast<Elem>(y),
+                            static_cast<Elem>(z)
+                        );
+                    }
+                }
+            }
+            return output;
+        }
+
+        /// Create a spiral of points with colors along the Z axis.
+        ///
+        /// * `num_points`: Total number of points.
+        /// * `radius`: The radius of the spiral.
+        /// * `angular_step`: The factor applied between each step along the trigonometric circle.
+        /// * `angular_offset`: Offsets the starting position on the trigonometric circle.
+        /// * `z_step`: The factor applied between each step along the Z axis.
+        void color_spiral(
+            size_t num_points, float radius, float angular_step, float angular_offset, float z_step,
+            std::vector<components::Position3D>& out_points,
+            std::vector<components::Color>& out_colors
+        );
+
+        /// Returns sRGB polynomial approximation from Turbo color map, assuming `t` is normalized.
+        rerun::components::Color colormap_turbo_srgb(float t);
+    } // namespace demo
+} // namespace rerun

include/rerun/entity_path.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace rerun {
+
+    /// Escape an individual part of an entity path.
+    ///
+    /// For instance, `escape_entity_path_path("my image!")` will return `"my\ image\!"`.
+    std::string escape_entity_path_part(std::string_view str);
+
+    /// Construct an entity path by escaping each part of the path.
+    ///
+    /// For instance, `rerun::new_entity_path({"world", 42, "unescaped string!"})` will return
+    /// `"world/42/escaped\ string\!"`.
+    std::string new_entity_path(const std::vector<std::string_view>& path);
+
+} // namespace rerun

include/rerun/error.hpp

@@ -0,0 +1,180 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+#ifdef __cpp_exceptions
+#include <stdexcept>
+#endif
+
+namespace arrow {
+    class Status;
+}
+
+struct rr_error;
+
+/// Return error if a given rerun::Error producing expression is not rerun::ErrorCode::Ok.
+#define RR_RETURN_NOT_OK(status_expr)              \
+    do {                                           \
+        const rerun::Error _status_ = status_expr; \
+        if (_status_.is_err()) {                   \
+            return _status_;                       \
+        }                                          \
+    } while (false)
+
+namespace rerun {
+    /// Status codes returned by the SDK as part of `Status`.
+    ///
+    /// Category codes are used to group errors together, but are never returned directly.
+    enum class ErrorCode : uint32_t {
+        Ok = 0x0000'0000,
+        OutOfMemory,
+        NotImplemented,
+        SdkVersionMismatch,
+
+        // Invalid argument errors.
+        _CategoryArgument = 0x0000'0010,
+        UnexpectedNullArgument,
+        InvalidStringArgument,
+        InvalidEnumValue,
+        InvalidRecordingStreamHandle,
+        InvalidSocketAddress,
+        InvalidComponentTypeHandle,
+        InvalidTensorDimension,
+        InvalidArchetypeField,
+        FileRead,
+        InvalidServerUrl,
+        InvalidMemoryLimit,
+
+        // Recording stream errors
+        _CategoryRecordingStream = 0x0000'0100,
+        RecordingStreamRuntimeFailure,
+        RecordingStreamCreationFailure,
+        RecordingStreamSaveFailure,
+        RecordingStreamStdoutFailure,
+        RecordingStreamSpawnFailure,
+        RecordingStreamChunkValidationFailure,
+        RecordingStreamServeGrpcFailure,
+
+        // Arrow data processing errors.
+        _CategoryArrow = 0x0000'1000,
+        ArrowFfiSchemaImportError,
+        ArrowFfiArrayImportError,
+
+        // Utility errors.
+        _CategoryUtilities = 0x0001'0000,
+        VideoLoadError,
+
+        // Errors relating to file IO.
+        _CategoryFileIO = 0x0010'0000,
+        FileOpenFailure,
+
+        // Errors directly translated from arrow::StatusCode.
+        _CategoryArrowCppStatus = 0x1000'0000,
+        ArrowStatusCode_KeyError,
+        ArrowStatusCode_TypeError,
+        ArrowStatusCode_Invalid,
+        ArrowStatusCode_IOError,
+        ArrowStatusCode_CapacityError,
+        ArrowStatusCode_IndexError,
+        ArrowStatusCode_Cancelled,
+        ArrowStatusCode_UnknownError,
+        ArrowStatusCode_NotImplemented,
+        ArrowStatusCode_SerializationError,
+        ArrowStatusCode_RError,
+        ArrowStatusCode_CodeGenError,
+        ArrowStatusCode_ExpressionValidationError,
+        ArrowStatusCode_ExecutionError,
+        ArrowStatusCode_AlreadyExists,
+
+        Unknown = 0xFFFF'FFFF,
+    };
+
+    /// Callback function type for log handlers.
+    using StatusLogHandler = void (*)(const class Error& status, void* userdata);
+
+    /// Status outcome object (success or error) returned for fallible operations.
+    ///
+    /// Converts to `true` for success, `false` for failure.
+    class [[nodiscard]] Error {
+      public:
+        /// Result code for the given operation.
+        ErrorCode code = ErrorCode::Ok;
+
+        /// Human readable description of the error.
+        std::string description;
+
+      public:
+        Error() = default;
+
+        Error(ErrorCode _code, std::string _description)
+            : code(_code), description(std::move(_description)) {}
+
+        /// Construct from a C status object.
+        Error(const rr_error& status);
+
+        /// Construct from an arrow status.
+        Error(const arrow::Status& status);
+
+        /// Creates a new error set to ok.
+        static Error ok() {
+            return Error();
+        }
+
+        /// Compare two errors for equality. Requires the description to match.
+        bool operator==(const Error& other) const {
+            return code == other.code && description == other.description;
+        }
+
+        /// Returns true if the code is `Ok`.
+        bool is_ok() const {
+            return code == ErrorCode::Ok;
+        }
+
+        /// Returns true if the code is not `Ok`.
+        bool is_err() const {
+            return code != ErrorCode::Ok;
+        }
+
+        /// Sets global log handler called for `handle`.
+        ///
+        /// The default will log to stderr, unless `RERUN_STRICT` is set to something truthy.
+        ///
+        /// \param handler The handler to call, or `nullptr` to reset to the default.
+        /// \param userdata Userdata pointer that will be passed to each invocation of the handler.
+        ///
+        /// @see log, log_on_failure
+        static void set_log_handler(StatusLogHandler handler, void* userdata = nullptr);
+
+        /// Handle this error based on the set log handler.
+        ///
+        /// If there is no error, nothing happens.
+        ///
+        /// If you have set a log handler with `set_log_handler`, it will be called.
+        /// Else if the `RERUN_STRICT` env-var is set to something truthy,
+        /// an exception will be thrown (if `__cpp_exceptions` are enabled),
+        /// or the program will abort.
+        ///
+        /// If no log handler is installed, and we are not in strict mode,
+        /// the error will be logged to stderr.
+        void handle() const;
+
+        /// Calls the `handle` method and then exits the application with code 1 if the error is not `Ok`.
+        /// @see throw_on_failure
+        void exit_on_failure() const;
+
+        /// Throws a `std::runtime_error` if the status is not `Ok`.
+        ///
+        /// If exceptions are disabled, this will forward to `exit_on_failure` instead.
+        /// @see exit_on_failure
+        void throw_on_failure() const {
+#ifdef __cpp_exceptions
+            if (is_err()) {
+                throw std::runtime_error(description);
+            }
+#else
+            exit_on_failure();
+#endif
+        }
+    };
+} // namespace rerun

include/rerun/half.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <cstdint>
+
+namespace rerun {
+    /// IEEE 754 16-bit half-precision floating point number.
+    struct half {
+        uint16_t f16;
+    };
+} // namespace rerun

include/rerun/image_utils.hpp

@@ -0,0 +1,187 @@
+#pragma once
+
+#include "datatypes/channel_datatype.hpp"
+#include "datatypes/color_model.hpp"
+#include "datatypes/pixel_format.hpp"
+#include "half.hpp"
+
+#include <cassert>
+#include <cstdint>
+
+namespace rerun {
+    /// The width and height of an image.
+    struct WidthHeight {
+        uint32_t width;
+        uint32_t height;
+
+        WidthHeight(uint32_t width_, uint32_t height_) : width{width_}, height{height_} {}
+    };
+
+    /// Number of bits used by this element type
+    inline size_t datatype_bits(datatypes::ChannelDatatype value) {
+        switch (value) {
+            case datatypes::ChannelDatatype::U8: {
+                return 8;
+            }
+            case datatypes::ChannelDatatype::U16: {
+                return 16;
+            }
+            case datatypes::ChannelDatatype::U32: {
+                return 32;
+            }
+            case datatypes::ChannelDatatype::U64: {
+                return 64;
+            }
+            case datatypes::ChannelDatatype::I8: {
+                return 8;
+            }
+            case datatypes::ChannelDatatype::I16: {
+                return 16;
+            }
+            case datatypes::ChannelDatatype::I32: {
+                return 32;
+            }
+            case datatypes::ChannelDatatype::I64: {
+                return 64;
+            }
+            case datatypes::ChannelDatatype::F16: {
+                return 16;
+            }
+            case datatypes::ChannelDatatype::F32: {
+                return 32;
+            }
+            case datatypes::ChannelDatatype::F64: {
+                return 64;
+            }
+            default:
+                assert(false && "unreachable");
+        }
+        return 0;
+    }
+
+    inline size_t num_bytes(WidthHeight resolution, datatypes::ChannelDatatype datatype) {
+        // rounding upwards:
+        return (resolution.width * resolution.height * datatype_bits(datatype) + 7) / 8;
+    }
+
+    template <typename TElement>
+    inline datatypes::ChannelDatatype get_datatype(const TElement* _unused);
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const uint8_t* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::U8;
+    }
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const uint16_t* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::U16;
+    }
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const uint32_t* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::U32;
+    }
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const uint64_t* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::U64;
+    }
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const int8_t* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::I8;
+    }
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const int16_t* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::I16;
+    }
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const int32_t* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::I32;
+    }
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const int64_t* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::I64;
+    }
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const rerun::half* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::F16;
+    }
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const float* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::F32;
+    }
+
+    template <>
+    inline datatypes::ChannelDatatype get_datatype(const double* _unused) {
+        (void)(_unused); // Suppress unused warning.
+        return datatypes::ChannelDatatype::F64;
+    }
+
+    /// Returns the number of channels for a given color model.
+    ///
+    /// This is the number of expected elements per pixel.
+    inline size_t color_model_channel_count(datatypes::ColorModel color_model) {
+        switch (color_model) {
+            case datatypes::ColorModel::L:
+                return 1;
+            case datatypes::ColorModel::BGR:
+            case datatypes::ColorModel::RGB:
+                return 3;
+            case datatypes::ColorModel::BGRA:
+            case datatypes::ColorModel::RGBA:
+                return 4;
+            default:
+                assert(false && "unreachable");
+        }
+        return 0;
+    }
+
+    inline size_t pixel_format_num_bytes(
+        WidthHeight resolution, datatypes::PixelFormat pixel_format
+    ) {
+        auto num_pixels = resolution.width * resolution.height;
+        switch (pixel_format) {
+            // 444 formats.
+            case datatypes::PixelFormat::Y_U_V24_FullRange:
+            case datatypes::PixelFormat::Y_U_V24_LimitedRange:
+                return num_pixels * 4;
+
+            // 422 formats.
+            case datatypes::PixelFormat::Y_U_V16_FullRange:
+            case datatypes::PixelFormat::Y_U_V16_LimitedRange:
+            case datatypes::PixelFormat::YUY2:
+                return 16 * num_pixels / 8;
+
+            // 420 formats.
+            case datatypes::PixelFormat::Y_U_V12_FullRange:
+            case datatypes::PixelFormat::Y_U_V12_LimitedRange:
+            case datatypes::PixelFormat::NV12:
+                return 12 * num_pixels / 8;
+
+            // Monochrome formats.
+            case datatypes::PixelFormat::Y8_LimitedRange:
+            case datatypes::PixelFormat::Y8_FullRange:
+                return num_pixels;
+
+            default:
+                assert(false && "unreachable");
+        }
+        return 0;
+    }
+} // namespace rerun

include/rerun/indicator_component.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <memory> // std::shared_ptr
+#include <optional>
+#include "component_descriptor.hpp"
+#include "loggable.hpp"
+#include "result.hpp"
+
+namespace arrow {
+    class DataType;
+    class Array;
+} // namespace arrow
+
+namespace rerun::components {
+    /// Arrow data type shared by all instances of IndicatorComponent.
+    const std::shared_ptr<arrow::DataType>& indicator_arrow_datatype();
+
+    /// Returns an arrow array for a single indicator component.
+    ///
+    /// This allocates a shared pointer only on the first call and returns references to the static object afterwards.
+    const std::shared_ptr<arrow::Array>& indicator_arrow_array();
+
+    /// Returns an arrow array for a several indicator component.
+    ///
+    /// Unlike the parameterless version this allocates a new data type on every call.
+    std::shared_ptr<arrow::Array> indicator_arrow_array(size_t num_instances);
+
+    /// Indicator component used by archetypes when converting them to component lists.
+    ///
+    /// This is done in order to track how a collection of component was logged.
+    template <const char ComponentName[]>
+    struct IndicatorComponent {};
+} // namespace rerun::components
+
+namespace rerun {
+    /// \private
+    template <const char ComponentName_[]>
+    struct Loggable<components::IndicatorComponent<ComponentName_>> {
+        /// Returns the name of this type.
+        static constexpr ComponentDescriptor Descriptor = ComponentDescriptor(ComponentName_);
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return components::indicator_arrow_datatype();
+        }
+
+        /// Creates an arrow ComponentBatch from an array of IndicatorComponent components.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::IndicatorComponent<ComponentName_>*, size_t num_instances
+        ) {
+            // If possible, use the statically allocated shared pointer returned by the parameterless version.
+            if (num_instances == 1) {
+                return components::indicator_arrow_array();
+            } else {
+                return components::indicator_arrow_array(num_instances);
+            }
+        }
+    };
+} // namespace rerun