Prime/purge tower optimisation

include/ExtruderPrime.h

@@ -0,0 +1,18 @@
+// Copyright (c) 2023 UltiMaker B.V.
+// CuraEngine is released under the terms of the AGPLv3 or higher.
+
+#ifndef EXTRUDERPRIME_H
+#define EXTRUDERPRIME_H
+
+namespace cura
+{
+
+enum class ExtruderPrime
+{
+    None, // Do not prime at all for this extruder on this layer
+    Sparse, // Just extrude a sparse priming which purpose is to make the tower stronger
+    Prime, // Do an actual prime
+};
+
+} // namespace cura
+#endif // EXTRUDERPRIME_H

include/ExtruderUse.h

@@ -0,0 +1,21 @@
+// Copyright (c) 2023 UltiMaker B.V.
+// CuraEngine is released under the terms of the AGPLv3 or higher.
+
+#ifndef EXTRUDERUSE_H
+#define EXTRUDERUSE_H
+
+#include "ExtruderPrime.h"
+
+#include <stddef.h>
+
+namespace cura
+{
+
+struct ExtruderUse
+{
+    size_t extruder_nr;
+    ExtruderPrime prime;
+};
+
+} // namespace cura
+#endif // EXTRUDERUSE_H

include/FffGcodeWriter.h

@@ -7,6 +7,7 @@
 #include <fstream>
 #include <optional>
 
+#include "ExtruderUse.h"
 #include "FanSpeedLayerTime.h"
 #include "LayerPlanBuffer.h"
 #include "gcodeExport.h"
@@ -64,9 +65,9 @@ class FffGcodeWriter : public NoCopy
      * For each raft/filler layer, the extruders to be used in that layer in the order in which they are going to be used.
      * The first number is the first raft layer. Indexing is shifted compared to normal negative layer numbers for raft/filler layers.
      */
-    std::vector<std::vector<size_t>> extruder_order_per_layer_negative_layers;
+    std::vector<std::vector<ExtruderUse>> extruder_order_per_layer_negative_layers;
 
-    std::vector<std::vector<size_t>> extruder_order_per_layer; //!< For each layer, the extruders to be used in that layer in the order in which they are going to be used
+    std::vector<std::vector<ExtruderUse>> extruder_order_per_layer; //!< For each layer, the extruders to be used in that layer in the order in which they are going to be used
 
     std::vector<std::vector<size_t>> mesh_order_per_extruder; //!< For each extruder, the order of the meshes (first element is first mesh to be printed)
 
@@ -296,7 +297,7 @@ class FffGcodeWriter : public NoCopy
      * \param current_extruder The current extruder with which we last printed
      * \return The order of extruders for a layer beginning with \p current_extruder
      */
-    std::vector<size_t> getUsedExtrudersOnLayerExcludingStartingExtruder(const SliceDataStorage& storage, const size_t start_extruder, const LayerIndex& layer_nr) const;
+    std::vector<ExtruderUse> getUsedExtrudersOnLayerExcludingStartingExtruder(const SliceDataStorage& storage, const size_t start_extruder, const LayerIndex& layer_nr) const;
 
     /*!
      * Calculate in which order to plan the meshes of a specific extruder

include/LayerPlan.h

@@ -69,6 +69,8 @@ class LayerPlan : public NoCopy
 
     std::vector<Point2LL> layer_start_pos_per_extruder_; //!< The starting position of a layer for each extruder
     std::vector<bool> has_prime_tower_planned_per_extruder_; //!< For each extruder, whether the prime tower is planned yet or not.
+    bool has_prime_tower_base_planned_; //!< Whether the prime tower base is planned yet or not.
+    bool has_prime_tower_inset_planned_; //!< Whether the prime tower inset is planned yet or not.
     std::optional<Point2LL> last_planned_position_; //!< The last planned XY position of the print head (if known)
 
     std::shared_ptr<const SliceMeshStorage> current_mesh_; //!< The mesh of the last planned move.
@@ -205,6 +207,26 @@ class LayerPlan : public NoCopy
      */
     void setPrimeTowerIsPlanned(unsigned int extruder_nr);
 
