grid_map.hpp

// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
// Based on "crates/build/re_type_definitions/rerun/archetypes/grid_map.def.rs".
 
#pragma once
 
#include "../collection.hpp"
#include "../component_batch.hpp"
#include "../component_column.hpp"
#include "../components/cell_size.hpp"
#include "../components/colormap.hpp"
#include "../components/draw_order.hpp"
#include "../components/image_buffer.hpp"
#include "../components/image_format.hpp"
#include "../components/opacity.hpp"
#include "../components/rotation_axis_angle.hpp"
#include "../components/rotation_quat.hpp"
#include "../components/translation3d.hpp"
#include "../result.hpp"
 
#include <cstdint>
#include <optional>
#include <utility>
#include <vector>
 
namespace rerun::archetypes {
    /// **Archetype**: A 2D grid map stored as raster data in an image buffer, with a cell size in scene units and pose.
    ///
    /// This archetype is intended for robotics applications like occupancy maps or navigation costmaps,
    /// but can also be useful for other use cases where an image buffer needs to be placed in a scene.
    ///
    /// ## Example
    ///
    /// ### Simple occupancy grid map
    /// ```cpp
    /// #include <rerun.hpp>
    ///
    /// #include <vector>
    ///
    /// int main(int argc, char* argv[]) {
    ///     const auto rec = rerun::RecordingStream("rerun_example_grid_map");
    ///     rec.spawn().exit_on_failure();
    ///
    ///     const size_t width = 64;
    ///     const size_t height = 64;
    ///     const float cell_size = 0.1f;
    ///
    ///     // Create a synthetic image with ROS `nav_msgs/OccupancyGrid` cell value conventions:
    ///     // -1 (255) unknown, 0 free, 100 occupied.
    ///     std::vector<uint8_t> grid(width * height, 255);
    ///     for (size_t y = 8; y <56; ++y) {
    ///         for (size_t x = 8; x <56; ++x) {
    ///             grid[y * width + x] = 0;
    ///         }
    ///     }
    ///     for (size_t y = 20; y <44; ++y) {
    ///         for (size_t x = 20; x <44; ++x) {
    ///             grid[y * width + x] = 100;
    ///         }
    ///     }
    ///
    ///     rec.log(
    ///         "world/map",
    ///         rerun::archetypes::GridMap()
    ///             .with_data(rerun::ImageBuffer(grid))
    ///             .with_format(rerun::components::ImageFormat(
    ///                 {width, height},
    ///                 rerun::ColorModel::L,
    ///                 rerun::ChannelDatatype::U8
    ///             ))
    ///             .with_cell_size(cell_size)
    ///             .with_translation(
    ///                 {-(static_cast<float>(width) * cell_size) / 2.0f,
    ///                  -(static_cast<float>(height) * cell_size) / 2.0f,
    ///                  0.0f}
    ///             )
    ///             .with_colormap(rerun::Colormap::RvizMap)
    ///     );
    /// }
    /// ```
    struct GridMap {
        /// The raw grid data.
        std::optional<ComponentBatch> data;
 
        /// The format of the grid's image data.
        std::optional<ComponentBatch> format;
 
        /// The scene unit size of a single grid cell (e.g. m / pixel).
        ///
        /// Defaults to 0.01 scene units per pixel.
        std::optional<ComponentBatch> cell_size;
 
        /// Translation of the lower-left corner of the grid map in space.
        ///
        /// Together with `components::RotationAxisAngle` or `components::RotationQuat`, this defines the pose of the
        /// lower-left image corner relative to the map's parent coordinate frame.
        ///
        /// If not set, the lower-left image corner is placed at origin of the map's parent coordinate frame.
        std::optional<ComponentBatch> translation;
 
        /// Rotation of the lower-left corner of the grid map in space via axis + angle.
        ///
        /// Together with `components::Translation3D`, this defines the pose of the
        /// lower-left image corner relative to the map's parent coordinate frame.
        ///
        /// Note: either this or `components::RotationQuat` can be set to specify the grid map's rotation, but not both.
        /// If both this and `components::RotationQuat` are set, this is ignored in favor of the quaternion.
        std::optional<ComponentBatch> rotation_axis_angle;
 
        /// Rotation of the lower-left corner of the grid map in space via quaternion.
        ///
        /// Together with `components::Translation3D`, this defines the pose of the
        /// lower-left image corner relative to the map's parent coordinate frame.
        std::optional<ComponentBatch> quaternion;
 
        /// Opacity of the grid map texture after all image decoding and colormap application.
        ///
        /// Defaults to 1.0 (fully opaque).
        std::optional<ComponentBatch> opacity;
 
        /// Optional draw order for layering multiple grid maps that overlap in space.
        ///
        /// Higher values are drawn on top of lower values.
        std::optional<ComponentBatch> draw_order;
 
        /// Colormap to use for rendering single-channel grid maps.
        ///
        /// If not set, the grid map is shown using the underlying `components::ImageFormat`
        /// interpretation.
        std::optional<ComponentBatch> colormap;
 
      public:
        /// The name of the archetype as used in `ComponentDescriptor`s.
        static constexpr const char ArchetypeName[] = "rerun.archetypes.GridMap";
 
        /// `ComponentDescriptor` for the `data` field.
        static constexpr auto Descriptor_data = ComponentDescriptor(
            ArchetypeName, "GridMap:data", Loggable<rerun::components::ImageBuffer>::ComponentType
        );
        /// `ComponentDescriptor` for the `format` field.
        static constexpr auto Descriptor_format = ComponentDescriptor(
            ArchetypeName, "GridMap:format", Loggable<rerun::components::ImageFormat>::ComponentType
        );
        /// `ComponentDescriptor` for the `cell_size` field.
        static constexpr auto Descriptor_cell_size = ComponentDescriptor(
            ArchetypeName, "GridMap:cell_size", Loggable<rerun::components::CellSize>::ComponentType
        );
        /// `ComponentDescriptor` for the `translation` field.
        static constexpr auto Descriptor_translation = ComponentDescriptor(
            ArchetypeName, "GridMap:translation",
            Loggable<rerun::components::Translation3D>::ComponentType
        );
        /// `ComponentDescriptor` for the `rotation_axis_angle` field.
        static constexpr auto Descriptor_rotation_axis_angle = ComponentDescriptor(
            ArchetypeName, "GridMap:rotation_axis_angle",
            Loggable<rerun::components::RotationAxisAngle>::ComponentType
        );
        /// `ComponentDescriptor` for the `quaternion` field.
        static constexpr auto Descriptor_quaternion = ComponentDescriptor(
            ArchetypeName, "GridMap:quaternion",
            Loggable<rerun::components::RotationQuat>::ComponentType
        );
        /// `ComponentDescriptor` for the `opacity` field.
        static constexpr auto Descriptor_opacity = ComponentDescriptor(
            ArchetypeName, "GridMap:opacity", Loggable<rerun::components::Opacity>::ComponentType
        );
        /// `ComponentDescriptor` for the `draw_order` field.
        static constexpr auto Descriptor_draw_order = ComponentDescriptor(
            ArchetypeName, "GridMap:draw_order",
            Loggable<rerun::components::DrawOrder>::ComponentType
        );
        /// `ComponentDescriptor` for the `colormap` field.
        static constexpr auto Descriptor_colormap = ComponentDescriptor(
            ArchetypeName, "GridMap:colormap", Loggable<rerun::components::Colormap>::ComponentType
        );
 
      public:
        GridMap() = default;
        GridMap(GridMap&& other) = default;
        GridMap(const GridMap& other) = default;
        GridMap& operator=(const GridMap& other) = default;
        GridMap& operator=(GridMap&& other) = default;
 
        /// Update only some specific fields of a `GridMap`.
        static GridMap update_fields() {
            return GridMap();
        }
 
        /// Clear all the fields of a `GridMap`.
        static GridMap clear_fields();
 
        /// The raw grid data.
        GridMap with_data(const rerun::components::ImageBuffer& _data) && {
            data = ComponentBatch::from_loggable(_data, Descriptor_data).value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `data` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_data` should
        /// be used when logging a single row's worth of data.
        GridMap with_many_data(const Collection<rerun::components::ImageBuffer>& _data) && {
            data = ComponentBatch::from_loggable(_data, Descriptor_data).value_or_throw();
            return std::move(*this);
        }
 
        /// The format of the grid's image data.
        GridMap with_format(const rerun::components::ImageFormat& _format) && {
            format = ComponentBatch::from_loggable(_format, Descriptor_format).value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `format` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_format` should
        /// be used when logging a single row's worth of data.
        GridMap with_many_format(const Collection<rerun::components::ImageFormat>& _format) && {
            format = ComponentBatch::from_loggable(_format, Descriptor_format).value_or_throw();
            return std::move(*this);
        }
 
        /// The scene unit size of a single grid cell (e.g. m / pixel).
        ///
        /// Defaults to 0.01 scene units per pixel.
        GridMap with_cell_size(const rerun::components::CellSize& _cell_size) && {
            cell_size =
                ComponentBatch::from_loggable(_cell_size, Descriptor_cell_size).value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `cell_size` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_cell_size` should
        /// be used when logging a single row's worth of data.
        GridMap with_many_cell_size(const Collection<rerun::components::CellSize>& _cell_size) && {
            cell_size =
                ComponentBatch::from_loggable(_cell_size, Descriptor_cell_size).value_or_throw();
            return std::move(*this);
        }
 
        /// Translation of the lower-left corner of the grid map in space.
        ///
        /// Together with `components::RotationAxisAngle` or `components::RotationQuat`, this defines the pose of the
        /// lower-left image corner relative to the map's parent coordinate frame.
        ///
        /// If not set, the lower-left image corner is placed at origin of the map's parent coordinate frame.
        GridMap with_translation(const rerun::components::Translation3D& _translation) && {
            translation = ComponentBatch::from_loggable(_translation, Descriptor_translation)
                              .value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `translation` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_translation` should
        /// be used when logging a single row's worth of data.
        GridMap with_many_translation(
            const Collection<rerun::components::Translation3D>& _translation
        ) && {
            translation = ComponentBatch::from_loggable(_translation, Descriptor_translation)
                              .value_or_throw();
            return std::move(*this);
        }
 
        /// Rotation of the lower-left corner of the grid map in space via axis + angle.
        ///
        /// Together with `components::Translation3D`, this defines the pose of the
        /// lower-left image corner relative to the map's parent coordinate frame.
        ///
        /// Note: either this or `components::RotationQuat` can be set to specify the grid map's rotation, but not both.
        /// If both this and `components::RotationQuat` are set, this is ignored in favor of the quaternion.
        GridMap with_rotation_axis_angle(
            const rerun::components::RotationAxisAngle& _rotation_axis_angle
        ) && {
            rotation_axis_angle =
                ComponentBatch::from_loggable(_rotation_axis_angle, Descriptor_rotation_axis_angle)
                    .value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `rotation_axis_angle` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_rotation_axis_angle` should
        /// be used when logging a single row's worth of data.
        GridMap with_many_rotation_axis_angle(
            const Collection<rerun::components::RotationAxisAngle>& _rotation_axis_angle
        ) && {
            rotation_axis_angle =
                ComponentBatch::from_loggable(_rotation_axis_angle, Descriptor_rotation_axis_angle)
                    .value_or_throw();
            return std::move(*this);
        }
 
        /// Rotation of the lower-left corner of the grid map in space via quaternion.
        ///
        /// Together with `components::Translation3D`, this defines the pose of the
        /// lower-left image corner relative to the map's parent coordinate frame.
        GridMap with_quaternion(const rerun::components::RotationQuat& _quaternion) && {
            quaternion =
                ComponentBatch::from_loggable(_quaternion, Descriptor_quaternion).value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `quaternion` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_quaternion` should
        /// be used when logging a single row's worth of data.
        GridMap with_many_quaternion(const Collection<rerun::components::RotationQuat>& _quaternion
        ) && {
            quaternion =
                ComponentBatch::from_loggable(_quaternion, Descriptor_quaternion).value_or_throw();
            return std::move(*this);
        }
 
        /// Opacity of the grid map texture after all image decoding and colormap application.
        ///
        /// Defaults to 1.0 (fully opaque).
        GridMap with_opacity(const rerun::components::Opacity& _opacity) && {
            opacity = ComponentBatch::from_loggable(_opacity, Descriptor_opacity).value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `opacity` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_opacity` should
        /// be used when logging a single row's worth of data.
        GridMap with_many_opacity(const Collection<rerun::components::Opacity>& _opacity) && {
            opacity = ComponentBatch::from_loggable(_opacity, Descriptor_opacity).value_or_throw();
            return std::move(*this);
        }
 
        /// Optional draw order for layering multiple grid maps that overlap in space.
        ///
        /// Higher values are drawn on top of lower values.
        GridMap with_draw_order(const rerun::components::DrawOrder& _draw_order) && {
            draw_order =
                ComponentBatch::from_loggable(_draw_order, Descriptor_draw_order).value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `draw_order` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_draw_order` should
        /// be used when logging a single row's worth of data.
        GridMap with_many_draw_order(const Collection<rerun::components::DrawOrder>& _draw_order
        ) && {
            draw_order =
                ComponentBatch::from_loggable(_draw_order, Descriptor_draw_order).value_or_throw();
            return std::move(*this);
        }
 
        /// Colormap to use for rendering single-channel grid maps.
        ///
        /// If not set, the grid map is shown using the underlying `components::ImageFormat`
        /// interpretation.
        GridMap with_colormap(const rerun::components::Colormap& _colormap) && {
            colormap =
                ComponentBatch::from_loggable(_colormap, Descriptor_colormap).value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `colormap` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_colormap` should
        /// be used when logging a single row's worth of data.
        GridMap with_many_colormap(const Collection<rerun::components::Colormap>& _colormap) && {
            colormap =
                ComponentBatch::from_loggable(_colormap, Descriptor_colormap).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::GridMap> {
        /// Serialize all set component batches.
        static Result<Collection<ComponentBatch>> as_batches(const archetypes::GridMap& archetype);
    };
} // namespace rerun