invert3x3()

bool fl::colorimetric_response::invert3x3 ( const float in[3][3], float out[3][3] )

inline

Definition at line 115 of file colorimetric_response.h.

                                                                          {
    const float a = in[0][0], b = in[0][1], c = in[0][2];
    const float d = in[1][0], e = in[1][1], f = in[1][2];
    const float g = in[2][0], h = in[2][1], i = in[2][2];
    const float det = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
 
    // Scale the test by the matrix's own magnitude, because an absolute
    // threshold cannot see the ratio that actually decides invertibility.
    //
    // Each column is divided by its largest entry and the determinant of
    // *that* matrix is what gets tested. The obvious alternative -- compare
    // |det| against the product of the column 2-norms -- needs `a * a`, which
    // overflows float32 for entries past about 1.8e19: `diag(1e20, 1e-20, 1)`
    // has determinant 1 and a perfectly representable inverse, and squaring
    // would send its first column norm to infinity and reject it. Dividing
    // first cannot overflow, and it costs three divisions instead of three
    // square roots.
    const float scale_a = detail::columnScale(a, d, g);
    const float scale_b = detail::columnScale(b, e, h);
    const float scale_c = detail::columnScale(c, f, i);
 
    // One negated `>`, which covers three cases at once and is why there is
    // no separate zero or NaN check: a zero column makes its scale zero, so
    // the division below yields infinity or NaN and the comparison fails; a
    // NaN anywhere makes every comparison false, so the negation rejects. An
    // explicit `scale > 0` clause was written here first, and mutation
    // testing showed it could not fire.
    const float an = a / scale_a, dn = d / scale_a, gn = g / scale_a;
    const float bn = b / scale_b, en = e / scale_b, hn = h / scale_b;
    const float cn = c / scale_c, fn = f / scale_c, in_ = i / scale_c;
    const float det_normalized = an * (en * in_ - fn * hn) -
                                 bn * (dn * in_ - fn * gn) +
                                 cn * (dn * hn - en * gn);
    if (!(fl::fabs(det_normalized) > detail::kRelativeSingularity)) {
        return false;
    }
 
    const float inv_det = 1.0f / det;
    out[0][0] = (e * i - f * h) * inv_det;
    out[0][1] = (c * h - b * i) * inv_det;
    out[0][2] = (b * f - c * e) * inv_det;
    out[1][0] = (f * g - d * i) * inv_det;
    out[1][1] = (a * i - c * g) * inv_det;
    out[1][2] = (c * d - a * f) * inv_det;
    out[2][0] = (d * h - e * g) * inv_det;
    out[2][1] = (b * g - a * h) * inv_det;
    out[2][2] = (a * e - b * d) * inv_det;
    return true;
}

References fl::colorimetric_response::detail::columnScale(), fl::fabs(), fl::FL_NO_EXCEPT, fl::g, and fl::colorimetric_response::detail::kRelativeSingularity.

Referenced by build_rgb_colorimetric_cache(), and build_source_matrix().

Here is the call graph for this function:

Here is the caller graph for this function: