FlushPredict Namespace Reference

Classes
struct	RGBColor
struct	LABColor

Functions
static double	rad_to_deg (double rad)
static double	deg_to_rad (double deg)
LABColor	RGB2LAB (const RGBColor &color)
float	calc_color_distance (const LABColor &lab1, const LABColor &lab2)
float	calc_color_distance (const RGBColor &color1, const RGBColor &color2)
bool	is_similar_color (const RGBColor &from, const RGBColor &to, float distance_threshold)

Function Documentation

calc_color_distance() [1/2]

float FlushPredict::calc_color_distance	(	const LABColor &	lab1,
		const LABColor &	lab2 )

    {
        static const double pow_25_to_7 = pow(25, 7);
 
        const double C1 = sqrt(lab1.a * lab1.a + lab1.b * lab1.b);
        const double C2 = sqrt(lab2.a * lab2.a + lab2.b * lab2.b);
        const double CMean = (C1 + C2) / 2.0;
        const double pow_CMean_to_7 = pow(CMean, 7);
        const double G = 0.5 * (1 - sqrt(pow_CMean_to_7 / (pow_CMean_to_7 + pow_25_to_7)));
 
        const double p_l1 = lab1.l;
        const double p_l2 = lab2.l;
        const double p_a1 = (1. + G) * lab1.a;
        const double p_a2 = (1. + G) * lab2.a;
        const double p_b1 = lab1.b;
        const double p_b2 = lab2.b;
        const double p_c1 = sqrt(p_a1 * p_a1 + p_b1 * p_b1);
        const double p_c2 = sqrt(p_a2 * p_a2 + p_b2 * p_b2);
        double p_h1;
        if (p_a1 == 0 && p_b1 == 0)
            p_h1 = 0;
        else {
            p_h1 = atan2(p_b1, p_a1);
            if (p_h1 < 0)
                p_h1 += M_PI * 2;
        }
        double p_h2;
        if (p_a2 == 0 && p_b2 == 0)
            p_h2 = 0;
        else {
            p_h2 = atan2(p_b2, p_a2);
            if (p_h2 < 0)
                p_h2 += M_PI * 2;
        }
 
        const double delta_L = p_l2 - p_l1;
        const double delta_C = p_c2 - p_c1;
 
        double delta_H;
        const double p_c_multi = p_c1 * p_c2;
        if (p_c_multi == 0)
            delta_H = 0;
        else {
            delta_H = p_h2 - p_h1;
            if (delta_H < -M_PI)
                delta_H += 2 * M_PI;
            else if (delta_H > M_PI)
                delta_H -= 2 * M_PI;
            delta_H = 2 * sqrt(p_c_multi) * sin(delta_H / 2.);
        }
 
 
        double p_L_mean = (p_l1 + p_l2) / 2.0;
        double p_C_mean = (p_c1 + p_c2) / 2.0;
 
        double p_H_mean, p_H_sum = p_h1 + p_h2;
        if (p_c1 * p_c2 == 0) {
            p_H_mean = p_H_sum;
        }
        else {
            if (fabs(p_h1 - p_h2) <= M_PI)
                p_H_mean = p_H_sum / 2;
            else {
                if (p_H_sum < 2 * M_PI)
                    p_H_mean = (p_H_sum + 2 * M_PI) / 2.0;
                else
                    p_H_mean = (p_H_sum - 2 * M_PI) / 2.0;
            }
        }
 
        const double T = 1 - 0.17 * cos(p_H_mean - deg_to_rad(30)) + 0.24 * cos(2 * p_H_mean) + 0.32 * cos(3 * p_H_mean + deg_to_rad(6)) - 0.2 * cos(4 * p_H_mean - deg_to_rad(63));
        const double dtheta = deg_to_rad(30) * exp(-pow((p_H_mean - deg_to_rad(275)) / deg_to_rad(25), 2));
 
        const double pow_p_cmean_to_7 = pow(p_C_mean, 7);
        const double R_C = 2 * sqrt(pow_p_cmean_to_7 / (pow_p_cmean_to_7 + pow_25_to_7));
 
        const double pow_p_lmean_to_2 = pow(p_L_mean - 50, 2);
        const double S_L = 1 + (0.015 * pow_p_lmean_to_2) / sqrt(20 + pow_p_lmean_to_2);
        const double S_C = 1 + 0.045 * p_C_mean;
        const double S_H = 1 + 0.015 * p_C_mean * T;
        const double R_T = -sin(2 * dtheta) * R_C;
 
        const double K_L = 1.0, K_C = 1.0, K_H = 1.0;
 
        double de = sqrt(
            pow(delta_L / (K_L * S_L), 2) + pow(delta_C / (K_C * S_C), 2) + pow(delta_H / (K_H * S_H), 2) + (R_T * (delta_C / (K_C * S_C)) * (delta_H / (K_H * S_H)))
        );
        return de;
    }

References FlushPredict::LABColor::a, FlushPredict::LABColor::b, deg_to_rad(), FlushPredict::LABColor::l, and M_PI.

Referenced by calc_color_distance(), Slic3r::FilamentGroup::calc_filament_group_for_match(), is_similar_color(), and Slic3r::select_best_group_for_ams().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_color_distance() [2/2]

float FlushPredict::calc_color_distance	(	const RGBColor &	color1,
		const RGBColor &	color2 )

                                                                              {
        LABColor lab1 = RGB2LAB(color1);
        LABColor lab2 = RGB2LAB(color2);
        return calc_color_distance(lab1, lab2);
    }

References calc_color_distance(), and RGB2LAB().

Here is the call graph for this function:

deg_to_rad()

double FlushPredict::deg_to_rad ( double deg )

static

                                         {
        return deg * M_PI / 180.0;
    }

References M_PI.

Referenced by calc_color_distance().

Here is the caller graph for this function:

is_similar_color()

bool FlushPredict::is_similar_color	(	const RGBColor &	from,
		const RGBColor &	to,
		float	distance_threshold )

    {
        float color_distance = calc_color_distance(from, to);
        if (color_distance > distance_threshold)
            return false;
        return true;
    }

References calc_color_distance().

Referenced by FlushVolPredictor::predict().

Here is the call graph for this function:

Here is the caller graph for this function:

rad_to_deg()

double FlushPredict::rad_to_deg ( double rad )

static

                                         {
        return 180.0 / M_PI * rad;
    }

References M_PI.

RGB2LAB()

LABColor FlushPredict::RGB2LAB

(

const RGBColor &

color

)

                                            {
        using XYZColor = std::tuple<double, double, double>;
        auto gamma = [](double x) {
            if (x > 0.04045)
                return pow((x + 0.055) / 1.055, 2.4);
            else
                return x / 12.92;
            };
        auto RGB2XYZ = [gamma](const RGBColor& color)->XYZColor {
            double R = gamma(static_cast<double>(color.r) / 255.0) * 100;
            double G = gamma(static_cast<double>(color.g) / 255.0) * 100;
            double B = gamma(static_cast<double>(color.b) / 255.0) * 100;
 
            double x = 0.412453 * R + 0.357580 * G + 0.180423 * B;
            double y = 0.212671 * R + 0.715160 * G + 0.072169 * B;
            double z = 0.019334 * R + 0.119193 * G + 0.950227 * B;
            return { x,y,z };
            };
 
        static const double XN = 95.0489;
        static const double YN = 100;
        static const double ZN = 108.8840;
 
        auto f = [](double t) {
            static const double threshold = 0.008856f;
            if (t > threshold)
                return pow(t, 1.0 / 3.0);
            else
                return 7.787 * t + 0.137931;
            };
 
        auto xyz_color = RGB2XYZ(color);
        double x = std::get<0>(xyz_color);
        double y = std::get<1>(xyz_color);
        double z = std::get<2>(xyz_color);
        double xn = f(x / XN);
        double yn = f(y / YN);
        double zn = f(z / ZN);
 
        double L = 116.0 * yn - 16.0;
        double A = 500.0 * (xn - yn);
        double B = 200.0 * (yn - zn);
        return LABColor(L, A, B);
    }

References FlushPredict::RGBColor::b, FlushPredict::RGBColor::g, L, FlushPredict::RGBColor::r, and RGB2XYZ().

Referenced by calc_color_distance().

Here is the call graph for this function:

Here is the caller graph for this function: