Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp} Namespace Reference

Classes
struct	LabColor
struct	StandardRecipeEntry

Functions
static double	srgb_to_linear (double v)
static double	xyz_to_lab_component (double v)
static LabColor	rgb_to_lab (const ColorDecomposeRgb &rgb)
static std::string	lab_to_srgb_hex (const LabColor &lab)
static double	delta_e76 (const LabColor &a, const LabColor &b)
static bool	material_matches (const std::string &a, const std::string &b)
static std::vector< std::vector< int > >	ratio_grid (size_t n)
static ColorDecomposeRecipeMode	parse_mode (const std::string &s)
static std::vector< StandardRecipeEntry >	load_standard_entries ()
static const std::vector< StandardRecipeEntry > &	standard_entries ()
static void	evaluate_candidate (const ColorDecomposeRgb &target, const std::vector< std::string > &hexes, const std::vector< int > &ratios, const std::vector< unsigned int > &indices, ColorDecomposeRecipeMode mode, double &best_score, ColorDecomposeRecipeResult &best)

---

Class Documentation

Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::LabColor

struct Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::LabColor

Class Members
double	a {0.0}
double	b {0.0}
double	l {0.0}

Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry

struct Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry

Collaboration diagram for Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry:

Class Members
vector< string >	component_hexes
vector< string >	component_keys
string	material
string	measured_hex
LabColor	measured_lab
ColorDecomposeRecipeMode	mode {ColorDecomposeRecipeMode::CMYW}
vector< int >	ratios
string	source

Function Documentation

delta_e76()

double Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::delta_e76 ( const LabColor & a, const LabColor & b )

static

{
    return std::sqrt(std::pow(a.l - b.l, 2.0) + std::pow(a.a - b.a, 2.0) + std::pow(a.b - b.b, 2.0));
}

References Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::LabColor::a, Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::LabColor::b, delta_e76(), and Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::LabColor::l.

Referenced by delta_e76(), and evaluate_candidate().

Here is the call graph for this function:

Here is the caller graph for this function:

evaluate_candidate()

void Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::evaluate_candidate ( const ColorDecomposeRgb & target, const std::vector< std::string > & hexes, const std::vector< int > & ratios, const std::vector< unsigned int > & indices, ColorDecomposeRecipeMode mode, double & best_score, ColorDecomposeRecipeResult & best )

static

{
    const std::string mixed = blend_color_multi(hexes, ratios);
    ColorDecomposeRgb mixed_rgb;
    if (!color_decompose_hex_to_rgb(mixed, mixed_rgb))
        return;
 
    const double score = delta_e76(rgb_to_lab(target), rgb_to_lab(mixed_rgb));
    if (score >= best_score)
        return;
 
    best_score = score;
    best.valid = true;
    best.mode = mode;
    best.matched_color_hex = mixed;
    best.components.clear();
    for (size_t i = 0; i < hexes.size(); ++i) {
        ColorDecomposeRecipeComponent comp;
        comp.color_hex = hexes[i];
        comp.ratio = ratios[i];
        comp.filament_index = i < indices.size() ? indices[i] : 0;
        best.components.push_back(comp);
    }
}

References Slic3r::blend_color_multi(), Slic3r::color_decompose_hex_to_rgb(), Slic3r::ColorDecomposeRecipeComponent::color_hex, Slic3r::ColorDecomposeRecipeResult::components, delta_e76(), evaluate_candidate(), Slic3r::ColorDecomposeRecipeComponent::filament_index, Slic3r::ColorDecomposeRecipeResult::matched_color_hex, Slic3r::ColorDecomposeRecipeResult::mode, Slic3r::ColorDecomposeRecipeComponent::ratio, rgb_to_lab(), and Slic3r::ColorDecomposeRecipeResult::valid.

Referenced by evaluate_candidate().

Here is the call graph for this function:

Here is the caller graph for this function:

lab_to_srgb_hex()

std::string Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::lab_to_srgb_hex ( const LabColor & lab )

static

{
    constexpr double Xn = 0.95047, Yn = 1.0, Zn = 1.08883;
 
    auto f_inv = [](double t) -> double {
        constexpr double eps   = 216.0 / 24389.0;
        constexpr double kappa = 24389.0 / 27.0;
        const double t3 = t * t * t;
        return t3 > eps ? t3 : (t * 116.0 - 16.0) / kappa;
    };
 
    const double fy = (lab.l + 16.0) / 116.0;
    const double fx = lab.a / 500.0 + fy;
    const double fz = fy - lab.b / 200.0;
 
    const double X = Xn * f_inv(fx);
    const double Y = Yn * f_inv(fy);
    const double Z = Zn * f_inv(fz);
 
    double r =  3.2406 * X - 1.5372 * Y - 0.4986 * Z;
    double g = -0.9689 * X + 1.8758 * Y + 0.0415 * Z;
    double b =  0.0557 * X - 0.2040 * Y + 1.0570 * Z;
 
    auto gamma = [](double c) -> double {
        c = std::max(0.0, std::min(1.0, c));
        return c <= 0.0031308 ? 12.92 * c : 1.055 * std::pow(c, 1.0 / 2.4) - 0.055;
    };
    auto u8 = [&](double c) -> int {
        return std::max(0, std::min(255, static_cast<int>(std::lround(gamma(c) * 255.0))));
    };
 
    char buf[8];
    std::snprintf(buf, sizeof(buf), "#%02X%02X%02X", u8(r), u8(g), u8(b));
    return std::string(buf);
}

References Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::LabColor::a, Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::LabColor::b, Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::LabColor::l, lab_to_srgb_hex(), Slic3r::X, Xn, Slic3r::Y, Yn, Slic3r::Z, and Zn.

Referenced by lab_to_srgb_hex().

Here is the call graph for this function:

Here is the caller graph for this function:

load_standard_entries()

std::vector< StandardRecipeEntry > Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::load_standard_entries ( )

static

{
    std::vector<StandardRecipeEntry> entries;
    const std::string path = resources_dir() + "/filament_mixing/standard_color_recipes.json";
    std::ifstream ifs(path);
    if (!ifs)
        return entries;
 
    nlohmann::json root = nlohmann::json::parse(ifs, nullptr, false);
    if (root.is_discarded() || !root.contains("entries") || !root["entries"].is_array())
        return entries;
 
    for (const auto& item : root["entries"]) {
        if (!item.is_object())
            continue;
        StandardRecipeEntry entry;
        entry.mode = parse_mode(item.value("mode", "CMYW"));
        entry.material = item.value("material", "");
        entry.source = item.value("source", "");
        entry.measured_hex = item.value("measured_rgb", "");
 
        if (item.contains("components") && item["components"].is_array()) {
            for (const auto& comp : item["components"]) {
                if (comp.is_object()) {
                    entry.component_keys.push_back(comp.value("key", ""));
                    entry.component_hexes.push_back(comp.value("rgb", ""));
                }
            }
        }
        if (item.contains("ratios") && item["ratios"].is_array()) {
            for (const auto& ratio : item["ratios"]) {
                if (ratio.is_number_integer())
                    entry.ratios.push_back(ratio.get<int>());
            }
        }
        if (item.contains("measured_lab") && item["measured_lab"].is_array() && item["measured_lab"].size() >= 3) {
            entry.measured_lab = {
                item["measured_lab"][0].get<double>(),
                item["measured_lab"][1].get<double>(),
                item["measured_lab"][2].get<double>()
            };
        } else {
            ColorDecomposeRgb measured_rgb;
            if (!color_decompose_hex_to_rgb(entry.measured_hex, measured_rgb))
                continue;
            entry.measured_lab = rgb_to_lab(measured_rgb);
        }
 
        if (entry.component_hexes.size() >= 2 && entry.component_hexes.size() == entry.ratios.size() &&
            !entry.measured_hex.empty())
            entries.push_back(std::move(entry));
    }
    return entries;
}

References Slic3r::color_decompose_hex_to_rgb(), Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry::component_hexes, Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry::component_keys, load_standard_entries(), Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry::material, Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry::measured_hex, Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry::measured_lab, Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry::mode, parse_mode(), Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry::ratios, Slic3r::resources_dir(), rgb_to_lab(), and Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::StandardRecipeEntry::source.

