FlushVolPredictor Class Reference

Collaboration diagram for FlushVolPredictor:

Public Member Functions
bool	predict (const RGB &from, const RGB &to, float &flush)
	FlushVolPredictor (const std::string &data_file)
int	get_min_flush_volume ()
	FlushVolPredictor ()=default

Private Types
using	RGB = FlushPredict::RGBColor

Private Member Functions
uint64_t	generate_hash_key (const RGB &from, const RGB &to)

Private Attributes
std::unordered_map< uint64_t, float >	m_flush_map
std::vector< RGB >	m_colors
bool	m_valid { false }

Detailed Description

Member Typedef Documentation

RGB

using FlushVolPredictor::RGB = FlushPredict::RGBColor

private

Constructor & Destructor Documentation

FlushVolPredictor() [1/2]

FlushVolPredictor::FlushVolPredictor

(

const std::string &

data_file

)

{
    auto rgb_hex_to_dec = [](const std::string& hexstr, FlushPredict::RGBColor& color)->bool
        {
            if (hexstr.empty() || hexstr.length() != 7 || hexstr[0] != '#')
            {
                assert(false);
                color.r = 0, color.g = 0, color.b = 0;
                return false;
            }
 
            auto hexToByte = [](const std::string& hex)->int
                {
                    unsigned int byte;
                    std::istringstream(hex) >> std::hex >> byte;
                    return byte;
                };
            color.r = hexToByte(hexstr.substr(1, 2));
            color.g = hexToByte(hexstr.substr(3, 2));
            color.b = hexToByte(hexstr.substr(5, 2));
            return true;
        };
 
    std::ifstream in(data_file);
    if (!in.is_open()) {
        m_valid = false;
        return;
    }
    std::string line;
    std::getline(in, line); //skip color description line
    std::getline(in, line);
    // read and save color lists
    {
        std::istringstream in(line);
        std::string color;
        while (in >> color) {
            RGB c;
            if (!rgb_hex_to_dec(color, c)) {
                m_valid = false;
                return;
            }
            m_colors.emplace_back(c);
        }
    }
    std::getline(in, line); // skip colume name line
    while (std::getline(in, line)) {
        std::istringstream iss(line);
        std::string rgb_from, rgb_to;
        float value;
        if (iss >> rgb_from >> rgb_to >> value) {
            RGB from,to;
            // transfer hex str to rgb format
            if (!rgb_hex_to_dec(rgb_from, from)) {
                m_valid = false;
                return;
            }
            if (!rgb_hex_to_dec(rgb_to, to)) {
                m_valid = false;
                return;
            }
            // generate hash key for two rgb color
            uint64_t key = generate_hash_key(from,to);
            m_flush_map.emplace(key, value);
        }
        else {
            m_valid = false;
            return;
        }
    }
    m_valid = true;
}

References generate_hash_key(), m_colors, m_flush_map, and m_valid.

Here is the call graph for this function:

FlushVolPredictor() [2/2]

FlushVolPredictor::FlushVolPredictor ( )

default

Member Function Documentation

generate_hash_key()

uint64_t FlushVolPredictor::generate_hash_key ( const RGB & from, const RGB & to )

private

{
    uint64_t key = 0;
    key |= (static_cast<uint64_t>(from.r) << 40);
    key |= (static_cast<uint64_t>(from.g) << 32);
    key |= (static_cast<uint64_t>(from.b) << 24);
    key |= (static_cast<uint64_t>(to.r) << 16);
    key |= (static_cast<uint64_t>(to.g) << 8);
    key |= static_cast<uint64_t>(to.b);
    return key;
}

References FlushPredict::RGBColor::b, FlushPredict::RGBColor::g, and FlushPredict::RGBColor::r.

Referenced by FlushVolPredictor(), and predict().

Here is the caller graph for this function:

get_min_flush_volume()

int FlushVolPredictor::get_min_flush_volume

(

)

{
    if(!m_valid)
        return std::numeric_limits<int>::max();
    return static_cast<int>(std::min_element(m_flush_map.begin(), m_flush_map.end(), [](const auto& a, const auto& b) {return a.second < b.second; })->second);
}

References m_flush_map, and m_valid.

predict()

bool FlushVolPredictor::predict	(	const RGB &	from,
		const RGB &	to,
		float &	flush )

{
    if (!m_valid)
        return false;
 
    // find similar colors in color list
    std::optional<RGB> similar_from, similar_to;
    for (auto& color : m_colors) {
        if (FlushPredict::is_similar_color(color, from)) {
            similar_from = color;
            break;
        }
    }
    for (auto& color : m_colors) {
        if (FlushPredict::is_similar_color(color, to)) {
            similar_to = color;
            break;
        }
    }
 
    // `from` and `to` should have similar colors in list
    if (!similar_from || !similar_to)
        return false;
 
    uint64_t key = generate_hash_key(*similar_from,*similar_to);
    auto iter = m_flush_map.find(key);
    if (iter == m_flush_map.end())
        return false;
 
    flush = iter->second;
    return true;
}

References generate_hash_key(), FlushPredict::is_similar_color(), m_colors, m_flush_map, and m_valid.

Here is the call graph for this function:

Member Data Documentation

m_colors

std::vector<RGB> FlushVolPredictor::m_colors

private

Referenced by FlushVolPredictor(), and predict().

m_flush_map

std::unordered_map<uint64_t, float> FlushVolPredictor::m_flush_map

private

Referenced by FlushVolPredictor(), get_min_flush_volume(), and predict().

m_valid

bool FlushVolPredictor::m_valid { false }

private

{ false };

Referenced by FlushVolPredictor(), get_min_flush_volume(), and predict().

---

The documentation for this class was generated from the following file:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/FlushVolPredictor.cpp