libvgcode::ColorRange Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libvgcode/include/ColorRange.hpp>

Collaboration diagram for libvgcode::ColorRange:

Public Member Functions
	ColorRange (EColorRangeType type=EColorRangeType::Linear)
EColorRangeType	get_type () const
const Palette &	get_palette () const
void	set_palette (const Palette &palette)
Color	get_color_at (float value) const
const std::array< float, 2 > &	get_range () const
std::vector< float >	get_values () const
std::size_t	size_in_bytes_cpu () const

Static Public Attributes
static const ColorRange	DUMMY_COLOR_RANGE = ColorRange()

Private Member Functions
void	update (float value)
void	reset ()

Private Attributes
EColorRangeType	m_type { EColorRangeType::Linear }
Palette	m_palette
std::array< float, 2 >	m_range { FLT_MAX, -FLT_MAX }
std::size_t	m_count { 0 }

Friends
class	ViewerImpl

Detailed Description

Constructor & Destructor Documentation

ColorRange()

libvgcode::ColorRange::ColorRange ( EColorRangeType type = EColorRangeType::Linear )

explicit

: m_type(type)
, m_palette(DEFAULT_RANGES_COLORS)
{
}

References libvgcode::DEFAULT_RANGES_COLORS, m_palette, and m_type.

Member Function Documentation

get_color_at()

Color libvgcode::ColorRange::get_color_at

(

float

value

)

const

{
    // Input value scaled to the colors range
    float global_t = 0.0f;
    value = std::clamp(value, m_range[0], m_range[1]);
    const float step = get_step_size(*this);
    if (step > 0.0f) {
        if (m_type == EColorRangeType::Logarithmic) {
            if (m_range[0] != 0.0f)
                global_t = std::log(value / m_range[0]) / step;
        }
        else
            global_t = (value - m_range[0]) / step;
    }
 
    const size_t color_max_idx = m_palette.size() - 1;
 
    // Compute the two colors just below (low) and above (high) the input value
    const size_t color_low_idx = std::clamp<size_t>(static_cast<size_t>(global_t), 0, color_max_idx);
    const size_t color_high_idx = std::clamp<size_t>(color_low_idx + 1, 0, color_max_idx);
 
    // Interpolate between the low and high colors to find exactly which color the input value should get
    return lerp(m_palette[color_low_idx], m_palette[color_high_idx], global_t - static_cast<float>(color_low_idx));
}

References libvgcode::get_step_size(), libvgcode::lerp(), libvgcode::Logarithmic, m_palette, m_range, and m_type.

Referenced by Slic3r::GUI::GCodeViewer::update_sequential_view_current().

Here is the call graph for this function:

Here is the caller graph for this function:

get_palette()

const Palette & libvgcode::ColorRange::get_palette

(

)

const

{
    return m_palette;
}

References m_palette.

Referenced by libvgcode::get_step_size().

Here is the caller graph for this function:

get_range()

const std::array< float, 2 > & libvgcode::ColorRange::get_range

(

)

const

{
    return m_range;
}

References m_range.

Referenced by libvgcode::get_step_size(), and Slic3r::GUI::GCodeViewer::update_sequential_view_current().

Here is the caller graph for this function:

get_type()

EColorRangeType libvgcode::ColorRange::get_type

(

)

const

{
    return m_type;
}

References m_type.

Referenced by libvgcode::get_step_size().

Here is the caller graph for this function:

get_values()

std::vector< float > libvgcode::ColorRange::get_values

(

)

const

{
    std::vector<float> ret;
 
    if (m_count == 1) {
        // single item use case
        ret.emplace_back(m_range[0]);
    }
    else if (m_count == 2) {
        // two items use case
        ret.emplace_back(m_range[0]);
        ret.emplace_back(m_range[1]);
    }
    else {
        const float step_size = get_step_size(*this);
        for (size_t i = 0; i < m_palette.size(); ++i) {
            float value = 0.0f;
            switch (m_type)
            {
            default:
            case EColorRangeType::Linear:      { value = m_range[0] + static_cast<float>(i) * step_size; break; }
            case EColorRangeType::Logarithmic: { value = ::exp(::log(m_range[0]) + static_cast<float>(i) * step_size);  break; }
            }
            ret.emplace_back(value);
        }
    }
 
    return ret;
}

References libvgcode::get_step_size(), libvgcode::Linear, libvgcode::Logarithmic, m_count, m_palette, m_range, and m_type.

Referenced by Slic3r::GUI::GCodeViewer::update_sequential_view_current().

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

void libvgcode::ColorRange::reset ( )

private

{
    m_range = { FLT_MAX, -FLT_MAX };
    m_count = 0;
}

References m_count, and m_range.

set_palette()

void libvgcode::ColorRange::set_palette

(

const Palette &

palette

)

{
    if (palette.size() > 1)
        m_palette = palette;
}

References m_palette.

size_in_bytes_cpu()

size_t libvgcode::ColorRange::size_in_bytes_cpu

(

)

const

{
    size_t ret = STDVEC_MEMSIZE(m_palette, Color);
    return ret;
}

References m_palette, and STDVEC_MEMSIZE.

update()

void libvgcode::ColorRange::update ( float value )

private

{
    if (value != m_range[0] && value != m_range[1])
        ++m_count;
 
    m_range[0] = std::min(m_range[0], value);
    m_range[1] = std::max(m_range[1], value);
}

References m_count, and m_range.

Friends And Related Symbol Documentation

ViewerImpl

friend class ViewerImpl

friend

References ViewerImpl.

Referenced by ViewerImpl.

Member Data Documentation

DUMMY_COLOR_RANGE

const ColorRange libvgcode::ColorRange::DUMMY_COLOR_RANGE = ColorRange()

static

Referenced by libvgcode::ViewerImpl::get_color_range().

m_count

std::size_t libvgcode::ColorRange::m_count { 0 }

private

{ 0 };

Referenced by get_values(), reset(), and update().

m_palette

Palette libvgcode::ColorRange::m_palette

private

Referenced by ColorRange(), get_color_at(), get_palette(), get_values(), set_palette(), and size_in_bytes_cpu().

m_range

std::array<float, 2> libvgcode::ColorRange::m_range { FLT_MAX, -FLT_MAX }

private

{ FLT_MAX, -FLT_MAX };

Referenced by get_color_at(), get_range(), get_values(), reset(), and update().

m_type

EColorRangeType libvgcode::ColorRange::m_type { EColorRangeType::Linear }

private

{ EColorRangeType::Linear };

Referenced by ColorRange(), get_color_at(), get_type(), and get_values().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libvgcode/include/ColorRange.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libvgcode/src/ColorRange.cpp