AdaptivePAInterpolator Class Reference

A class to interpolate pressure advance (PA) values based on flow rate and acceleration using Piecewise Cubic Hermite Interpolating Polynomial (PCHIP) interpolation. More...

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/AdaptivePAInterpolator.hpp>

Collaboration diagram for AdaptivePAInterpolator:

Public Member Functions
	AdaptivePAInterpolator ()
	Default constructor.
int	parseAndSetData (const std::string &data)
	Parses the input data and sets up the interpolators.
double	operator() (double flow_rate, double acceleration)
	Interpolates the PA value for the given flow rate and acceleration.
bool	isInitialised () const
	Returns the initialization status.

Private Attributes
std::map< double, PchipInterpolatorHelper >	flow_interpolators_
	Map each acceleration to a flow-rate-to-PA interpolator.
std::vector< double >	accelerations_
	Store unique accelerations.
bool	m_isInitialised

Detailed Description

A class to interpolate pressure advance (PA) values based on flow rate and acceleration using Piecewise Cubic Hermite Interpolating Polynomial (PCHIP) interpolation.

Constructor & Destructor Documentation

AdaptivePAInterpolator()

AdaptivePAInterpolator::AdaptivePAInterpolator ( )

inline

Default constructor.

: m_isInitialised(false) {}

References m_isInitialised.

Member Function Documentation

isInitialised()

bool AdaptivePAInterpolator::isInitialised ( ) const

inline

Returns the initialization status.

Returns

The value of m_isInitialised.

                               {
        return m_isInitialised;
    }

References m_isInitialised.

Referenced by Slic3r::AdaptivePAProcessor::process_layer().

Here is the caller graph for this function:

operator()()

double AdaptivePAInterpolator::operator()	(	double	flow_rate,
		double	acceleration )

Interpolates the PA value for the given flow rate and acceleration.

Parameters

flow_rate	The flow rate at which to interpolate.
acceleration	The acceleration at which to interpolate.

Returns

The interpolated PA value, or -1 if interpolation fails.

                                                                               {
    std::vector<double> pa_values;
    std::vector<double> acc_values;
 
    // Estimate PA value for every flow to PA model for the given flow rate
    for (const auto& kv : flow_interpolators_) {
        double pa_value = kv.second.interpolate(flow_rate);
        
        // Check if the interpolated PA value is valid
        if (pa_value != -1) {
            pa_values.push_back(pa_value);
            acc_values.push_back(kv.first);
        }
    }
 
    // Check if there are enough acceleration values for interpolation
    if (acc_values.size() < 2) {
        // Special case: Only one acceleration value
        if (acc_values.size() == 1) {
            return std::round(pa_values[0] * 1000.0) / 1000.0; // Rounded to 3 decimal places
        }
        return -1; // Error: Not enough data points for interpolation
    }
 
    // Create a new PchipInterpolatorHelper for PA-acceleration interpolation
    // Use the estimated PA values from the for loop above and their corresponding accelerations to
    // generate the new PCHIP model. Then run this model to interpolate the PA value for the given acceleration value.
    PchipInterpolatorHelper pa_accel_interpolator(acc_values, pa_values);
    return std::round(pa_accel_interpolator.interpolate(acceleration) * 1000.0) / 1000.0; // Rounded to 3 decimal places
}

References flow_interpolators_, and PchipInterpolatorHelper::interpolate().

Here is the call graph for this function:

parseAndSetData()

int AdaptivePAInterpolator::parseAndSetData

(

const std::string &

data

)

Parses the input data and sets up the interpolators.

Parameters

data	A string containing the data in CSV format (PA, flow rate, acceleration).

Returns

0 on success, -1 on error.

                                                                 {
    flow_interpolators_.clear();
    accelerations_.clear();
 
    try {
        std::istringstream ss(data);
        std::string line;
        std::map<double, std::vector<std::pair<double, double>>> acc_to_flow_pa;
 
        while (std::getline(ss, line)) {
            std::istringstream lineStream(line);
            std::string value;
            double paValue, flowRate, acceleration;
            paValue = flowRate = acceleration = 0.f; // initialize all to zero.
 
            // Parse PA value
            if (std::getline(lineStream, value, ',')) {
                paValue = std::stod(value);
            }
 
            // Parse flow rate value
            if (std::getline(lineStream, value, ',')) {
                flowRate = std::stod(value);
            }
 
            // Parse acceleration value
            if (std::getline(lineStream, value, ',')) {
                acceleration = std::stod(value);
            }
 
            // Store the parsed values in a map with acceleration as the key
            acc_to_flow_pa[acceleration].emplace_back(flowRate, paValue);
        }
 
        // Iterate through the map to set up the interpolators
        for (const auto& kv : acc_to_flow_pa) {
            double acceleration = kv.first;
            const auto& data = kv.second;
 
            std::vector<double> flowRates;
            std::vector<double> paValues;
 
            for (const auto& pair : data) {
                flowRates.push_back(pair.first);
                paValues.push_back(pair.second);
            }
 
            // Only set up the interpolator if there are enough data points
            if (flowRates.size() > 1) {
                PchipInterpolatorHelper interpolator(flowRates, paValues);
                flow_interpolators_[acceleration] = interpolator;
                accelerations_.push_back(acceleration);
            }
        }
    } catch (const std::exception&) {
        m_isInitialised = false;
        return -1; // Error: Exception during parsing
    }
    m_isInitialised = true;
    return 0; // Success
}

References accelerations_, flow_interpolators_, and m_isInitialised.

Member Data Documentation

accelerations_

std::vector<double> AdaptivePAInterpolator::accelerations_

private

Store unique accelerations.

Referenced by parseAndSetData().

flow_interpolators_

std::map<double, PchipInterpolatorHelper> AdaptivePAInterpolator::flow_interpolators_

private

Map each acceleration to a flow-rate-to-PA interpolator.

Referenced by operator()(), and parseAndSetData().

m_isInitialised

bool AdaptivePAInterpolator::m_isInitialised

private

Referenced by AdaptivePAInterpolator(), isInitialised(), and parseAndSetData().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/AdaptivePAInterpolator.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/AdaptivePAInterpolator.cpp