colorimetric_response.h

Go to the documentation of this file.

 
#pragma once
 
#include "fl/math/math.h"
#include "fl/gfx/color_profile.h"
#include "fl/stl/stdint.h"
 
namespace fl {
namespace colorimetric_response {
 
// ===== Pure-math inline helpers ==============================================
// Tight, leaf-level operations kept inline because:
//   1. They're trivial bodies (≤ 25 lines).
//   2. They appear in hot inner loops; inlining lets the optimizer fold them.
//   3. Tests can validate them directly without a full library rebuild.
 
// Krystek's approximation for blackbody chromaticity (good 1000K - 15000K).
// Krystek's outputs are (u, v) in the CIE 1960 UCS; convert to xy via the
// standard 1960->xy formulas. Reference: Krystek, "An algorithm to calculate
// correlated color temperature", Color Research & Application, 1985.
inline void cct_to_xy(int cct, float out[2]) FL_NO_EXCEPT {
    const float T = static_cast<float>(
        (cct < 1500) ? 1500 : ((cct > 15000) ? 15000 : cct));
    const float T2 = T * T;
    const float u_num = 0.860117757f + 1.54118254e-4f * T + 1.28641212e-7f * T2;
    const float u_den = 1.0f + 8.42420235e-4f * T + 7.08145163e-7f * T2;
    const float v_num = 0.317398726f + 4.22806245e-5f * T + 4.20481691e-8f * T2;
    const float v_den = 1.0f - 2.89741816e-5f * T + 1.61456053e-7f * T2;
    const float u = u_num / u_den;
    const float v = v_num / v_den;
    const float den = 2.0f * u - 8.0f * v + 4.0f;
    out[0] = 3.0f * u / den;
    out[1] = 2.0f * v / den;
}
 
inline void xyY_to_XYZ(float x, float y, float Y, float out[3]) FL_NO_EXCEPT {
    if (y < 1e-12f) {
        out[0] = out[1] = out[2] = 0.0f;
        return;
    }
    const float inv_y = 1.0f / y;
    out[0] = x * Y * inv_y;
    out[1] = Y;
    out[2] = (1.0f - x - y) * Y * inv_y;
}
 
namespace detail {

constexpr float kRelativeSingularity = 1e-6f;

inline float columnScale(float a, float b, float c) FL_NO_EXCEPT {
    const float x = fl::fabs(a);
    const float y = fl::fabs(b);
    const float z = fl::fabs(c);
    float largest = x > y ? x : y;
    if (z > largest) {
        largest = z;
    }
    return largest;
}
 
}  // namespace detail
 
inline bool invert3x3(const float in[3][3], float out[3][3]) FL_NO_EXCEPT {
    const float a = in[0][0], b = in[0][1], c = in[0][2];
    const float d = in[1][0], e = in[1][1], f = in[1][2];
    const float g = in[2][0], h = in[2][1], i = in[2][2];
    const float det = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
 
    // Scale the test by the matrix's own magnitude, because an absolute
    // threshold cannot see the ratio that actually decides invertibility.
    //
    // Each column is divided by its largest entry and the determinant of
    // *that* matrix is what gets tested. The obvious alternative -- compare
    // |det| against the product of the column 2-norms -- needs `a * a`, which
    // overflows float32 for entries past about 1.8e19: `diag(1e20, 1e-20, 1)`
    // has determinant 1 and a perfectly representable inverse, and squaring
    // would send its first column norm to infinity and reject it. Dividing
    // first cannot overflow, and it costs three divisions instead of three
    // square roots.
    const float scale_a = detail::columnScale(a, d, g);
    const float scale_b = detail::columnScale(b, e, h);
    const float scale_c = detail::columnScale(c, f, i);
 
    // One negated `>`, which covers three cases at once and is why there is
    // no separate zero or NaN check: a zero column makes its scale zero, so
    // the division below yields infinity or NaN and the comparison fails; a
    // NaN anywhere makes every comparison false, so the negation rejects. An
    // explicit `scale > 0` clause was written here first, and mutation
    // testing showed it could not fire.
    const float an = a / scale_a, dn = d / scale_a, gn = g / scale_a;
    const float bn = b / scale_b, en = e / scale_b, hn = h / scale_b;
    const float cn = c / scale_c, fn = f / scale_c, in_ = i / scale_c;
    const float det_normalized = an * (en * in_ - fn * hn) -
                                 bn * (dn * in_ - fn * gn) +
                                 cn * (dn * hn - en * gn);
    if (!(fl::fabs(det_normalized) > detail::kRelativeSingularity)) {
        return false;
    }
 
    const float inv_det = 1.0f / det;
    out[0][0] = (e * i - f * h) * inv_det;
    out[0][1] = (c * h - b * i) * inv_det;
    out[0][2] = (b * f - c * e) * inv_det;
    out[1][0] = (f * g - d * i) * inv_det;
    out[1][1] = (a * i - c * g) * inv_det;
    out[1][2] = (c * d - a * f) * inv_det;
    out[2][0] = (d * h - e * g) * inv_det;
    out[2][1] = (b * g - a * h) * inv_det;
    out[2][2] = (a * e - b * d) * inv_det;
    return true;
}
 
inline void matvec3(const float M[3][3], const float v[3], float out[3]) FL_NO_EXCEPT {
    out[0] = M[0][0] * v[0] + M[0][1] * v[1] + M[0][2] * v[2];
    out[1] = M[1][0] * v[0] + M[1][1] * v[1] + M[1][2] * v[2];
    out[2] = M[2][0] * v[0] + M[2][1] * v[1] + M[2][2] * v[2];
}
 
inline bool barycentric_xy(const float t[2], const float A[2], const float B[2],
                           const float C[2], float bary[3]) FL_NO_EXCEPT {
    const float v0x = B[0] - A[0], v0y = B[1] - A[1];
    const float v1x = C[0] - A[0], v1y = C[1] - A[1];
    const float v2x = t[0] - A[0], v2y = t[1] - A[1];
    const float d00 = v0x * v0x + v0y * v0y;
    const float d01 = v0x * v1x + v0y * v1y;
    const float d11 = v1x * v1x + v1y * v1y;
    const float d20 = v2x * v0x + v2y * v0y;
    const float d21 = v2x * v1x + v2y * v1y;
    const float den = d00 * d11 - d01 * d01;
    if (fl::fabs(den) < 1e-20f) {
        return false;
    }
    const float inv_den = 1.0f / den;
    const float u = (d11 * d20 - d01 * d21) * inv_den;
    const float v = (d00 * d21 - d01 * d20) * inv_den;
    bary[0] = 1.0f - u - v;
    bary[1] = u;
    bary[2] = v;
    return true;
}
 
inline u8 quantize_u8(float v) FL_NO_EXCEPT {
    const float scaled = v * 255.0f + 0.5f;
    if (scaled <= 0.0f) return 0;
    if (scaled >= 255.0f) return 255;
    return static_cast<u8>(scaled);
}
 
// Standard CIE primary-matrix construction (#2705). Given source primary
// chromaticities xy_r/g/b and a source white chromaticity xy_w, build the
// 3x3 matrix M such that M·[1,1,1]^T = xyY_to_XYZ(xy_w, 1.0). Columns are
// per-channel scaled XYZ vectors of the primaries at Y=1, with scaling
// chosen so the (1,1,1) input lands at source white in XYZ. This is the
// classic linear-sRGB -> XYZ derivation generalized to arbitrary primaries.
// Returns false if the primary matrix is singular (collinear chromaticities).
inline bool build_source_matrix(const float xy_r[2], const float xy_g[2],
                                const float xy_b[2], const float xy_w[2],
                                float M_out[3][3]) FL_NO_EXCEPT {
    float xyz_R[3], xyz_G[3], xyz_B[3], xyz_W[3];
    xyY_to_XYZ(xy_r[0], xy_r[1], 1.0f, xyz_R);
    xyY_to_XYZ(xy_g[0], xy_g[1], 1.0f, xyz_G);
    xyY_to_XYZ(xy_b[0], xy_b[1], 1.0f, xyz_B);
    xyY_to_XYZ(xy_w[0], xy_w[1], 1.0f, xyz_W);
 
    float P[3][3];
    P[0][0] = xyz_R[0]; P[0][1] = xyz_G[0]; P[0][2] = xyz_B[0];
    P[1][0] = xyz_R[1]; P[1][1] = xyz_G[1]; P[1][2] = xyz_B[1];
    P[2][0] = xyz_R[2]; P[2][1] = xyz_G[2]; P[2][2] = xyz_B[2];
 
    float P_inv[3][3];
    if (!invert3x3(P, P_inv)) {
        return false;
    }
    float k[3];
    matvec3(P_inv, xyz_W, k);
 
    M_out[0][0] = k[0] * xyz_R[0]; M_out[0][1] = k[1] * xyz_G[0]; M_out[0][2] = k[2] * xyz_B[0];
    M_out[1][0] = k[0] * xyz_R[1]; M_out[1][1] = k[1] * xyz_G[1]; M_out[1][2] = k[2] * xyz_B[1];
    M_out[2][0] = k[0] * xyz_R[2]; M_out[2][1] = k[1] * xyz_G[2]; M_out[2][2] = k[2] * xyz_B[2];
    return true;
}
 
// Non-negative least squares for the 3×3 sub-system M·t = b with t ≥ 0
// (#2708, gist §3). Projected-gradient form matching the reference
// `_nnls_solve` fallback used when scipy is unavailable: 500 iterations at
// step 0.01. Cheap (~50 µs scalar on a typical MCU at -O2; only invoked for
// out-of-hull source targets, never on the in-hull fast path) and free of
// dynamic allocation, which makes it safe to inline behind the colorimetric
// solvers' rare-branch.
inline void nnls3(const float M[3][3], const float b[3],   // ok array parameter
                  float t_out[3], float* residual_out) FL_NO_EXCEPT {
    float t[3] = {0.0f, 0.0f, 0.0f};
    constexpr float kStep = 0.01f;
    constexpr int kIters = 500;
    for (int it = 0; it < kIters; ++it) {
        float r[3];
        r[0] = M[0][0]*t[0] + M[0][1]*t[1] + M[0][2]*t[2] - b[0];
        r[1] = M[1][0]*t[0] + M[1][1]*t[1] + M[1][2]*t[2] - b[1];
        r[2] = M[2][0]*t[0] + M[2][1]*t[1] + M[2][2]*t[2] - b[2];
        // grad = Mᵀ · r
        float g[3];
        g[0] = M[0][0]*r[0] + M[1][0]*r[1] + M[2][0]*r[2];
        g[1] = M[0][1]*r[0] + M[1][1]*r[1] + M[2][1]*r[2];
        g[2] = M[0][2]*r[0] + M[1][2]*r[1] + M[2][2]*r[2];
        for (int j = 0; j < 3; ++j) {
            float v = t[j] - kStep * g[j];
            t[j] = v > 0.0f ? v : 0.0f;
        }
    }
    if (residual_out != nullptr) {
        float r[3];
        r[0] = M[0][0]*t[0] + M[0][1]*t[1] + M[0][2]*t[2] - b[0];
        r[1] = M[1][0]*t[0] + M[1][1]*t[1] + M[1][2]*t[2] - b[1];
        r[2] = M[2][0]*t[0] + M[2][1]*t[1] + M[2][2]*t[2] - b[2];
        *residual_out = fl::sqrt(r[0]*r[0] + r[1]*r[1] + r[2]*r[2]);
    }
    t_out[0] = t[0]; t_out[1] = t[1]; t_out[2] = t[2];
}
 
// ===== LUT quantization and interpolation constants =========================
// Used by both the RGBW LUT (today) and any future RGB / RGBCCT LUT paths
// extracted out of the topology-specific solver modules.
 
// LUT cell quantization scale (value in [-8, +8) maps to i16 via *kLutQ).
constexpr i16 kLutQ = 4096;
 
// Storage stride per grid point. Bilinear LUTs store 4 (rgbw) values; Hermite
// LUTs additionally store ∂/∂t_x and ∂/∂t_y per channel (in cell-parameter
// units), enabling bicubic Hermite interpolation that reaches comparable
// accuracy at ~half the grid edge length — ~25 % of the memory at ~ the
// same error vs. bilinear. The grid step is uniform so derivatives are
// naturally expressed in cell-parameter units (t ∈ [0, 1] per cell).
constexpr int kLutStrideBilinear = 4;
constexpr int kLutStrideHermite = 12;
 
enum class LutInterp : u8 {
    Bilinear = 0,
    Hermite = 1,
};
 
// Cubic Hermite basis on [0, 1]. Output layout: { h00, h01, h10, h11 } where
//   h00(t) = 2t³ - 3t² + 1   value at t=0
//   h01(t) = -2t³ + 3t²      value at t=1
//   h10(t) = t³ - 2t² + t    derivative at t=0
//   h11(t) = t³ - t²         derivative at t=1
// Lifted into a header inline so `lookup_lut` and the test suite consume
// exactly the same evaluator (CodeRabbit #2707: tests that redefine basis
// locally cannot catch regressions in the production code).
inline void hermite_basis(float t, float out[4]) FL_NO_EXCEPT {
    const float t2 = t * t;
    const float t3 = t2 * t;
    out[0] = 2.0f * t3 - 3.0f * t2 + 1.0f;
    out[1] = -2.0f * t3 + 3.0f * t2;
    out[2] = t3 - 2.0f * t2 + t;
    out[3] = t3 - t2;
}
 
inline i16 quantize_lut_cell(float v) FL_NO_EXCEPT {
    const float scaled = v * static_cast<float>(kLutQ) + 0.5f;
    if (scaled <= -32768.0f) return -32768;
    if (scaled >= 32767.0f) return 32767;
    return static_cast<i16>(scaled);
}
 
// ===== Physical emitter profile =============================================
enum class EmitterTopology : u8 { RGB = 0, RGBW = 1, RGBWW = 2 };
 
// The RGB fields retain their original layout; wide topology data is appended
// so existing RGB profiles and factory calls remain source-compatible.
struct EmitterProfile {
    float xy_r[2];      // R diode chromaticity (CIE 1931 xy)
    float xy_g[2];      // G diode chromaticity
    float xy_b[2];      // B diode chromaticity
    float lum_r;        // R diode peak luminance (relative to source white = 1.0)
    float lum_g;
    float lum_b;
 
    // Source / input color space (#2705 semantics). When `input_xy_w[1]` is
    // 0 (the default for value-initialized profiles), solvers fall back to
    // the legacy interpretation in which the input RGB triple IS the
    // device-emitter drive coordinates — preserved for backward compat.
    float input_xy_r[2];  // source R primary chromaticity (default: native LED R)
    float input_xy_g[2];  // source G primary chromaticity (default: native LED G)
    float input_xy_b[2];  // source B primary chromaticity (default: native LED B)
    float input_xy_w[2];  // source white chromaticity (default D65)
 
    const char* id;
    const u16* response_lut_r;
    const u16* response_lut_g;
    const u16* response_lut_b;
    u16 response_lut_size;
    u8 native_code_depth;
    FiveBitSemantics five_bit_semantics;
    const char* provenance_kind;
    const char* report_id;
    float reference_temperature_c;
    float electrical_milliwatts_r;
    float electrical_milliwatts_g;
    float electrical_milliwatts_b;
    float electrical_idle_milliwatts;
 
    // Appended so existing RGB aggregate initializers retain their meaning.
    // In RGBW white1 is the sole white; in RGBWW it is warm white and white2
    // is cool white. Unused white slots stay zero/null.
    EmitterTopology topology;
    float xy_white1[2];
    float xy_white2[2];
    float lum_white1;
    float lum_white2;
    const u16* response_lut_white1;
    const u16* response_lut_white2;
    float electrical_milliwatts_white1;
    float electrical_milliwatts_white2;
 
    static constexpr EmitterProfile rgb(const char* profile_id, Chromaticity red,
                                        Chromaticity green, Chromaticity blue,
                                        float red_y, float green_y, float blue_y,
                                        const char* provenance = nullptr,
                                        const char* report = nullptr) FL_NO_EXCEPT {
        return EmitterProfile{{red.x, red.y}, {green.x, green.y}, {blue.x, blue.y}, red_y, green_y, blue_y,
                              {0, 0}, {0, 0}, {0, 0}, {0, 0}, profile_id, nullptr, nullptr, nullptr, 0, 8,
                              FiveBitSemantics::NotApplicable, provenance, report, 0, 0, 0, 0, 0,
                              EmitterTopology::RGB, {0, 0}, {0, 0}, 0, 0,
                              nullptr, nullptr, 0, 0};
    }
 
    static constexpr EmitterProfile rgbw(const char* profile_id, Chromaticity red,
                                         Chromaticity green, Chromaticity blue,
                                         Chromaticity white, float red_y,
                                         float green_y, float blue_y,
                                         float white_y,
                                         const char* provenance = nullptr,
                                         const char* report = nullptr) FL_NO_EXCEPT {
        return EmitterProfile{{red.x, red.y}, {green.x, green.y}, {blue.x, blue.y},
                              red_y, green_y, blue_y,
                              {0, 0}, {0, 0}, {0, 0}, {0, 0}, profile_id,
                              nullptr, nullptr, nullptr, 0, 8,
                              FiveBitSemantics::NotApplicable, provenance, report,
                              0, 0, 0, 0, 0,
                              EmitterTopology::RGBW, {white.x, white.y}, {0, 0},
                              white_y, 0, nullptr, nullptr, 0, 0};
    }
 
    static constexpr EmitterProfile rgbww(const char* profile_id, Chromaticity red,
                                          Chromaticity green, Chromaticity blue,
                                          Chromaticity warm_white,
                                          Chromaticity cool_white, float red_y,
                                          float green_y, float blue_y,
                                          float warm_white_y, float cool_white_y,
                                          const char* provenance = nullptr,
                                          const char* report = nullptr) FL_NO_EXCEPT {
        return EmitterProfile{{red.x, red.y}, {green.x, green.y}, {blue.x, blue.y},
                              red_y, green_y, blue_y,
                              {0, 0}, {0, 0}, {0, 0}, {0, 0}, profile_id,
                              nullptr, nullptr, nullptr, 0, 8,
                              FiveBitSemantics::NotApplicable, provenance, report,
                              0, 0, 0, 0, 0,
                              EmitterTopology::RGBWW,
                              {warm_white.x, warm_white.y},
                              {cool_white.x, cool_white.y},
                              warm_white_y, cool_white_y,
                              nullptr, nullptr, 0, 0};
    }
};
 
// Backward-compat alias for the original PR vocabulary (issue #3231 → PR 2
// of #3255). New code should prefer the topology-independent
// `EmitterProfile` name; existing call sites that spell out
// `RgbColorimetricProfile` keep compiling.
using RgbColorimetricProfile = EmitterProfile;
 
namespace profiles {
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 6
extern const EmitterProfile WS2812B;
#else
static constexpr EmitterProfile WS2812B = EmitterProfile::rgb(
    "ws2812b/placeholder/uncalibrated", Chromaticity(.640f, .330f),
    Chromaticity(.300f, .600f), Chromaticity(.150f, .060f), 1.0f, 1.0f, 1.0f,
    "placeholder", "uncalibrated");
#endif
}  // namespace profiles
 
// Cache derived from `EmitterProfile`: precomputed XYZ primaries, inverse
// primary matrix, and source-space matrix when an input gamut is supplied.
// Built once per profile and reused across pixels.
struct RgbColorimetricCache {
    float P_R[3], P_G[3], P_B[3];
    float P_RGB_inv[3][3];
    float M_src[3][3];
    bool has_source_space;
};
 
// Build the precomputed primaries / inverse matrices for `p`. Returns false
// when the device-emitter primary matrix is singular (collinear
// chromaticities), or when a declared source space cannot be built; the
// cache is still populated with zeros so callers can safely fall back to the
// no-op solve.
//
// Source-space handling matches the RGBW path (#2705 semantics): when
// `input_xy_w[1]` is effectively zero, the input RGB triple IS treated as
// drive coordinates. Otherwise a source-primary matrix is built and
// normalized so that the source white at unit drive lands on the maximum
// per-channel column — keeping outputs in [0, 1] for in-gamut inputs.
//
// "No source space declared" and "a source space was declared and is
// unusable" are different answers and must not collapse into one. Folding
// the second into the first leaves `has_source_space` false, which means the
// caller's RGB is reinterpreted as device drive coordinates -- a different
// colour, produced silently, from primaries the caller believed were in
// effect. FastLED#4156 R6 asks for that specifically: a near-singular
// transform needs deterministic rejection, not an arbitrary fallback that
// destroys the accuracy promise.
inline bool build_rgb_colorimetric_cache(const EmitterProfile& p,
                                         RgbColorimetricCache* cache) FL_NO_EXCEPT {
    xyY_to_XYZ(p.xy_r[0], p.xy_r[1], p.lum_r, cache->P_R);
    xyY_to_XYZ(p.xy_g[0], p.xy_g[1], p.lum_g, cache->P_G);
    xyY_to_XYZ(p.xy_b[0], p.xy_b[1], p.lum_b, cache->P_B);
 
    const float P_RGB[3][3] = {
        { cache->P_R[0], cache->P_G[0], cache->P_B[0] },
        { cache->P_R[1], cache->P_G[1], cache->P_B[1] },
        { cache->P_R[2], cache->P_G[2], cache->P_B[2] },
    };
    const bool ok_rgb = invert3x3(P_RGB, cache->P_RGB_inv);
    const bool declares_source_space = (p.input_xy_w[1] > 1e-6f);
    cache->has_source_space = declares_source_space
                           && build_source_matrix(p.input_xy_r, p.input_xy_g,
                                                  p.input_xy_b, p.input_xy_w,
                                                  cache->M_src);
    if (cache->has_source_space && ok_rgb) {
        float X_w[3];
        xyY_to_XYZ(p.input_xy_w[0], p.input_xy_w[1], 1.0f, X_w);
        float t[3];
        matvec3(cache->P_RGB_inv, X_w, t);
        const float mt = fl::max(fl::max(fl::fabs(t[0]), fl::fabs(t[1])),
                                 fl::fabs(t[2]));
        if (mt > 1e-6f) {
            const float scale_k = 1.0f / mt;
            for (int i = 0; i < 3; ++i) {
                for (int j = 0; j < 3; ++j) {
                    cache->M_src[i][j] *= scale_k;
                }
            }
        }
    }
    if (!ok_rgb) {
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 3; ++j) {
                cache->P_RGB_inv[i][j] = 0.0f;
            }
        }
    }
    if (!cache->has_source_space) {
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 3; ++j) {
                cache->M_src[i][j] = 0.0f;
            }
        }
    }
    if (declares_source_space && !cache->has_source_space) {
        return false;
    }
    return ok_rgb;
}
 
// Map a source-space RGB triple to absolute XYZ. With a configured source
// gamut, this is the M_src multiplication; without one, the device-emitter
// primary columns are used directly (the input is treated as drive
// coordinates).
inline void rgb_source_to_XYZ(const RgbColorimetricCache& cache, float s_r,
                              float s_g, float s_b,
                              float X_t[3]) FL_NO_EXCEPT {
    if (cache.has_source_space) {
        const float s[3] = { s_r, s_g, s_b };
        matvec3(cache.M_src, s, X_t);
    } else {
        X_t[0] = cache.P_R[0] * s_r + cache.P_G[0] * s_g + cache.P_B[0] * s_b;
        X_t[1] = cache.P_R[1] * s_r + cache.P_G[1] * s_g + cache.P_B[1] * s_b;
        X_t[2] = cache.P_R[2] * s_r + cache.P_G[2] * s_g + cache.P_B[2] * s_b;
    }
}
 
// Solve a source-space RGB target for the device RGB drives. The result is
// clamped to non-negative and normalized so the per-channel max ≤ 1.
inline bool solve_rgb_colorimetric(const RgbColorimetricCache& cache,
                                   float s_r, float s_g, float s_b,
                                   float out_rgb[3]) FL_NO_EXCEPT {
    float X_t[3];
    rgb_source_to_XYZ(cache, s_r, s_g, s_b, X_t);
    matvec3(cache.P_RGB_inv, X_t, out_rgb);
    out_rgb[0] = fl::max(out_rgb[0], 0.0f);
    out_rgb[1] = fl::max(out_rgb[1], 0.0f);
    out_rgb[2] = fl::max(out_rgb[2], 0.0f);
    const float m = fl::max(fl::max(out_rgb[0], out_rgb[1]), out_rgb[2]);
    if (m > 1.0f) {
        const float inv_m = 1.0f / m;
        out_rgb[0] *= inv_m;
        out_rgb[1] *= inv_m;
        out_rgb[2] *= inv_m;
    }
    return true;
}
 
} // namespace colorimetric_response
 
namespace profiles {
using colorimetric_response::profiles::WS2812B;  // ok bare using: public P2 profile API
}  // namespace profiles
} // namespace fl