+    /*!
+     * Whether the prime tower extra base is already planned.
+     */
+    bool getPrimeTowerBaseIsPlanned() const;
+
+    /*!
+     * Mark the prime tower extra base as planned.
+     */
+    void setPrimeTowerBaseIsPlanned();
+
+    /*!
+     * Whether the prime tower extra inset is already planned.
+     */
+    bool getPrimeTowerInsetIsPlanned() const;
+
+    /*!
+     * Mark the prime tower extra inset as planned.
+     */
+    void setPrimeTowerInsetIsPlanned();
+
     bool getSkirtBrimIsPlanned(unsigned int extruder_nr) const;
 
     void setSkirtBrimIsPlanned(unsigned int extruder_nr);

include/LayerPlanBuffer.h

@@ -212,7 +212,6 @@ class LayerPlanBuffer
     void handleStandbyTemp(std::vector<ExtruderPlan*>& extruder_plans, unsigned int extruder_plan_idx, double standby_temp);
 };
 
-
 } // namespace cura
 
 #endif // LAYER_PLAN_BUFFER_H

include/PrimeTower.h

@@ -4,13 +4,15 @@
 #ifndef PRIME_TOWER_H
 #define PRIME_TOWER_H
 
+#include <map>
 #include <vector>
 
+#include "ExtruderUse.h"
+#include "settings/EnumSettings.h"
 #include "settings/types/LayerIndex.h"
 #include "utils/polygon.h" // Polygons
 #include "utils/polygonUtils.h"
 
