feasibleChromaInterval()

template<typename Feasible>

bool fl::anonymous_namespace{gamut_map.cpp.hpp}::feasibleChromaInterval	(	const i32(&)	lab[3],
		i32	lightness,
		Feasible	feasible,
		i32 *	out_low,
		i32 *	out_high )

The feasible chroma interval at the target's own lightness, as factors of the target's chroma.

Above the brightest neutral the interval is still one run – that much is measured, on this device and on the wide ones – but it no longer contains zero (#4245). largestFeasibleChroma cannot find it: its bracket assumes a feasible low end, and starting infeasible it walks down to zero, which is the clamp this exists to avoid.

So the seed comes first, by a linear scan, and only then are the two edges bisected. Returns false when no probe lands inside, which is the caller's signal to keep the shipped clamp-then-bisect path – the reason this is never worse than what it replaces.

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

                                                        {
    i32 seed = 0;
    bool found = false;
    for (int probe = 1; probe <= kGamutMapProbes; ++probe) {
        const i32 factor = static_cast<i32>(
            (static_cast<i64>(kGamutProbeCeilingQ16) * probe) / kGamutMapProbes);
        i32 candidate_xyz[3];
        chromaCandidateXyz(lab, lightness, factor, candidate_xyz);
        if (feasible(candidate_xyz)) {
            seed = factor;
            found = true;
            break;
        }
    }
    if (!found) {
        return false;
    }
 
    // Lower edge: the smallest feasible factor. `high` is feasible throughout,
    // `low` is not, which is the mirror of the usual invariant.
    i32 low = 0;
    i32 high = seed;
    for (int step = 0; step < kGamutMapHalvings; ++step) {
        const i32 factor = low + ((high - low) >> 1);
        i32 candidate_xyz[3];
        chromaCandidateXyz(lab, lightness, factor, candidate_xyz);
        if (feasible(candidate_xyz)) {
            high = factor;
        } else {
            low = factor;
        }
    }
    *out_low = high;
 
    // Upper edge: the largest feasible factor, the usual invariant again.
    low = seed;
    high = kGamutProbeCeilingQ16;
    for (int step = 0; step < kGamutMapHalvings; ++step) {
        const i32 factor = low + ((high - low) >> 1);
        i32 candidate_xyz[3];
        chromaCandidateXyz(lab, lightness, factor, candidate_xyz);
        if (feasible(candidate_xyz)) {
            low = factor;
        } else {
            high = factor;
        }
    }
    *out_high = low;
    return true;
}

References chromaCandidateXyz(), feasibleChromaInterval(), fl::FL_NO_EXCEPT, fl::kGamutMapHalvings, kGamutMapProbes, kGamutProbeCeilingQ16, and fl::step().

Referenced by feasibleChromaInterval(), and highestReachableLightness().

Here is the call graph for this function:

Here is the caller graph for this function: