Enhancement: Adaptive Pressure advance

src/libslic3r/CMakeLists.txt

@@ -156,6 +156,12 @@ set(lisbslic3r_sources
     GCode/RetractWhenCrossingPerimeters.hpp
     GCode/SmallAreaInfillFlowCompensator.cpp
     GCode/SmallAreaInfillFlowCompensator.hpp
+    GCode/PchipInterpolatorHelper.cpp
+    GCode/PchipInterpolatorHelper.hpp
+    GCode/AdaptivePAInterpolator.cpp
+    GCode/AdaptivePAInterpolator.hpp
+    GCode/AdaptivePAProcessor.cpp
+    GCode/AdaptivePAProcessor.hpp
     GCode/SpiralVase.cpp
     GCode/SpiralVase.hpp
     GCode/SeamPlacer.cpp

src/libslic3r/GCode.hpp

@@ -24,6 +24,8 @@
 
 #include "GCode/PressureEqualizer.hpp"
 #include "GCode/SmallAreaInfillFlowCompensator.hpp"
+// ORCA: post processor below used for Dynamic Pressure advance
+#include "GCode/AdaptivePAProcessor.hpp"
 
 #include <memory>
 #include <map>
@@ -358,6 +360,19 @@ class GCode {
     std::string     extrude_loop(ExtrusionLoop loop, std::string description, double speed = -1., const ExtrusionEntitiesPtr& region_perimeters = ExtrusionEntitiesPtr());
     std::string     extrude_multi_path(ExtrusionMultiPath multipath, std::string description = "", double speed = -1.);
     std::string     extrude_path(ExtrusionPath path, std::string description = "", double speed = -1.);
+
+    // Orca: Adaptive PA variables
+    // Used for adaptive PA when extruding paths with multiple, varying flow segments.
+    // This contains the sum of the mm3_per_mm values weighted by the length of each path segment.
+    // The m_multi_flow_segment_path_pa_set constrains the PA change request to the first extrusion segment.
+    // It sets the mm3_mm value for the adaptive PA post processor to be the average of that path
+    // as calculated and stored in the m_multi_segment_path_average_mm3_per_mm value
+    double          m_multi_flow_segment_path_average_mm3_per_mm = 0;
+    bool            m_multi_flow_segment_path_pa_set = false;
+    // Adaptive PA last set flow to enable issuing of PA change commands when adaptive PA for overhangs
+    // is enabled
+    double          m_last_mm3_mm = 0;
+    // Orca: Adaptive PA code segment end
 
     // Extruding multiple objects with soluble / non-soluble / combined supports
     // on a multi-material printer, trying to minimize tool switches.
@@ -540,11 +555,13 @@ class GCode {
     std::unique_ptr<SpiralVase>         m_spiral_vase;
 
     std::unique_ptr<PressureEqualizer>  m_pressure_equalizer;
+
+    std::unique_ptr<AdaptivePAProcessor>      m_pa_processor;
 
     std::unique_ptr<WipeTowerIntegration> m_wipe_tower;
 
     std::unique_ptr<SmallAreaInfillFlowCompensator> m_small_area_infill_flow_compensator;
-
+    
     // Heights (print_z) at which the skirt has already been extruded.
     std::vector<coordf_t>               m_skirt_done;
     // Has the brim been extruded already? Brim is being extruded only for the first object of a multi-object print.

src/libslic3r/GCode/AdaptivePAInterpolator.cpp

@@ -0,0 +1,114 @@
+// AdaptivePAInterpolator.cpp
+// OrcaSlicer
+//
+// Implementation file for the AdaptivePAInterpolator class, providing methods to parse data and perform PA interpolation.
+
+#include "AdaptivePAInterpolator.hpp"
+#include <stdexcept>
+#include <cmath>
+#include <algorithm>
+#include <sstream>
+
+/**
+ * @brief Parses the input data and sets up the interpolators.
+ * @param data A string containing the data in CSV format (PA, flow rate, acceleration).
+ * @return 0 on success, -1 on error.
+ */
+int AdaptivePAInterpolator::parseAndSetData(const std::string& data) {
+    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
+}
+
+/**
+ * @brief Interpolates the PA value for the given flow rate and acceleration.
+ * @param flow_rate The flow rate at which to interpolate.
+ * @param acceleration The acceleration at which to interpolate.
+ * @return The interpolated PA value, or -1 if interpolation fails.
+ */
+double AdaptivePAInterpolator::operator()(double flow_rate, double acceleration) {
+    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
+}

src/libslic3r/GCode/AdaptivePAInterpolator.hpp

@@ -0,0 +1,54 @@
+// AdaptivePAInterpolator.hpp
+// OrcaSlicer
+//
+// Header file for the AdaptivePAInterpolator class, responsible for interpolating pressure advance (PA) values based on flow rate and acceleration using PCHIP interpolation.
+
+#ifndef ADAPTIVEPAINTERPOLATOR_HPP
+#define ADAPTIVEPAINTERPOLATOR_HPP
+
+#include <vector>
+#include <string>
+#include <map>
+#include "PchipInterpolatorHelper.hpp"
+
+/**
+ * @class AdaptivePAInterpolator
+ * @brief A class to interpolate pressure advance (PA) values based on flow rate and acceleration using Piecewise Cubic Hermite Interpolating Polynomial (PCHIP) interpolation.
+ */
+class AdaptivePAInterpolator {
+public:
+    /**
+     * @brief Default constructor.
+     */
+    AdaptivePAInterpolator() : m_isInitialised(false) {}
+
+    /**
+     * @brief Parses the input data and sets up the interpolators.
+     * @param data A string containing the data in CSV format (PA, flow rate, acceleration).
+     * @return 0 on success, -1 on error.
+     */
+    int parseAndSetData(const std::string& data);
+
+    /**
+     * @brief Interpolates the PA value for the given flow rate and acceleration.
+     * @param flow_rate The flow rate at which to interpolate.
+     * @param acceleration The acceleration at which to interpolate.
+     * @return The interpolated PA value, or -1 if interpolation fails.
+     */
+    double operator()(double flow_rate, double acceleration);
+
+    /**
+     * @brief Returns the initialization status.
+     * @return The value of m_isInitialised.
+     */
+    bool isInitialised() const {
+        return m_isInitialised;
+    }
+
+private:
+    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;
+};
+
+#endif // ADAPTIVEPAINTERPOLATOR_HPP