-
 namespace cura
 {
 
@@ -40,7 +42,17 @@ class PrimeTower
     const unsigned int number_of_prime_tower_start_locations_ = 21; //!< The required size of \ref PrimeTower::wipe_locations
 
     MovesByExtruder prime_moves_; //!< For each extruder, the moves to be processed for actual priming.
+
+    /*
+     *  The first index is a bitmask representing an extruder combination, e.g. 0x05 for extruders 1+3.
+     *  The second one is the used extruder index, e.g. 1
+     *  The polygons represent the sparse pattern to be printed when all the given extruders are unused for this layer
+     *  and the given extruder is currently in use
+     */
+    std::map<size_t, std::map<size_t, Polygons>> sparse_pattern_per_extruders_;
+
     MovesByLayer base_extra_moves_; //!< For each layer and each extruder, the extra moves to be processed for better adhesion/strength
+    MovesByExtruder inset_extra_moves_; //!< For each extruder, the extra inset moves to be processed for better adhesion on initial layer
 
     Polygons outer_poly_; //!< The outline of the outermost prime tower.
     std::vector<Polygons> outer_poly_base_; //!< The outline of the layers having extra width for the base
@@ -89,10 +101,16 @@ class PrimeTower
      *
      * \param storage where to get settings from; where to get the maximum height of the prime tower from
      * \param[in,out] gcode_layer Where to get the current extruder from; where to store the generated layer paths
-     * \param prev_extruder The previous extruder with which paths were planned; from which extruder a switch was made
-     * \param new_extruder The switched to extruder with which the prime tower paths should be generated.
+     * \param required_extruder_prime the extruders which actually required to be primed at this layer
+     * \param prev_extruder_nr The previous extruder with which paths were planned; from which extruder a switch was made
+     * \param new_extruder_nr The switched to extruder with which the prime tower paths should be generated.
      */
-    void addToGcode(const SliceDataStorage& storage, LayerPlan& gcode_layer, const size_t prev_extruder, const size_t new_extruder) const;
+    void addToGcode(
+        const SliceDataStorage& storage,
+        LayerPlan& gcode_layer,
+        const std::vector<ExtruderUse>& required_extruder_prime,
+        const size_t prev_extruder_nr,
+        const size_t new_extruder_nr) const;
 
     /*!
      * \brief Subtract the prime tower from the support areas in storage.
@@ -121,8 +139,33 @@ class PrimeTower
      *
      * Generate the extrude paths for each extruder on even and odd layers
      * Fill the ground poly with dense infill.
+     * \param cumulative_insets [in, out] The insets added to each extruder to compute the radius of its ring
+     */
+    void generatePaths_denseInfill(std::vector<coord_t>& cumulative_insets);
+
+    /*!
+     * \see WipeTower::generatePaths
+     *
+     * \brief Generate the sparse extrude paths for each extruders combination
+     * \param cumulative_insets The insets added to each extruder to compute the radius of its ring
+     */
+    void generatePaths_sparseInfill(const std::vector<coord_t>& cumulative_insets);
+
+    /*!
+     * \brief Generate the sparse extrude paths for an extruders combination
+     *
+     * \param first_extruder_nr The index of the first extruder to be pseudo-primed
+     * \param last_extruder_nr The index of the last extruder to be pseudo-primed
+     * \param rings_radii The external radii of each extruder ring, plus the internal radius of the internal ring
+     * \param line_width The actual line width of the extruder
+     * \param actual_extruder_nr The number of the actual extruder to be used
      */
-    void generatePaths_denseInfill();
+    Polygons generatePath_sparseInfill(
+        const size_t first_extruder_idx,
+        const size_t last_extruder_idx,
+        const std::vector<coord_t>& rings_radii,
+        const coord_t line_width,
+        const size_t actual_extruder_nr);
 
     /*!
      * Generate start locations on the prime tower. The locations are evenly spread around the prime tower's perimeter.
@@ -143,6 +186,49 @@ class PrimeTower
      */
     void addToGcode_denseInfill(LayerPlan& gcode_layer, const size_t extruder) const;
 
+    /*!
+     * \brief Add path plans for the prime tower extra outer rings to make the stronger base
+     * \param gcode_layer The gcode export to add the paths plans to
+     * \param extruder_nr The current extruder number
+     * \return True if something has actually been added, according to the extruder number
+     *         and current layer.
+     */
+    bool addToGcode_base(LayerPlan& gcode_layer, const size_t extruder_nr) const;
+
+    /*!
+     * \brief Add path plans for the prime tower extra inner rings to increase bed adhesion
+     * \param gcode_layer The gcode export to add the paths plans to
+     * \param extruder_nr The current extruder number
+     * \return True if something has actually been added, according to the extruder number
+     *         and current layer.
+     */
+    bool addToGcode_inset(LayerPlan& gcode_layer, const size_t extruder_nr) const;
+
+    /*!
+     * \brief Add path plans in the case an extruder is not to be actually primed, but we still
+     *        want to print something to make the prime tower consistent.
+     * \param gcode_layer The gcode export to add the paths plans to
+     * \param extruders_to_prime_idx The indexes of the extra extruders which also don't require being primed on this layer
+     * \param current_extruder_nr The extruder currently being used
+     */
+    void addToGcode_sparseInfill(LayerPlan& gcode_layer, const std::vector<size_t>& extruders_to_prime_idx, const size_t current_extruder_nr) const;
+
+    /*!
+     * \brief Find the list of extruders that don't actually need to be primed during this layer, and for which
+     *        we want to print only the sparse infill to keep the prime tower consistent.
+     * \param gcode_layer The current gcode export
+     * \param required_extruder_prime The pre-computed list of extruders uses during this layer
+     * \param method The current prime tower strategy
+     * \param initial_list_idx A list potentially containing extruders that we already know can be used for
+     *                         sparse infill
+     * \return The indexes of extruders to be used for sparse infill
+     */
+    std::vector<size_t> findExtrudersSparseInfill(
+        LayerPlan& gcode_layer,
+        const std::vector<ExtruderUse>& required_extruder_prime,
+        cura::PrimeTowerMethod method,
+        const std::vector<size_t>& initial_list_idx = {}) const;
+
     /*!
      * For an extruder switch that happens not on the first layer, the extruder needs to be primed on the prime tower.
      * This function picks a start location for this extruder on the prime tower's perimeter and travels there to avoid

include/TreeSupportBaseCircle.h

@@ -1,14 +1,15 @@
-//CuraEngine is released under the terms of the AGPLv3 or higher.
+// CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #ifndef TREESUPPORTCIRCLE_H
 #define TREESUPPORTCIRCLE_H
 
 #include "utils/Coord_t.h"
 #include "utils/polygon.h"
 
-#include <cmath>
 #include <range/v3/view/iota.hpp>
 
+#include <cmath>
+
 namespace cura
 {
 

include/TreeSupportEnums.h

@@ -1,4 +1,4 @@
-//CuraEngine is released under the terms of the AGPLv3 or higher.
+// CuraEngine is released under the terms of the AGPLv3 or higher.
 #ifndef CURAENGINE_TREESUPPORTENUMS_H
 #define CURAENGINE_TREESUPPORTENUMS_H
 
@@ -28,6 +28,6 @@ enum class AvoidanceType
     COLLISION
 };
 
-}//end namespace
+} // namespace cura
 
 #endif // CURAENGINE_TREESUPPORTENUMS_H

include/settings/EnumSettings.h

@@ -245,6 +245,28 @@ enum class InsetDirection
     PLUGIN,
 };
 
+/*!
+ * Method used for prime tower generation
+ */
+enum class PrimeTowerMethod
+{
+    /*!
+     * No prime tower is generated.
+     */
+    NONE,
+
+    /*!
+     * Prime tower that minimizes time and used filament as much as possible.
+     */
+    INTERLEAVED,
+
+    /*!
+     * Prime tower that minimizes time and used filament, but doesn't allow
+     * for printing two different filaments over each other.
+     */
+    NORMAL,
+};
+
 } // namespace cura
 
-#endif // ENUMSETTINGS_H
+#endif // ENUMSETTINGS_H

include/utils/polygonUtils.h

@@ -675,6 +675,19 @@ class PolygonUtils
      */
     static Polygon makeCircle(const Point2LL mid, const coord_t radius, const AngleRadians a_step = std::numbers::pi / 8);
 
+    /*!
+     * Create a "wheel" shape.
+     *
+     * This creates a polygon which represents the shape of a wheel.
+     * \param mid The center of the circle.
+     * \param inner_radius The radius of the wheel inner circle.
+     * \param outer_radius The radius of the wheel outer circle.
+     * \param semi_nb_spokes The semi number of spokes in the wheel. There will actually be N*2 spokes.
+     * \param arc_angle_resolution The number of segment on each arc.
+     * \return A new Polygon containing the circle.
+     */
+    static Polygon makeWheel(const Point2LL& mid, const coord_t inner_radius, const coord_t outer_radius, const size_t semi_nb_spokes, const size_t arc_angle_resolution);
+
     /*!
      * Connect all polygons to their holes using zero widths hole channels, so that the polygons and their outlines are connected together
      */

include/utils/types/get.h

@@ -103,7 +103,9 @@ constexpr auto& get(cura::utils::point3d auto& point) noexcept
 {
     constexpr std::string_view idx = C.value;
     static_assert(idx.size() == 1, "Only one character allowed");
-    static_assert(idx.starts_with("X") || idx.starts_with("x") || idx.starts_with("Y") || idx.starts_with("y") || idx.starts_with("Z") || idx.starts_with("z"), "Index out of bounds");
+    static_assert(
+        idx.starts_with("X") || idx.starts_with("x") || idx.starts_with("Y") || idx.starts_with("y") || idx.starts_with("Z") || idx.starts_with("z"),
+        "Index out of bounds");
     if constexpr (idx.starts_with("X") || idx.starts_with("x"))
     {
         return std::get<0>(point);