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

include/rerun/archetypes/geo_line_strings.hpp

@@ -0,0 +1,166 @@
+// 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/archetypes/geo_line_strings.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_batch.hpp"
+#include "../component_column.hpp"
+#include "../components/color.hpp"
+#include "../components/geo_line_string.hpp"
+#include "../components/radius.hpp"
+#include "../indicator_component.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::archetypes {
+    /// **Archetype**: Geospatial line strings with positions expressed in [EPSG:4326](https://epsg.io/4326) altitude and longitude (North/East-positive degrees), and optional colors and radii.
+    ///
+    /// Also known as "line strips" or "polylines".
+    ///
+    /// ## Example
+    ///
+    /// ### Log a geospatial line string
+    /// ![image](https://static.rerun.io/geo_line_strings_simple/5669983eb10906ace303755b5b5039cad75b917f/full.png)
+    ///
+    /// ```cpp
+    /// #include <rerun.hpp>
+    ///
+    /// int main() {
+    ///     const auto rec = rerun::RecordingStream("rerun_example_geo_line_strings");
+    ///     rec.spawn().exit_on_failure();
+    ///
+    ///     auto line_string = rerun::components::GeoLineString::from_lat_lon(
+    ///         {{41.0000, -109.0452},
+    ///          {41.0000, -102.0415},
+    ///          {36.9931, -102.0415},
+    ///          {36.9931, -109.0452},
+    ///          {41.0000, -109.0452}}
+    ///     );
+    ///
+    ///     rec.log(
+    ///         "colorado",
+    ///         rerun::GeoLineStrings(line_string)
+    ///             .with_radii(rerun::Radius::ui_points(2.0f))
+    ///             .with_colors(rerun::Color(0, 0, 255))
+    ///     );
+    /// }
+    /// ```
+    struct GeoLineStrings {
+        /// The line strings, expressed in [EPSG:4326](https://epsg.io/4326) coordinates (North/East-positive degrees).
+        std::optional<ComponentBatch> line_strings;
+
+        /// Optional radii for the line strings.
+        ///
+        /// *Note*: scene units radiii are interpreted as meters. Currently, the display scale only considers the latitude of
+        /// the first vertex of each line string (see [this issue](https://github.com/rerun-io/rerun/issues/8013)).
+        std::optional<ComponentBatch> radii;
+
+        /// Optional colors for the line strings.
+        std::optional<ComponentBatch> colors;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.components.GeoLineStringsIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.archetypes.GeoLineStrings";
+
+        /// `ComponentDescriptor` for the `line_strings` field.
+        static constexpr auto Descriptor_line_strings = ComponentDescriptor(
+            ArchetypeName, "line_strings",
+            Loggable<rerun::components::GeoLineString>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `radii` field.
+        static constexpr auto Descriptor_radii = ComponentDescriptor(
+            ArchetypeName, "radii", Loggable<rerun::components::Radius>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `colors` field.
+        static constexpr auto Descriptor_colors = ComponentDescriptor(
+            ArchetypeName, "colors", Loggable<rerun::components::Color>::Descriptor.component_name
+        );
+
+      public:
+        GeoLineStrings() = default;
+        GeoLineStrings(GeoLineStrings&& other) = default;
+        GeoLineStrings(const GeoLineStrings& other) = default;
+        GeoLineStrings& operator=(const GeoLineStrings& other) = default;
+        GeoLineStrings& operator=(GeoLineStrings&& other) = default;
+
+        explicit GeoLineStrings(Collection<rerun::components::GeoLineString> _line_strings)
+            : line_strings(
+                  ComponentBatch::from_loggable(std::move(_line_strings), Descriptor_line_strings)
+                      .value_or_throw()
+              ) {}
+
+        /// Update only some specific fields of a `GeoLineStrings`.
+        static GeoLineStrings update_fields() {
+            return GeoLineStrings();
+        }
+
+        /// Clear all the fields of a `GeoLineStrings`.
+        static GeoLineStrings clear_fields();
+
+        /// The line strings, expressed in [EPSG:4326](https://epsg.io/4326) coordinates (North/East-positive degrees).
+        GeoLineStrings with_line_strings(
+            const Collection<rerun::components::GeoLineString>& _line_strings
+        ) && {
+            line_strings = ComponentBatch::from_loggable(_line_strings, Descriptor_line_strings)
+                               .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Optional radii for the line strings.
+        ///
+        /// *Note*: scene units radiii are interpreted as meters. Currently, the display scale only considers the latitude of
+        /// the first vertex of each line string (see [this issue](https://github.com/rerun-io/rerun/issues/8013)).
+        GeoLineStrings with_radii(const Collection<rerun::components::Radius>& _radii) && {
+            radii = ComponentBatch::from_loggable(_radii, Descriptor_radii).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Optional colors for the line strings.
+        GeoLineStrings with_colors(const Collection<rerun::components::Color>& _colors) && {
+            colors = ComponentBatch::from_loggable(_colors, Descriptor_colors).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<archetypes::GeoLineStrings> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const archetypes::GeoLineStrings& archetype
+        );
+    };
+} // namespace rerun

include/rerun/archetypes/geo_points.hpp

@@ -0,0 +1,177 @@
+// 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/archetypes/geo_points.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_batch.hpp"
+#include "../component_column.hpp"
+#include "../components/class_id.hpp"
+#include "../components/color.hpp"
+#include "../components/lat_lon.hpp"
+#include "../components/radius.hpp"
+#include "../indicator_component.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::archetypes {
+    /// **Archetype**: Geospatial points with positions expressed in [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees), and optional colors and radii.
+    ///
+    /// ## Example
+    ///
+    /// ### Log a geospatial point
+    /// ![image](https://static.rerun.io/geopoint_simple/b86ce83e5871837587bd33a0ad639358b96e9010/full.png)
+    ///
+    /// ```cpp
+    /// #include <rerun.hpp>
+    ///
+    /// int main() {
+    ///     const auto rec = rerun::RecordingStream("rerun_example_geo_points");
+    ///     rec.spawn().exit_on_failure();
+    ///
+    ///     rec.log(
+    ///         "rerun_hq",
+    ///         rerun::GeoPoints::from_lat_lon({{59.319221, 18.075631}})
+    ///             .with_radii(rerun::Radius::ui_points(10.0f))
+    ///             .with_colors(rerun::Color(255, 0, 0))
+    ///     );
+    /// }
+    /// ```
+    struct GeoPoints {
+        /// The [EPSG:4326](https://epsg.io/4326) coordinates for the points (North/East-positive degrees).
+        std::optional<ComponentBatch> positions;
+
+        /// Optional radii for the points, effectively turning them into circles.
+        ///
+        /// *Note*: scene units radiii are interpreted as meters.
+        std::optional<ComponentBatch> radii;
+
+        /// Optional colors for the points.
+        std::optional<ComponentBatch> colors;
+
+        /// Optional class Ids for the points.
+        ///
+        /// The `components::ClassId` provides colors if not specified explicitly.
+        std::optional<ComponentBatch> class_ids;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.components.GeoPointsIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.archetypes.GeoPoints";
+
+        /// `ComponentDescriptor` for the `positions` field.
+        static constexpr auto Descriptor_positions = ComponentDescriptor(
+            ArchetypeName, "positions",
+            Loggable<rerun::components::LatLon>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `radii` field.
+        static constexpr auto Descriptor_radii = ComponentDescriptor(
+            ArchetypeName, "radii", Loggable<rerun::components::Radius>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `colors` field.
+        static constexpr auto Descriptor_colors = ComponentDescriptor(
+            ArchetypeName, "colors", Loggable<rerun::components::Color>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `class_ids` field.
+        static constexpr auto Descriptor_class_ids = ComponentDescriptor(
+            ArchetypeName, "class_ids",
+            Loggable<rerun::components::ClassId>::Descriptor.component_name
+        );
+
+      public: // START of extensions from geo_points_ext.cpp:
+        /// Creates a new GeoPoints object based on [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees).
+        static GeoPoints from_lat_lon(Collection<components::LatLon> positions_) {
+            return GeoPoints(std::move(positions_));
+        }
+
+        // END of extensions from geo_points_ext.cpp, start of generated code:
+
+      public:
+        GeoPoints() = default;
+        GeoPoints(GeoPoints&& other) = default;
+        GeoPoints(const GeoPoints& other) = default;
+        GeoPoints& operator=(const GeoPoints& other) = default;
+        GeoPoints& operator=(GeoPoints&& other) = default;
+
+        explicit GeoPoints(Collection<rerun::components::LatLon> _positions)
+            : positions(ComponentBatch::from_loggable(std::move(_positions), Descriptor_positions)
+                            .value_or_throw()) {}
+
+        /// Update only some specific fields of a `GeoPoints`.
+        static GeoPoints update_fields() {
+            return GeoPoints();
+        }
+
+        /// Clear all the fields of a `GeoPoints`.
+        static GeoPoints clear_fields();
+
+        /// The [EPSG:4326](https://epsg.io/4326) coordinates for the points (North/East-positive degrees).
+        GeoPoints with_positions(const Collection<rerun::components::LatLon>& _positions) && {
+            positions =
+                ComponentBatch::from_loggable(_positions, Descriptor_positions).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Optional radii for the points, effectively turning them into circles.
+        ///
+        /// *Note*: scene units radiii are interpreted as meters.
+        GeoPoints with_radii(const Collection<rerun::components::Radius>& _radii) && {
+            radii = ComponentBatch::from_loggable(_radii, Descriptor_radii).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Optional colors for the points.
+        GeoPoints with_colors(const Collection<rerun::components::Color>& _colors) && {
+            colors = ComponentBatch::from_loggable(_colors, Descriptor_colors).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Optional class Ids for the points.
+        ///
+        /// The `components::ClassId` provides colors if not specified explicitly.
+        GeoPoints with_class_ids(const Collection<rerun::components::ClassId>& _class_ids) && {
+            class_ids =
+                ComponentBatch::from_loggable(_class_ids, Descriptor_class_ids).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<archetypes::GeoPoints> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(const archetypes::GeoPoints& archetype
+        );
+    };
+} // namespace rerun

include/rerun/archetypes/graph_edges.hpp

@@ -0,0 +1,152 @@
+// 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/archetypes/graph_edges.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_batch.hpp"
+#include "../component_column.hpp"
+#include "../components/graph_edge.hpp"
+#include "../components/graph_type.hpp"
+#include "../indicator_component.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::archetypes {
+    /// **Archetype**: A list of edges in a graph.
+    ///
+    /// By default, edges are undirected.
+    ///
+    /// ## Example
+    ///
+    /// ### Simple directed graph
+    /// ![image](https://static.rerun.io/graph_directed/ca29a37b65e1e0b6482251dce401982a0bc568fa/full.png)
+    ///
+    /// ```cpp
+    /// #include <rerun.hpp>
+    ///
+    /// int main() {
+    ///     const auto rec = rerun::RecordingStream("rerun_example_graph_directed");
+    ///     rec.spawn().exit_on_failure();
+    ///
+    ///     rec.log(
+    ///         "simple",
+    ///         rerun::GraphNodes({"a", "b", "c"})
+    ///             .with_positions({{0.0, 100.0}, {-100.0, 0.0}, {100.0, 0.0}})
+    ///             .with_labels({"A", "B", "C"}),
+    ///         rerun::GraphEdges({{"a", "b"}, {"b", "c"}, {"c", "a"}})
+    ///             // Graphs are undirected by default.
+    ///             .with_graph_type(rerun::components::GraphType::Directed)
+    ///     );
+    /// }
+    /// ```
+    struct GraphEdges {
+        /// A list of node tuples.
+        std::optional<ComponentBatch> edges;
+
+        /// Specifies if the graph is directed or undirected.
+        ///
+        /// If no `components::GraphType` is provided, the graph is assumed to be undirected.
+        std::optional<ComponentBatch> graph_type;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.components.GraphEdgesIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.archetypes.GraphEdges";
+
+        /// `ComponentDescriptor` for the `edges` field.
+        static constexpr auto Descriptor_edges = ComponentDescriptor(
+            ArchetypeName, "edges",
+            Loggable<rerun::components::GraphEdge>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `graph_type` field.
+        static constexpr auto Descriptor_graph_type = ComponentDescriptor(
+            ArchetypeName, "graph_type",
+            Loggable<rerun::components::GraphType>::Descriptor.component_name
+        );
+
+      public:
+        GraphEdges() = default;
+        GraphEdges(GraphEdges&& other) = default;
+        GraphEdges(const GraphEdges& other) = default;
+        GraphEdges& operator=(const GraphEdges& other) = default;
+        GraphEdges& operator=(GraphEdges&& other) = default;
+
+        explicit GraphEdges(Collection<rerun::components::GraphEdge> _edges)
+            : edges(ComponentBatch::from_loggable(std::move(_edges), Descriptor_edges)
+                        .value_or_throw()) {}
+
+        /// Update only some specific fields of a `GraphEdges`.
+        static GraphEdges update_fields() {
+            return GraphEdges();
+        }
+
+        /// Clear all the fields of a `GraphEdges`.
+        static GraphEdges clear_fields();
+
+        /// A list of node tuples.
+        GraphEdges with_edges(const Collection<rerun::components::GraphEdge>& _edges) && {
+            edges = ComponentBatch::from_loggable(_edges, Descriptor_edges).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Specifies if the graph is directed or undirected.
+        ///
+        /// If no `components::GraphType` is provided, the graph is assumed to be undirected.
+        GraphEdges with_graph_type(const rerun::components::GraphType& _graph_type) && {
+            graph_type =
+                ComponentBatch::from_loggable(_graph_type, Descriptor_graph_type).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// This method makes it possible to pack multiple `graph_type` in a single component batch.
+        ///
+        /// This only makes sense when used in conjunction with `columns`. `with_graph_type` should
+        /// be used when logging a single row's worth of data.
+        GraphEdges with_many_graph_type(const Collection<rerun::components::GraphType>& _graph_type
+        ) && {
+            graph_type =
+                ComponentBatch::from_loggable(_graph_type, Descriptor_graph_type).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<archetypes::GraphEdges> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(const archetypes::GraphEdges& archetype
+        );
+    };
+} // namespace rerun