Collaboration diagram for Slic3r::client::InterpolateTableContext:

Classes
struct	Item

Static Public Member Functions
static void	init (const expr &x)

static void	add_pair (const expr &x, const expr &y, InterpolateTableContext &table)

static void	evaluate (const expr &expr_x, const InterpolateTableContext &table, expr &out)

Public Attributes
std::vector< Item >	table

Detailed Description

Class Documentation

◆ Slic3r::client::InterpolateTableContext::Item

struct Slic3r::client::InterpolateTableContext::Item

Class Members
IteratorRange	it_range_x
double	x
double	y

Member Function Documentation

◆ add_pair()

static void Slic3r::client::InterpolateTableContext::add_pair	(	const expr &	x,
		const expr &	y,
		InterpolateTableContext &	table
	)

inlinestatic

                                                                                           {
            if (x.type() != expr::TYPE_EMPTY) {
                if (! x.numeric_type())
                    x.throw_exception("X value of a table point must be a number.");
                if (! y.numeric_type())
                    y.throw_exception("Y value of a table point must be a number.");
                table.table.push_back({ x.as_d(), x.it_range, y.as_d() });
            }
        }

References table, and Slic3r::client::expr::TYPE_EMPTY.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the caller graph for this function:

◆ evaluate()

static void Slic3r::client::InterpolateTableContext::evaluate	(	const expr &	expr_x,
		const InterpolateTableContext &	table,
		expr &	out
	)

inlinestatic

                                                                                                  {
            if (expr_x.type() == expr::TYPE_EMPTY)
                return;
 
            // Check whether the table X values are sorted.
            double x = expr_x.as_d();
            bool   evaluated = false;
            for (size_t i = 1; i < table.table.size(); ++i) {
                double x0 = table.table[i - 1].x;
                double x1 = table.table[i].x;
                if (x0 > x1)
                    boost::throw_exception(qi::expectation_failure(
                        table.table[i - 1].it_range_x.begin(), table.table[i].it_range_x.end(), spirit::info("X coordinates of the table must be increasing")));
                if (! evaluated && x >= x0 && x <= x1) {
                    double y0 = table.table[i - 1].y;
                    double y1 = table.table[i].y;
                    if (x == x0)
                        out.set_d(y0);
                    else if (x == x1)
                        out.set_d(y1);
                    else if (is_approx(x0, x1))
                        out.set_d(0.5 * (y0 + y1));
                    else
                        out.set_d(Slic3r::lerp(y0, y1, (x - x0) / (x1 - x0)));
                    evaluated = true;
                }
            }
            if (! evaluated) {
                // Clamp x into the table range with EPSILON.
                if (double x0 = table.table.front().x; x > x0 - EPSILON && x < x0)
                    out.set_d(table.table.front().y);
                else if (double x1 = table.table.back().x; x > x1 && x < x1 + EPSILON)
                    out.set_d(table.table.back().y);
                else
                    // The value is really outside the table range.
                    expr_x.throw_exception("Interpolation value is outside the table range");
            }
        }

References Slic3r::client::expr::as_d(), EPSILON, Slic3r::is_approx(), Slic3r::lerp(), Slic3r::client::expr::set_d(), table, Slic3r::client::expr::throw_exception(), Slic3r::client::expr::type(), and Slic3r::client::expr::TYPE_EMPTY.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init()

static void Slic3r::client::InterpolateTableContext::init ( const expr & x )

inlinestatic

                                        {
            if (x.type() != expr::TYPE_EMPTY) {
                if (!x.numeric_type())
                    x.throw_exception("Interpolation value must be a number.");
            }
        }