X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=white_balance_effect.cpp;h=07c95cac4ca473b52dda9f9d80ddbf9fda918a52;hp=f1852283431b2234c80e83c9d67b376256f2ef18;hb=8e9f58fec54a4c879035b214fd7411f6ff7b3a32;hpb=26304d874e2d61a0497f563a4daae882f671bf0d diff --git a/white_balance_effect.cpp b/white_balance_effect.cpp index f185228..07c95ca 100644 --- a/white_balance_effect.cpp +++ b/white_balance_effect.cpp @@ -1,14 +1,19 @@ -#include -#include - +#include #include +#include +#include -#include "white_balance_effect.h" -#include "util.h" -#include "opengl.h" +#include "colorspace_conversion_effect.h" #include "d65.h" +#include "effect_util.h" +#include "image_format.h" +#include "util.h" +#include "white_balance_effect.h" using namespace Eigen; +using namespace std; + +namespace movit { namespace { @@ -22,7 +27,7 @@ Vector3d convert_color_temperature_to_xyz(float T) assert(T <= 15000.0f); if (T <= 4000.0f) { - x = ((-0.2661239e9 * invT - 0.2343580e6) * invT + 0.8776956e3) * invT + 0.179910; + x = ((-0.2661239e9 * invT - 0.2343589e6) * invT + 0.8776956e3) * invT + 0.179910; } else { x = ((-3.0258469e9 * invT + 2.1070379e6) * invT + 0.2226347e3) * invT + 0.240390; } @@ -38,13 +43,6 @@ Vector3d convert_color_temperature_to_xyz(float T) return Vector3d(x, y, 1.0 - x - y); } -// Assuming sRGB primaries, from Wikipedia. -double rgb_to_xyz_matrix[9] = { - 0.4124, 0.2126, 0.0193, - 0.3576, 0.7152, 0.1192, - 0.1805, 0.0722, 0.9505, -}; - /* * There are several different perceptual color spaces with different intended * uses; for instance, CIECAM02 uses one space (CAT02) for purposes of computing @@ -53,9 +51,9 @@ double rgb_to_xyz_matrix[9] = { * (Hunt-Pointer-Estevez, or HPE) for the actual perception post-adaptation. * * CIECAM02 chromatic adaptation, while related to the transformation we want, - * is a more complex phenomenon that depends on factors like the total luminance - * (in cd/m²) of the illuminant, and can no longer be implemented by just scaling - * each component in LMS space linearly. The simpler way out is to use the HPE matrix, + * is a more complex phenomenon that depends on factors like the viewing conditions + * (e.g. amount of surrounding light), and can no longer be implemented by just scaling + * each component in LMS space. The simpler way out is to use the HPE matrix, * which is intended to be close to the actual cone response; this results in * the “von Kries transformation” when we couple it with normalization in LMS space. * @@ -67,41 +65,34 @@ double rgb_to_xyz_matrix[9] = { * The actual perceptual differences were found to be minor, though. * We use the Bradford tranformation matrix from that page, and compute the * inverse ourselves. (The Bradford matrix is also used in CMCCAT97.) - * - * We normalize the Bradford fundamentals to D65, which means that the standard - * D65 illuminant (x=0.31271, y=0.32902, z=1-y-x) gives L=M=S under this - * transformation. This makes sense because sRGB (which is used to derive - * those XYZ values in the first place) assumes the D65 illuminant, and so the - * D65 illuminant also gives R=G=B in sRGB. (We could also have done this - * step separately in XYZ space, but we'd have to do it to all colors we - * wanted scaled to LMS.) */ const double xyz_to_lms_matrix[9] = { - 0.8951 / d65_X, -0.7502 / d65_X, 0.0389 / d65_X, - 0.2664, 1.7135, -0.0685, - -0.1614 / d65_Z, 0.0367 / d65_Z, 1.0296 / d65_Z, + 0.7328, -0.7036, 0.0030, + 0.4296, 1.6975, 0.0136, + -0.1624, 0.0061, 0.9834, }; /* - * For a given reference color (given in XYZ space), - * compute scaling factors for L, M and S. What we want at the output is equal L, M and S - * for the reference color (making it a neutral illuminant), or sL ref_L = sM ref_M = sS ref_S. - * This removes two degrees of freedom for our system, and we only need to find fL. + * For a given reference color (given in XYZ space), compute scaling factors + * for L, M and S. What we want at the output is turning the reference color + * into a scaled version of the D65 illuminant (giving it R=G=B in sRGB), or + * + * (sL ref_L, sM ref_M, sS ref_S) = (s d65_L, s d65_M, s d65_S) * + * This removes two degrees of freedom from our system, and we only need to find s. * A reasonable last constraint would be to preserve Y, approximately the brightness, - * for the reference color. Since L'=M'=S' and the Y row of the LMS-to-XYZ matrix - * sums to unity, we know that Y'=L', and it's easy to find the fL that sets Y'=Y. + * for the reference color. Thus, we choose our D65 illuminant's Y such that it is + * equal to the reference color's Y, and the rest is easy. */ -Vector3d compute_lms_scaling_factors(const Vector3d &xyz) +Vector3d compute_lms_scaling_factors(const Vector3d &ref_xyz) { - Vector3d lms = Map(xyz_to_lms_matrix) * xyz; - double l = lms[0]; - double m = lms[1]; - double s = lms[2]; + Vector3d ref_lms = Map(xyz_to_lms_matrix) * ref_xyz; + Vector3d d65_lms = Map(xyz_to_lms_matrix) * + (ref_xyz[1] * Vector3d(d65_X, d65_Y, d65_Z)); // d65_Y = 1.0. - double scale_l = xyz[1] / l; - double scale_m = scale_l * (l / m); - double scale_s = scale_l * (l / s); + double scale_l = d65_lms[0] / ref_lms[0]; + double scale_m = d65_lms[1] / ref_lms[1]; + double scale_s = d65_lms[2] / ref_lms[2]; return Vector3d(scale_l, scale_m, scale_s); } @@ -114,17 +105,19 @@ WhiteBalanceEffect::WhiteBalanceEffect() { register_vec3("neutral_color", (float *)&neutral_color); register_float("output_color_temperature", &output_color_temperature); + register_uniform_mat3("correction_matrix", &uniform_correction_matrix); } -std::string WhiteBalanceEffect::output_fragment_shader() +string WhiteBalanceEffect::output_fragment_shader() { return read_file("white_balance_effect.frag"); } -void WhiteBalanceEffect::set_gl_state(GLuint glsl_program_num, const std::string &prefix, unsigned *sampler_num) +void WhiteBalanceEffect::set_gl_state(GLuint glsl_program_num, const string &prefix, unsigned *sampler_num) { + Matrix3d rgb_to_xyz_matrix = ColorspaceConversionEffect::get_xyz_matrix(COLORSPACE_sRGB); Vector3d rgb(neutral_color.r, neutral_color.g, neutral_color.b); - Vector3d xyz = Map(rgb_to_xyz_matrix) * rgb; + Vector3d xyz = rgb_to_xyz_matrix * rgb; Vector3d lms_scale = compute_lms_scaling_factors(xyz); /* @@ -150,11 +143,12 @@ void WhiteBalanceEffect::set_gl_state(GLuint glsl_program_num, const std::string * Note that since we postmultiply our vectors, the order of the matrices * has to be the opposite of the execution order. */ - Matrix3d corr_matrix = - Map(rgb_to_xyz_matrix).inverse() * + uniform_correction_matrix = + rgb_to_xyz_matrix.inverse() * Map(xyz_to_lms_matrix).inverse() * lms_scale.asDiagonal() * Map(xyz_to_lms_matrix) * - Map(rgb_to_xyz_matrix); - set_uniform_mat3(glsl_program_num, prefix, "correction_matrix", corr_matrix); + rgb_to_xyz_matrix; } + +} // namespace movit