voxel_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/store/re_sdk_types/definitions/rerun/archetypes/voxel_grid_map.fbs".
 
#pragma once
 
#include "../collection.hpp"
#include "../component_batch.hpp"
#include "../component_column.hpp"
#include "../components/color.hpp"
#include "../components/colormap.hpp"
#include "../components/opacity.hpp"
#include "../components/rotation_axis_angle.hpp"
#include "../components/rotation_quat.hpp"
#include "../components/translation3d.hpp"
#include "../components/value_range.hpp"
#include "../components/voxel_index.hpp"
#include "../components/voxel_size.hpp"
#include "../components/voxel_value.hpp"
#include "../result.hpp"
 
#include <cstdint>
#include <optional>
#include <utility>
#include <vector>
 
namespace rerun::archetypes {
    /// **Archetype**: A sparse 3D voxel grid map with grid indices and voxel dimensions.
    ///
    /// This archetype is intended for 3D occupancy maps and other volumetric data
    /// represented as a sparse grid of voxels with scene-unit dimensions along the local X/Y/Z axes.
    ///
    /// The minimum corner of the voxel with `[0, 0, 0]` index is located at the origin of the entity's coordinate frame
    /// and can have an additional offset from there through the optional translation and rotation fields.
    ///
    /// A voxel center is at `(index + 0.5) * voxel_size` in local grid coordinates (i.e. relative to the minimum corner).
    ///
    /// ## Example
    ///
    /// ### Simple sparse voxel grid map
    /// ```cpp
    /// #include <rerun.hpp>
    ///
    /// #include <array>
    /// #include <vector>
    ///
    /// int main(int argc, char* argv[]) {
    ///     const auto rec =
    ///         rerun::RecordingStream("rerun_example_voxel_grid_map_simple");
    ///     rec.spawn().exit_on_failure();
    ///
    ///     const std::vector<rerun::components::VoxelIndex> voxel_indices = {
    ///         rerun::components::VoxelIndex(-1, 0, 0),
    ///         rerun::components::VoxelIndex(1, 0, 0),
    ///         rerun::components::VoxelIndex(1, 1, 0),
    ///         rerun::components::VoxelIndex(3, 0, 0),
    ///         rerun::components::VoxelIndex(3, 0, 1),
    ///         rerun::components::VoxelIndex(4, 0, 1),
    ///     };
    ///     const std::vector<rerun::components::VoxelValue> values = {
    ///         0.0f,
    ///         0.2f,
    ///         0.4f,
    ///         0.6f,
    ///         0.8f,
    ///         1.0f,
    ///     };
    ///
    ///     rec.log(
    ///         "world/voxels",
    ///         rerun::archetypes::VoxelGridMap(
    ///             voxel_indices,
    ///             std::array<float, 3>{0.25f, 0.25f, 0.25f}
    ///         )
    ///             .with_values(values)
    ///             .with_value_range(
    ///                 rerun::components::ValueRange(std::array<double, 2>{0.0, 1.0})
    ///             )
    ///             .with_colormap(rerun::components::Colormap::Turbo)
    ///             .with_translation({-0.5f, -0.5f, 0.0f})
    ///     );
    /// }
    /// ```
    ///
    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
    ///
    struct VoxelGridMap {
        /// Indices of the voxels within the grid volume.
        std::optional<ComponentBatch> voxel_indices;
 
        /// The scene-unit dimensions of a single voxel cell.
        ///
        /// This defines the voxel size along the local grid X/Y/Z axes.
        /// Each dimension must be finite and positive.
        std::optional<ComponentBatch> voxel_size;
 
        /// Optional scalar occupancy or value data for each voxel.
        ///
        /// If explicit colors are not provided, values are mapped through `colormap` and `value_range`.
        std::optional<ComponentBatch> values;
 
        /// Optional colors for each voxel.
        ///
        /// If set, these colors take precedence over color-mapped scalar values.
        std::optional<ComponentBatch> colors;
 
        /// Translation of the minimum corner of voxel `[0, 0, 0]`.
        ///
        /// Together with `components::RotationAxisAngle` or `components::RotationQuat`, this defines the pose of the
        /// grid relative to the map's parent coordinate frame.
        ///
        /// If not set, the minimum corner is placed at the origin of the map's parent coordinate frame.
        std::optional<ComponentBatch> translation;
 
        /// Rotation of the grid via axis + angle.
        ///
        /// Together with `components::Translation3D`, this defines the pose of the grid relative to the
        /// map's parent coordinate frame.
        ///
        /// Note: either this or `components::RotationQuat` can be set to specify the grid'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 grid via quaternion.
        ///
        /// Together with `components::Translation3D`, this defines the pose of the grid relative to the
        /// map's parent coordinate frame.
        std::optional<ComponentBatch> quaternion;
 
