buildWhiteAllocationFromSolveQ16()

bool fl::buildWhiteAllocationFromSolveQ16	(	const colorimetric_response::EmitterProfile &	profile,
		const EmitterSolveMatrixQ16 &	solve,
		const i32(&)	white_xyz[3],
		WhiteAllocationPolicy	policy,
		WhiteAllocationQ16 *	out )

Bind from an RGB solve already adapted to the D65 working domain.

white_xyz must be adapted into that same domain. The profile supplies physical RGB column magnitudes for the per-channel rounding allowance.

Definition at line 89 of file white_allocation.cpp.hpp.

                                                                        {
    if (out == nullptr) {
        return false;
    }
    out->policy = policy;
    out->rgb_solve = solve;
    solveRgbDrivesQ16(out->rgb_solve, white_xyz, out->per_white);
 
    // Per-channel slack, so the allowance costs the same colour everywhere.
    // Bind time, once per profile -- there is no per-pixel work here.
    {
        const float* xy[3] = {profile.xy_r, profile.xy_g, profile.xy_b};
        const float luminance[3] = {profile.lum_r, profile.lum_g, profile.lum_b};
        for (int channel = 0; channel < 3; ++channel) {
            i32 xy_q16[2];
            i32 luminance_q16;
            if (!q16FromFloatBits(xy[channel][0], &xy_q16[0]) ||
                !q16FromFloatBits(xy[channel][1], &xy_q16[1]) ||
                !q16FromFloatBits(luminance[channel], &luminance_q16)) {
                return false;
            }
            i64 column[3];
            if (!detail::xyzColumnQ16(xy_q16, luminance_q16, column)) {
                return false;
            }
            // The peak component, because that is what bounds the per-axis
            // XYZ error a clamp of one drive unit can cause.
            i64 peak = 0;
            for (int axis = 0; axis < 3; ++axis) {
                const i64 magnitude = column[axis] < 0 ? -column[axis]
                                                         : column[axis];
                if (magnitude > peak) {
                    peak = magnitude;
                }
            }
            // Both operands are Q16, so the quotient is in raw drive units.
            // The numerator fits i64 even at the largest supported slack.
            i64 scaled = (static_cast<i64>(kWhiteSlackAtUnitColumn) * 65536 +
                          peak / 2) / peak;
            // Never zero: a column so large that the allowance rounds away
            // would reject the rounding this exists to tolerate.
            if (scaled < 1) {
                scaled = 1;
            }
            // And never larger than the allowance it is scaling. Dim
            // emitters have small columns, so the division wants to *grow*
            // the slack -- at a luminance of 1e-4 it reaches 640,000 raw
            // units, nearly ten in drive space, which accepts any drive at
            // all and clamps it. That is the defect this function exists to
            // remove, reinstated an order of magnitude worse.
            //
            // The tolerance is for rounding in the solve, which is a few raw
            // units whatever the emitter's brightness. So this only ever
            // narrows: 64 stays the ceiling and the column decides how far
            // below it each channel sits. For the corpus device nothing is
            // clipped -- green is already at 64 and the others below it --
            // so the measurements above are unaffected.
            if (scaled > kWhiteSlackAtUnitColumn) {
                scaled = kWhiteSlackAtUnitColumn;
            }
            out->slack[channel] = static_cast<i32>(scaled);
        }
    }
 
    // A white emitter the primaries cannot express at all leaves nothing for
    // the allocation to trade against, and every bound below would divide by
    // zero or be vacuous.
    bool expressible = false;
    for (int i = 0; i < 3; ++i) {
        if (out->per_white[i] != 0) {
            expressible = true;
        }
    }
    return expressible;
}

References FL_NO_EXCEPT, fl::colorimetric_response::EmitterProfile::lum_b, fl::colorimetric_response::EmitterProfile::lum_g, fl::colorimetric_response::EmitterProfile::lum_r, q16FromFloatBits(), solveRgbDrivesQ16(), xy(), fl::colorimetric_response::EmitterProfile::xy_b, fl::colorimetric_response::EmitterProfile::xy_g, fl::colorimetric_response::EmitterProfile::xy_r, and fl::detail::xyzColumnQ16().

Referenced by buildGamutMapRgbwFromSolveQ16(), and buildWhiteAllocationQ16().

Here is the call graph for this function:

Here is the caller graph for this function: