CURA-12175 Fix scarf seam and coasting interaction

include/ExtruderPlan.h

@@ -191,7 +191,7 @@ class ExtruderPlan
     /*!
      * @return distance between p0 and p1 as well as the time spend on the segment
      */
-    std::pair<double, double> getPointToPointTime(const Point3LL& p0, const Point3LL& p1, const GCodePath& path);
+    std::pair<double, double> getPointToPointTime(const Point3LL& p0, const Point3LL& p1, const GCodePath& path) const;
 
     /*!
      * Compute naive time estimates (without accounting for slow down at corners etc.) and naive material estimates.

include/LayerPlan.h

@@ -60,20 +60,27 @@ class LayerPlan : public NoCopy
 #endif
 
 public:
-    // 'AdjustCoasting'; because split-up paths from the same extruder (with no travel moves between them) should count as the same path w.r.t. coasting.
-    enum class AdjustCoasting
-    {
-        AsNormal,
-        CoastEntirePath,
-        ContinueCoasting
-    };
-
     const PathConfigStorage configs_storage_; //!< The line configs for this layer for each feature type
     const coord_t z_;
     coord_t final_travel_z_;
     bool mode_skip_agressive_merge_; //!< Whether to give every new path the 'skip_agressive_merge_hint' property (see GCodePath); default is false.
 
 private:
+    // Indicates how coasting should be processed on the given path.
+    enum class ApplyCoasting
+    {
+        NoCoasting, // Do not apply coasting on this path, extrude it normally
+        CoastEntirePath, // Fully coast this path, i.e. replace it by travel moves
+        PartialCoasting // Extrude the first part of the path and coast the end
+    };
+
+    struct PathCoasting
+    {
+        ApplyCoasting apply_coasting{ ApplyCoasting::NoCoasting };
+        size_t coasting_start_index{ 0 };
+        Point3LL coasting_start_pos;
+    };
+
     const SliceDataStorage& storage_; //!< The polygon data obtained from FffPolygonProcessor
     const LayerIndex layer_nr_; //!< The layer number of this layer plan
     const bool is_initial_layer_; //!< Whether this is the first layer (which might be raft)
@@ -714,28 +721,6 @@ class LayerPlan : public NoCopy
      */
     bool makeRetractSwitchRetract(unsigned int extruder_plan_idx, unsigned int path_idx);
 
-    /*!
-     * Writes a path to GCode and performs coasting, or returns false if it did nothing.
-     *
-     * Coasting replaces the last piece of an extruded path by move commands and uses the oozed material to lay down lines.
-     *
-     * \param gcode The gcode to write the planned paths to.
-     * \param extruder_plan_idx The index of the current extruder plan.
-     * \param path_idx The index into LayerPlan::paths for the next path to be
-     * written to GCode.
-     * \param layer_thickness The height of the current layer.
-     * \param insertTempOnTime A function that inserts temperature changes at a given time.
-     * \param coasting_adjust Paths can be split up, so we need to know when to continue coasting from last, or even coast the entire path.
-     * \return Whether any GCode has been written for the path.
-     */
-    bool writePathWithCoasting(
-        GCodeExport& gcode,
-        const size_t extruder_plan_idx,
-        const size_t path_idx,
-        const coord_t layer_thickness,
-        const std::function<void(const double, const int64_t)> insertTempOnTime,
-        const std::pair<AdjustCoasting, double> coasting_adjust);
-
     /*!
      * Applying speed corrections for minimal layer times and determine the fanSpeed.
      *
@@ -957,6 +942,37 @@ class LayerPlan : public NoCopy
         const bool smooth_speed,
         const AddExtrusionSegmentFunction& func_add_segment);
 
+    /*!
+     * Pre-calculates the coasting to be applied on the paths
+     *
+     * \param extruder_settings The current extruder settings
+     * \param paths The current set of paths to be written to GCode
+     * \param current_position The last position set in the gcode writer
+     * \return The list of coasting settings to be applied on the paths. It will always have the same size as paths.
+     */
+    std::vector<PathCoasting> calculatePathsCoasting(const Settings& extruder_settings, const std::vector<GCodePath>& paths, const Point3LL& current_position) const;
+
+    /*!
+     * Writes a path to GCode and performs coasting, or returns false if it did nothing.
+     *
+     * Coasting replaces the last piece of an extruded path by move commands and uses the oozed material to lay down lines.
+     *
+     * \param gcode The gcode to write the planned paths to.
+     * \param extruder_plan_idx The index of the current extruder plan.
+     * \param path_idx The index into LayerPlan::paths for the next path to be
+     * written to GCode.
+     * \param layer_thickness The height of the current layer.
+     * \param insertTempOnTime A function that inserts temperature changes at a given time.
+     * \param path_coasting The actual coasting to be applied to the path.
+     * \return Whether any GCode has been written for the path.
+     */
+    bool writePathWithCoasting(
+        GCodeExport& gcode,
+        const size_t extruder_plan_idx,
+        const size_t path_idx,
+        const std::function<void(const double, const int64_t)> insertTempOnTime,
+        const PathCoasting& path_coasting);
+
     /*!
      * \brief Helper function to calculate the distance from the start of the current wall line to the first bridge segment
      * \param wall The currently processed wall

include/geometry/Point3LL.h

@@ -192,6 +192,11 @@ inline Point3LL operator*(const T i, const Point3LL& rhs)
     return rhs * i;
 }
 
+inline Point3LL lerp(const Point3LL& a, const Point3LL& b, const double t)
+{
+    return Point3LL(cura::lerp(a.x_, b.x_, t), cura::lerp(a.y_, b.y_, t), cura::lerp(a.z_, b.z_, t));
+}
+
 } // namespace cura
 
 

include/utils/Coord_t.h

@@ -6,8 +6,11 @@
 
 
 // Include Clipper to get the ClipperLib::IntPoint definition, which we reuse as Point definition.
+#include <cmath>
 #include <polyclipping/clipper.hpp>
 
+#include "utils/types/generic.h"
+
 namespace cura
 {
 
@@ -16,7 +19,7 @@ using coord_t = ClipperLib::cInt;
 static inline coord_t operator"" _mu(unsigned long long i)
 {
     return static_cast<coord_t>(i);
-};
+}
 
 #define INT2MM(n) (static_cast<double>(n) / 1000.0)
 #define INT2MM2(n) (static_cast<double>(n) / 1000000.0)
@@ -27,6 +30,12 @@ static inline coord_t operator"" _mu(unsigned long long i)
 #define INT2MICRON(n) ((n) / 1)
 #define MICRON2INT(n) ((n)*1)
 
+template<utils::floating_point FactorType>
+[[nodiscard]] inline coord_t lerp(coord_t a, coord_t b, FactorType t)
+{
+    return std::llrint(std::lerp(static_cast<double>(a), static_cast<double>(b), t));
+}
+
 } // namespace cura