        /// Opacity of the voxels after color or colormap application.
        ///
        /// Defaults to 1.0 (fully opaque).
        std::optional<ComponentBatch> opacity;
 
        /// Scalar value range for color-mapping.
        ///
        /// Defaults to `[0.0, 1.0]`.
        std::optional<ComponentBatch> value_range;
 
        /// Colormap to use when `values` are present and explicit `colors` are not provided.
        ///
        /// Defaults to Turbo.
        std::optional<ComponentBatch> colormap;
 
      public:
        /// The name of the archetype as used in `ComponentDescriptor`s.
        static constexpr const char ArchetypeName[] = "rerun.archetypes.VoxelGridMap";
 
        /// `ComponentDescriptor` for the `voxel_indices` field.
        static constexpr auto Descriptor_voxel_indices = ComponentDescriptor(
            ArchetypeName, "VoxelGridMap:voxel_indices",
            Loggable<rerun::components::VoxelIndex>::ComponentType
        );
        /// `ComponentDescriptor` for the `voxel_size` field.
        static constexpr auto Descriptor_voxel_size = ComponentDescriptor(
            ArchetypeName, "VoxelGridMap:voxel_size",
            Loggable<rerun::components::VoxelSize>::ComponentType
        );
        /// `ComponentDescriptor` for the `values` field.
        static constexpr auto Descriptor_values = ComponentDescriptor(
            ArchetypeName, "VoxelGridMap:values",
            Loggable<rerun::components::VoxelValue>::ComponentType
        );
        /// `ComponentDescriptor` for the `colors` field.
        static constexpr auto Descriptor_colors = ComponentDescriptor(
            ArchetypeName, "VoxelGridMap:colors", Loggable<rerun::components::Color>::ComponentType
        );
        /// `ComponentDescriptor` for the `translation` field.
        static constexpr auto Descriptor_translation = ComponentDescriptor(
            ArchetypeName, "VoxelGridMap:translation",
            Loggable<rerun::components::Translation3D>::ComponentType
        );
        /// `ComponentDescriptor` for the `rotation_axis_angle` field.
        static constexpr auto Descriptor_rotation_axis_angle = ComponentDescriptor(
            ArchetypeName, "VoxelGridMap:rotation_axis_angle",
            Loggable<rerun::components::RotationAxisAngle>::ComponentType
        );
        /// `ComponentDescriptor` for the `quaternion` field.
        static constexpr auto Descriptor_quaternion = ComponentDescriptor(
            ArchetypeName, "VoxelGridMap:quaternion",
            Loggable<rerun::components::RotationQuat>::ComponentType
        );
        /// `ComponentDescriptor` for the `opacity` field.
        static constexpr auto Descriptor_opacity = ComponentDescriptor(
            ArchetypeName, "VoxelGridMap:opacity",
            Loggable<rerun::components::Opacity>::ComponentType
        );
        /// `ComponentDescriptor` for the `value_range` field.
        static constexpr auto Descriptor_value_range = ComponentDescriptor(
            ArchetypeName, "VoxelGridMap:value_range",
            Loggable<rerun::components::ValueRange>::ComponentType
        );
        /// `ComponentDescriptor` for the `colormap` field.
        static constexpr auto Descriptor_colormap = ComponentDescriptor(
            ArchetypeName, "VoxelGridMap:colormap",
            Loggable<rerun::components::Colormap>::ComponentType
        );
 
      public:
        VoxelGridMap() = default;
        VoxelGridMap(VoxelGridMap&& other) = default;
        VoxelGridMap(const VoxelGridMap& other) = default;
        VoxelGridMap& operator=(const VoxelGridMap& other) = default;
        VoxelGridMap& operator=(VoxelGridMap&& other) = default;
 
        explicit VoxelGridMap(
            Collection<rerun::components::VoxelIndex> _voxel_indices,
            rerun::components::VoxelSize _voxel_size
        )
            : voxel_indices(
                  ComponentBatch::from_loggable(std::move(_voxel_indices), Descriptor_voxel_indices)
                      .value_or_throw()
              ),
              voxel_size(
                  ComponentBatch::from_loggable(std::move(_voxel_size), Descriptor_voxel_size)
                      .value_or_throw()
              ) {}
 
        /// Update only some specific fields of a `VoxelGridMap`.
        static VoxelGridMap update_fields() {
            return VoxelGridMap();
        }
 
        /// Clear all the fields of a `VoxelGridMap`.
        static VoxelGridMap clear_fields();
 
        /// Indices of the voxels within the grid volume.
        VoxelGridMap with_voxel_indices(
            const Collection<rerun::components::VoxelIndex>& _voxel_indices
        ) && {
            voxel_indices = ComponentBatch::from_loggable(_voxel_indices, Descriptor_voxel_indices)
                                .value_or_throw();
            return std::move(*this);
        }
 
        /// The scene-unit dimensions of a single voxel cell.
        ///
        /// This defines the voxel size along the local grid X/Y/Z axes.
        /// Each dimension must be finite and positive.
        VoxelGridMap with_voxel_size(const rerun::components::VoxelSize& _voxel_size) && {
            voxel_size =
                ComponentBatch::from_loggable(_voxel_size, Descriptor_voxel_size).value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `voxel_size` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_voxel_size` should
        /// be used when logging a single row's worth of data.
        VoxelGridMap with_many_voxel_size(
            const Collection<rerun::components::VoxelSize>& _voxel_size
        ) && {
            voxel_size =
                ComponentBatch::from_loggable(_voxel_size, Descriptor_voxel_size).value_or_throw();
            return std::move(*this);
        }
 
        /// Optional scalar occupancy or value data for each voxel.
        ///
        /// If explicit colors are not provided, values are mapped through `colormap` and `value_range`.
        VoxelGridMap with_values(const Collection<rerun::components::VoxelValue>& _values) && {
            values = ComponentBatch::from_loggable(_values, Descriptor_values).value_or_throw();
            return std::move(*this);
        }
 
        /// Optional colors for each voxel.
        ///
        /// If set, these colors take precedence over color-mapped scalar values.
        VoxelGridMap with_colors(const Collection<rerun::components::Color>& _colors) && {
            colors = ComponentBatch::from_loggable(_colors, Descriptor_colors).value_or_throw();
            return std::move(*this);
        }
 
        /// Translation of the minimum corner of voxel `[0, 0, 0]`.
        ///
        /// Together with `components::RotationAxisAngle` or `components::RotationQuat`, this defines the pose of the
        /// grid relative to the map's parent coordinate frame.
        ///
        /// If not set, the minimum corner is placed at the origin of the map's parent coordinate frame.
        VoxelGridMap 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.
        VoxelGridMap 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 grid via axis + angle.
        ///
        /// Together with `components::Translation3D`, this defines the pose of the grid relative to the
        /// map's parent coordinate frame.
        ///
        /// Note: either this or `components::RotationQuat` can be set to specify the grid's rotation, but not both.
        /// If both this and `components::RotationQuat` are set, this is ignored in favor of the quaternion.
        VoxelGridMap 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.
        VoxelGridMap 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 grid via quaternion.
        ///
        /// Together with `components::Translation3D`, this defines the pose of the grid relative to the
        /// map's parent coordinate frame.
        VoxelGridMap 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.
        VoxelGridMap 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 voxels after color or colormap application.
        ///
        /// Defaults to 1.0 (fully opaque).
        VoxelGridMap 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.
        VoxelGridMap with_many_opacity(const Collection<rerun::components::Opacity>& _opacity) && {
            opacity = ComponentBatch::from_loggable(_opacity, Descriptor_opacity).value_or_throw();
            return std::move(*this);
        }
 
        /// Scalar value range for color-mapping.
        ///
        /// Defaults to `[0.0, 1.0]`.
        VoxelGridMap with_value_range(const rerun::components::ValueRange& _value_range) && {
            value_range = ComponentBatch::from_loggable(_value_range, Descriptor_value_range)
                              .value_or_throw();
            return std::move(*this);
        }
 
        /// This method makes it possible to pack multiple `value_range` in a single component batch.
        ///
        /// This only makes sense when used in conjunction with `columns`. `with_value_range` should
        /// be used when logging a single row's worth of data.
        VoxelGridMap with_many_value_range(
            const Collection<rerun::components::ValueRange>& _value_range
        ) && {
            value_range = ComponentBatch::from_loggable(_value_range, Descriptor_value_range)
                              .value_or_throw();
            return std::move(*this);
        }
 
        /// Colormap to use when `values` are present and explicit `colors` are not provided.
        ///
        /// Defaults to Turbo.
        VoxelGridMap 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.
        VoxelGridMap 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::VoxelGridMap> {
        /// Serialize all set component batches.
        static Result<Collection<ComponentBatch>> as_batches(
            const archetypes::VoxelGridMap& archetype
        );
    };
} // namespace rerun