buildGamutMapRgbwwFromSolveQ16()

bool fl::buildGamutMapRgbwwFromSolveQ16	(	const colorimetric_response::EmitterProfile &	profile,
		const EmitterSolveMatrixQ16 &	solve,
		const i32(&)	white1_xyz[3],
		const i32(&)	white2_xyz[3],
		WhiteAllocationPolicy	policy,
		GamutMapRgbwwQ16 *	out )

Bind a five-emitter map from one effective RGB solve and two white columns, all in the same D65 working coordinates.

Definition at line 625 of file gamut_map.cpp.hpp.

                                        {
    if (out == nullptr) {
        return false;
    }
    if (!buildTwoWhiteAllocationFromSolveQ16(solve, white1_xyz, white2_xyz,
                                             policy, &out->allocation)) {
        return false;
    }
 
    i32 neutral_drives[3];
    solveRgbDrivesQ16(out->allocation.rgb_solve, kGamutD65Q16, neutral_drives);
    for (int i = 0; i < 3; ++i) {
        // As in the other two builds: every drive, not just the largest.
        if (neutral_drives[i] <= 0) {
            return false;
        }
    }
 
    // The three-emitter bound, reached with both whites off, and always
    // attainable.
    i32 largest_neutral_drive = neutral_drives[0];
    for (int i = 1; i < 3; ++i) {
        if (neutral_drives[i] > largest_neutral_drive) {
            largest_neutral_drive = neutral_drives[i];
        }
    }
    i64 reachable = (static_cast<i64>(kGamutFullDrive) << 16) /
                    static_cast<i64>(largest_neutral_drive);
 
    // Clamped for the same reason the three-emitter build clamps it, and to
    // the same place: `buildRgbSolveMatrixQ16` accepts emitter luminances up
    // to 1e6, so a profile bright enough to reach D65 on one or two raw
    // units of drive puts `2^32 / largest` at or past i32's range -- exactly
    // 2^31 at largest == 2. `optimistic` starts at `kOklabQ16MaxMagnitude`,
    // so for such a profile the bisection below is skipped and the narrowing
    // is reached directly. 64.0 is where the OKLab transform's domain ends,
    // so nothing downstream can tell the difference.
    if (reachable > kOklabQ16MaxMagnitude) {
        reachable = kOklabQ16MaxMagnitude;
    }
 
    // The one-white relaxation with a second white added. Along the D65 ray
    // the RGB drives are `s*d0 - w1*dW1 - w2*dW2`, so the upper limit on
    // drive i is loosest with each white at full when its column is positive
    // and off when it is not -- hence a `max(.., 0)` term per white.
    // Dropping the lower limits, and letting each channel choose its own
    // whites, are both relaxations, so this is an upper bound.
    //
    // `per_white1` is not stored: the allocation keeps the second column and
    // the difference, because that is all the per-pixel path needs. It is
    // recovered here rather than widening the struct for a bind-time sum.
    i64 optimistic = static_cast<i64>(kOklabQ16MaxMagnitude);
    for (int i = 0; i < 3; ++i) {
        const i32 per_white2 = out->allocation.per_white2[i];
        const i32 per_white1 = out->allocation.difference[i] + per_white2;
        i64 numerator = static_cast<i64>(kGamutFullDrive);
        if (per_white1 > 0) {
            numerator += static_cast<i64>(per_white1);
        }
        if (per_white2 > 0) {
            numerator += static_cast<i64>(per_white2);
        }
        const i64 candidate =
            (numerator << 16) / static_cast<i64>(neutral_drives[i]);
        if (candidate < optimistic) {
            optimistic = candidate;
        }
    }
 
    // Bisected against the attainable bound rather than trusted, for exactly
    // the reason spelled out on the one-white path: the relaxation enforces
    // only the upper limits, and full white can push a different channel
    // negative. Once per profile, never per pixel (A3/B11).
    if (optimistic > reachable) {
        i64 low = reachable;
        i64 high = optimistic;
        for (int step = 0; step < 24; ++step) {
            const i64 middle = (low + high) / 2;
            const i32 trial_scale = static_cast<i32>(middle);
            const i32 trial[3] = {
                scaleGamutQ16(kGamutD65Q16[0], trial_scale),
                scaleGamutQ16(kGamutD65Q16[1], trial_scale),
                scaleGamutQ16(kGamutD65Q16[2], trial_scale),
            };
            i32 trial_drives[5];
            if (allocateTwoWhiteDrivesQ16(out->allocation, trial, trial_drives)) {
                low = middle;
            } else {
                high = middle;
            }
        }
        reachable = low;
    }
 
    const i32 scale = static_cast<i32>(reachable);
    const i32 brightest_neutral[3] = {
        scaleGamutQ16(kGamutD65Q16[0], scale),
        scaleGamutQ16(kGamutD65Q16[1], scale),
        scaleGamutQ16(kGamutD65Q16[2], scale),
    };
    i32 lab[3];
    xyzToOklabQ16(brightest_neutral, lab);
    out->max_neutral_lightness = lab[0];
    return true;
}

References allocateTwoWhiteDrivesQ16(), buildTwoWhiteAllocationFromSolveQ16(), FL_NO_EXCEPT, kOklabQ16MaxMagnitude, scale, solveRgbDrivesQ16(), step(), and xyzToOklabQ16().

Referenced by buildGamutMapRgbwwQ16(), and fl::anonymous_namespace{pipeline.cpp.hpp}::buildWidePipelineQ16().

Here is the call graph for this function:

Here is the caller graph for this function: