spherical_harmonics3rgb.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/encodings/spherical_harmonics3rgb.def.rs".
 
#pragma once
 
#include "../half.hpp"
#include "../result.hpp"
 
#include <array>
#include <cstdint>
#include <memory>
 
namespace arrow {
    class Array;
    class DataType;
    class FixedSizeListBuilder;
} // namespace arrow
 
namespace rerun::encodings {
    /// **Encoding**: Spherical harmonics coefficients of degrees 1 through 3 for RGB, as 15 half-precision RGB triples.
    ///
    /// The coefficients are stored coefficient-major: `[c1.rgb, c2.rgb, …, c15.rgb]`.
    /// The 15 coefficients `c1…c15` are ordered by ascending degree `l = 1, 2, 3`, and within
    /// each degree by ascending order `m = -l … +l`:
    /// degree 1 is `c1…c3`, degree 2 is `c4…c8`, and degree 3 is `c9…c15`.
    /// The degrees are not exposed as separate groups, since each degree has a different
    /// number of coefficients (3, 5, and 7).
    ///
    /// This per-coefficient order matches the `f_rest_*` properties of the PLY files used by
    /// [3D Gaussian Splatting](https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/) (Kerbl et al., 2023),
    /// but those store the channels channel-major (all 15 coefficients of R, then G, then B),
    /// so they must be transposed on import.
    ///
    /// The degree-0 (DC) term is *not* included — it is represented as a `encodings::Rgba32` color instead.
    ///
    /// Data of a lower spherical harmonics degree should be zero-padded,
    /// which represents the exact same function (the spherical harmonics basis is orthonormal).
    /// Conversely, truncating trailing coefficients at the degree boundaries (3 and 8 triples)
    /// yields the optimal least-squares approximation of that lower degree.
    ///
    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
    ///
    struct SphericalHarmonics3Rgb {
        /// Spherical harmonics coefficients of degrees 1 through 3, coefficient-major.
        std::array<std::array<rerun::half, 3>, 15> coefficients;
 
      public: // START of extensions from spherical_harmonics3rgb_ext.cpp:
        /// The number of coefficients of degrees 1 through 3, i.e. the number of RGB triples.
        static constexpr size_t NUM_COEFFICIENTS = 15;
 
        /// Construct from 15 RGB coefficient triples of `float`, converting each to half-precision.
        SphericalHarmonics3Rgb(
            const std::array<std::array<float, 3>, NUM_COEFFICIENTS>& coefficients_
        );
 
        // END of extensions from spherical_harmonics3rgb_ext.cpp, start of generated code:
 
      public:
        SphericalHarmonics3Rgb() = default;
 
        SphericalHarmonics3Rgb(std::array<std::array<rerun::half, 3>, 15> coefficients_)
            : coefficients(coefficients_) {}
 
        SphericalHarmonics3Rgb& operator=(std::array<std::array<rerun::half, 3>, 15> coefficients_
        ) {
            coefficients = coefficients_;
            return *this;
        }
    };
} // namespace rerun::encodings
 
namespace rerun {
    template <typename T>
    struct Loggable;
 
    /// \private
    template <>
    struct Loggable<encodings::SphericalHarmonics3Rgb> {
        static constexpr std::string_view ComponentType = "rerun.encodings.SphericalHarmonics3Rgb";
 
        /// Returns the arrow data type this type corresponds to.
        static const std::shared_ptr<arrow::DataType>& arrow_data_type();
 
        /// Serializes an array of `rerun::encodings::SphericalHarmonics3Rgb` into an arrow array.
        static Result<std::shared_ptr<arrow::Array>> to_arrow(
            const encodings::SphericalHarmonics3Rgb* instances, size_t num_instances
        );
 
        /// Fills an arrow array builder with an array of this type.
        static rerun::Error fill_arrow_array_builder(
            arrow::FixedSizeListBuilder* builder, const encodings::SphericalHarmonics3Rgb* elements,
            size_t num_elements
        );
    };
} // namespace rerun