Function lookup_lut

src/fl/gfx/rgbw_colorimetric.cpp.hpp:947–1040

}

void lookup_lut(const LutTable& lut, const float xy_t[2], float Y_t,
                float out_rgbw[4]) FL_NOEXCEPT {
    // Defend against degenerate LUTs (empty table, unbuilt cells, zero span).
    // build_lut() returns an empty LutTable on bad input — without these
    // guards the divide-by-zero and OOB reads would corrupt random memory.
    out_rgbw[0] = out_rgbw[1] = out_rgbw[2] = out_rgbw[3] = 0.0f;
    if (lut.N < 2 || lut.cells.get() == nullptr) {
        return;
    }
    const int N = lut.N;
    const float dx = lut.xy_max[0] - lut.xy_min[0];
    const float dy = lut.xy_max[1] - lut.xy_min[1];
    if (dx <= 0.0f || dy <= 0.0f) {
        return;
    }
    float x_norm = (xy_t[0] - lut.xy_min[0]) / dx * (N - 1);
    float y_norm = (xy_t[1] - lut.xy_min[1]) / dy * (N - 1);
    x_norm = fl::clamp(x_norm, 0.0f, static_cast<float>(N - 1) - 1e-4f);
    y_norm = fl::clamp(y_norm, 0.0f, static_cast<float>(N - 1) - 1e-4f);
    const int i = static_cast<int>(x_norm);
    const int j = static_cast<int>(y_norm);
    const float fx = x_norm - i;
    const float fy = y_norm - j;

    const i16* base = lut.cells.get();
    const int stride =
        (lut.interp == LutInterp::Hermite) ? kLutStrideHermite : kLutStrideBilinear;
    const i16* c00 = &base[(j * N + i) * stride];
    const i16* c10 = &base[(j * N + i + 1) * stride];
    const i16* c01 = &base[((j + 1) * N + i) * stride];
    const i16* c11 = &base[((j + 1) * N + i + 1) * stride];

    const float inv_Q = 1.0f / static_cast<float>(kLutQ);

    if (lut.interp == LutInterp::Hermite) {
        // Bicubic Hermite with no fxy cross term. Basis is computed via the
        // shared header helper `hermite_basis` so the test suite exercises the
        // same evaluator (CodeRabbit #2707).
        float bx[4], by[4];
        hermite_basis(fx, bx);
        hermite_basis(fy, by);
        const float h00x = bx[0], h01x = bx[1], h10x = bx[2], h11x = bx[3];
        const float h00y = by[0], h01y = by[1], h10y = by[2], h11y = by[3];

        for (int k = 0; k < 4; ++k) {
            const float v00 = c00[k] * inv_Q;
            const float v10 = c10[k] * inv_Q;
            const float v01 = c01[k] * inv_Q;
            const float v11 = c11[k] * inv_Q;
            const float dx00 = c00[4 + k] * inv_Q;
            const float dx10 = c10[4 + k] * inv_Q;
            const float dx01 = c01[4 + k] * inv_Q;
            const float dx11 = c11[4 + k] * inv_Q;
            const float dy00 = c00[8 + k] * inv_Q;
            const float dy10 = c10[8 + k] * inv_Q;
            const float dy01 = c01[8 + k] * inv_Q;
            const float dy11 = c11[8 + k] * inv_Q;