Referenced by load_standard_entries(), and standard_entries().

Here is the call graph for this function:

Here is the caller graph for this function:

material_matches()

bool Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::material_matches ( const std::string & a, const std::string & b )

static

{
    if (a.empty() || b.empty())
        return false;
    return a == b || a == b + " Basic" || b == a + " Basic";
}

References material_matches().

Referenced by material_matches().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_mode()

ColorDecomposeRecipeMode Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::parse_mode ( const std::string & s )

static

{
    if (s == "RYBW" || s == "RGBY")
        return ColorDecomposeRecipeMode::RYBW;
    return ColorDecomposeRecipeMode::CMYW;
}

References Slic3r::CMYW, parse_mode(), and Slic3r::RYBW.

Referenced by load_standard_entries(), and parse_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

ratio_grid()

std::vector< std::vector< int > > Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::ratio_grid ( size_t n )

static

{
    std::vector<std::vector<int>> out;
    if (n == 2) {
        for (int a = 20; a <= 80; a += 5)
            out.push_back({a, 100 - a});
    } else if (n == 3) {
        for (int a = 20; a <= 60; a += 5)
            for (int b = 20; b <= 80 - a; b += 5) {
                const int c = 100 - a - b;
                if (c >= 20)
                    out.push_back({a, b, c});
            }
    }
    return out;
}

References ratio_grid().

Referenced by ratio_grid().

Here is the call graph for this function:

Here is the caller graph for this function:

rgb_to_lab()

LabColor Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::rgb_to_lab ( const ColorDecomposeRgb & rgb )

static

{
    const double r = srgb_to_linear(rgb.r);
    const double g = srgb_to_linear(rgb.g);
    const double b = srgb_to_linear(rgb.b);
 
    const double x = (0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / 0.95047;
    const double y = (0.2126729 * r + 0.7151522 * g + 0.0721750 * b);
    const double z = (0.0193339 * r + 0.1191920 * g + 0.9503041 * b) / 1.08883;
 
    const double fx = xyz_to_lab_component(x);
    const double fy = xyz_to_lab_component(y);
    const double fz = xyz_to_lab_component(z);
 
    return {116.0 * fy - 16.0, 500.0 * (fx - fy), 200.0 * (fy - fz)};
}

References Slic3r::ColorDecomposeRgb::b, Slic3r::ColorDecomposeRgb::g, Slic3r::ColorDecomposeRgb::r, rgb_to_lab(), srgb_to_linear(), and xyz_to_lab_component().

Referenced by evaluate_candidate(), load_standard_entries(), and rgb_to_lab().

Here is the call graph for this function:

Here is the caller graph for this function:

srgb_to_linear()

double Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::srgb_to_linear ( double v )

static

{
    v /= 255.0;
    return v <= 0.04045 ? v / 12.92 : std::pow((v + 0.055) / 1.055, 2.4);
}

References srgb_to_linear().

Referenced by rgb_to_lab(), and srgb_to_linear().

Here is the call graph for this function:

Here is the caller graph for this function:

standard_entries()

const std::vector< StandardRecipeEntry > & Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::standard_entries ( )

static

{
    static const std::vector<StandardRecipeEntry> entries = load_standard_entries();
    return entries;
}

References load_standard_entries(), and standard_entries().

Referenced by standard_entries().

Here is the call graph for this function:

Here is the caller graph for this function:

xyz_to_lab_component()

double Slic3r::anonymous_namespace{ColorDecomposeRecipe.cpp}::xyz_to_lab_component ( double v )

static

{
    constexpr double eps = 216.0 / 24389.0;
    constexpr double kappa = 24389.0 / 27.0;
    return v > eps ? std::cbrt(v) : (kappa * v + 16.0) / 116.0;
}

References xyz_to_lab_component().

Referenced by rgb_to_lab(), and xyz_to_lab_component().

Here is the call graph for this function:

Here is the caller graph for this function: