Function build_lut

src/fl/gfx/rgbw_colorimetric.cpp.hpp:861–945

}

LutTable build_lut(const ProfileCache& cache, int grid_n,
                   LutInterp interp) FL_NOEXCEPT {
    LutTable lut;
    // Guard against degenerate grids: N < 2 would divide-by-zero in the
    // 1/(N-1) step below, and negative N would overflow the allocation size.
    // Return an empty LutTable so callers can detect failure via .N == 0.
    if (grid_n < 2) {
        return lut;
    }
    const fl::size_t n = static_cast<fl::size_t>(grid_n);
    lut.N = grid_n;
    lut.interp = interp;
    const fl::size_t stride =
        (interp == LutInterp::Hermite) ? kLutStrideHermite : kLutStrideBilinear;
    lut.cells = fl::make_unique<i16[]>(n * n * stride);

    const float* R = cache.profile->xy_r;
    const float* G = cache.profile->xy_g;
    const float* B = cache.profile->xy_b;
    const float xmin = fl::min(fl::min(R[0], G[0]), B[0]);
    const float xmax = fl::max(fl::max(R[0], G[0]), B[0]);
    const float ymin = fl::min(fl::min(R[1], G[1]), B[1]);
    const float ymax = fl::max(fl::max(R[1], G[1]), B[1]);
    const float xpad = (xmax - xmin) * 0.02f;
    const float ypad = (ymax - ymin) * 0.02f;
    lut.xy_min[0] = xmin - xpad;
    lut.xy_min[1] = ymin - ypad;
    lut.xy_max[0] = xmax + xpad;
    lut.xy_max[1] = ymax + ypad;

    i16* cells = lut.cells.get();
    const int N = grid_n;
    const float inv_Nm1 = 1.0f / static_cast<float>(N - 1);
    const float cell_dx = (lut.xy_max[0] - lut.xy_min[0]) * inv_Nm1;
    const float cell_dy = (lut.xy_max[1] - lut.xy_min[1]) * inv_Nm1;

    auto sample = [&](float x, float y, float out[4]) FL_NOEXCEPT {
        const float xy[2] = {x, y};
        solve_strict_subgamut_xy(cache, xy, 1.0f, out);
    };

    for (int j = 0; j < N; ++j) {
        const float y = lut.xy_min[1] + cell_dy * j;
        for (int i = 0; i < N; ++i) {
            const float x = lut.xy_min[0] + cell_dx * i;
            float v[4];
            sample(x, y, v);
            i16* cell = &cells[(j * N + i) * stride];
            cell[0] = quantize_lut_cell(v[0]);
            cell[1] = quantize_lut_cell(v[1]);
            cell[2] = quantize_lut_cell(v[2]);
            cell[3] = quantize_lut_cell(v[3]);

            if (interp != LutInterp::Hermite) continue;

            // Numerical partials in cell-parameter (t) units. Sample
            // half-a-cell ahead / behind in world coords, clamped to the LUT
            // domain so edges fall back to one-sided differences. With