CURA-12822 start end infill away from wall (#2263)

Author: HellAholic

CMakeLists.txt

@@ -184,6 +184,8 @@ set(engine_SRCS # Except main.cpp.
         src/geometry/Polyline.cpp
         src/geometry/ClosedPolyline.cpp
         src/geometry/MixedLinesSet.cpp
+
+        src/geometry/conversions/Point2D_Point2LL.cpp
 )
 
 add_library(_CuraEngine STATIC ${engine_SRCS} ${engine_PB_SRCS})
@@ -235,9 +237,9 @@ find_package(fmt REQUIRED)
 find_package(range-v3 REQUIRED)
 find_package(scripta REQUIRED)
 find_package(PNG REQUIRED)
-if(NOT EMSCRIPTEN)
+if (NOT EMSCRIPTEN)
     find_package(TBB REQUIRED)
-endif()
+endif ()
 
 if (ENABLE_SENTRY)
     find_package(sentry REQUIRED)

include/FffGcodeWriter.h

@@ -417,10 +417,18 @@ class FffGcodeWriter : public NoCopy
      * mesh which should be printed with this extruder.
      * \param mesh_config The line config with which to print a print feature.
      * \param part The part for which to create gcode.
+     * \param start_move_inwards_length The length of the extra inwards moves to be added at the start of each infill line
+     * \param end_move_inwards_length The length of the extra inwards moves to be added at the end of each infill line
      * \return Whether this function added anything to the layer plan.
      */
-    bool processMultiLayerInfill(LayerPlan& gcodeLayer, const SliceMeshStorage& mesh, const size_t extruder_nr, const MeshPathConfigs& mesh_config, const SliceLayerPart& part)
-        const;
+    bool processMultiLayerInfill(
+        LayerPlan& gcodeLayer,
+        const SliceMeshStorage& mesh,
+        const size_t extruder_nr,
+        const MeshPathConfigs& mesh_config,
+        const SliceLayerPart& part,
+        const coord_t start_move_inwards_length = 0,
+        const coord_t end_move_inwards_length = 0) const;
 
     /*!
      * \brief Add normal sparse infill for a given part in a layer.
@@ -430,6 +438,8 @@ class FffGcodeWriter : public NoCopy
      * mesh which should be printed with this extruder
      * \param mesh_config The line config with which to print a print feature.
      * \param part The part for which to create gcode.
+     * \param start_move_inwards_length The length of the extra inwards moves to be added at the start of each infill line
+     * \param end_move_inwards_length The length of the extra inwards moves to be added at the end of each infill line
      * \return Whether this function added anything to the layer plan.
      */
     bool processSingleLayerInfill(
@@ -438,7 +448,9 @@ class FffGcodeWriter : public NoCopy
         const SliceMeshStorage& mesh,
         const size_t extruder_nr,
         const MeshPathConfigs& mesh_config,
-        const SliceLayerPart& part) const;
+        const SliceLayerPart& part,
+        const coord_t start_move_inwards_length = 0,
+        const coord_t end_move_inwards_length = 0) const;
 
     /*!
      * Generate the insets for the walls of a given layer part.

include/LayerPlan.h

@@ -37,6 +37,7 @@ namespace cura
 class Comb;
 class SliceDataStorage;
 class LayerPlanBuffer;
+class STHalfEdge;
 
 template<typename PathType>
 class PathAdapter;
@@ -525,9 +526,30 @@ class LayerPlan : public NoCopy
         bool reverse_order = false,
         const std::optional<Point2LL> start_near_location = std::optional<Point2LL>(),
         bool scarf_seam = false,
-        bool smooth_acceleration = false,
+        bool smooth_speed = false,
         const std::shared_ptr<TextureDataProvider>& texture_data_provider = nullptr);
 
+    /*!
+     * Adds infill polygons to the gcode with optimized order.
+     *
+     * In case we need to generate extra inwards moves for the infill, we cannot treat them as polygons anymore, since the lines will be un-closed. Thus, the resulting open
+     * polylines are returned in \p remaining_lines and should be re-added to the gcode, e.g. by using addLinesByOptimizer().
+     *
+     * @param polygons The infill polygons to be added
+     * @param[out] remaining_lines The list to be filled with generates open polylines. The given list may be non-empty, only new lines will be appended.     * @param config The
+     * config with which to print the polygon lines
+     * @param settings The current settings to retrieve values from
+     * @param add_extra_inwards_move Indicates whether extra start/end inwards extrusion moves will be generated
+     * @param near_start_location Optional: Location near where to add the first line. If not provided the last position is used.
+     */
+    void addInfillPolygonsByOptimizer(
+        const Shape& polygons,
+        OpenLinesSet& remaining_lines,
+        const GCodePathConfig& config,
+        const Settings& settings,
+        const bool add_extra_inwards_move = false,
+        const std::optional<Point2LL>& near_start_location = std::optional<Point2LL>());
+
     /*!
      * Add a single line that is part of a wall to the gcode.
      * \param p0 The start vertex of the line.
@@ -687,6 +709,9 @@ class LayerPlan : public NoCopy
      * \param fan_speed optional fan speed override for this path
      * \param reverse_print_direction Whether to reverse the optimized order and their printing direction.
      * \param order_requirements Pairs where first needs to be printed before second. Pointers are pointing to elements of \p lines
+     * \param extra_inwards_start_move_length The length of the extra inwards moves to be added at the start of each infill line
+     * \param extra_inwards_end_move_length The length of the extra inwards moves to be added at the end of each infill line
+     * \param extra_inwards_move_contour The contour to be considered in order to add the inwards moves
      */
     template<class LineType>
     void addLinesByOptimizer(
@@ -699,7 +724,10 @@ class LayerPlan : public NoCopy
         const std::optional<Point2LL> near_start_location = std::optional<Point2LL>(),
         const double fan_speed = GCodePathConfig::FAN_SPEED_DEFAULT,
         const bool reverse_print_direction = false,
-        const std::unordered_multimap<const Polyline*, const Polyline*>& order_requirements = PathOrderOptimizer<const Polyline*>::no_order_requirements_);
+        const std::unordered_multimap<const Polyline*, const Polyline*>& order_requirements = PathOrderOptimizer<const Polyline*>::no_order_requirements_,
+        const coord_t extra_inwards_start_move_length = 0,
+        const coord_t extra_inwards_end_move_length = 0,
+        const Shape& extra_inwards_move_contour = Shape());
 
     /*!
      * Add lines to the gcode with optimized order.
@@ -870,14 +898,55 @@ class LayerPlan : public NoCopy
      * \param wipe_dist (optional) the distance wiped without extruding after laying down a line.
      * \param flow_ratio The ratio with which to multiply the extrusion amount
      * \param fan_speed optional fan speed override for this path
+     * \param extra_inwards_start_move_length The length of the extra inwards moves to be added at the start of each infill line
+     * \param extra_inwards_end_move_length The length of the extra inwards moves to be added at the end of each infill line
+     * \param extra_inwards_move_contour The contour to be considered in order to add the inwards moves
      */
     void addLinesInGivenOrder(
         const std::vector<PathOrdering<const Polyline*>>& lines,
         const GCodePathConfig& config,
         const SpaceFillType space_fill_type,
         const coord_t wipe_dist,
         const Ratio flow_ratio,
-        const double fan_speed);
+        const double fan_speed,
+        const coord_t extra_inwards_start_move_length = 0,
+        const coord_t extra_inwards_end_move_length = 0,
+        const Shape& extra_inwards_move_contour = Shape());
+
+    /*!
+     * Add order optimized polygons to the gcode.
+     * Add polygons to the gcode with optimized order.
+     *
+     * \param polygons The polygons.
+     * \param config The config with which to print the polygon lines.
+     * for each given segment (optionally nullptr).
+     * \param settings The settings which should apply to these polygons added to the layer plan
+     * \param z_seam_config Optional configuration for z-seam.
+     * \param wall_0_wipe_dist The distance to travel along each polygon after
+     * it has been laid down, in order to wipe the start and end of the wall
+     * together.
+     * \param spiralize Whether to gradually increase the z height from the
+     * normal layer height to the height of the next layer over each polygon
+     * printed.
+     * \param flow_ratio The ratio with which to multiply the extrusion amount.
+     * \param always_retract Whether to force a retraction when moving to the
+     * start of the polygon (used for outer walls).
+     * \param reverse_order Adds polygons in reverse order.
+     * \param scarf_seam Indicates whether we may use a scarf seam for the path
+     * \param smooth_speed Indicates whether we may use a speed gradient for the path
+     */
+    void addPolygonsInGivenOrder(
+        const std::vector<PathOrdering<const Polygon*>>& polygons,
+        const GCodePathConfig& config,
+        const Settings& settings,
+        const ZSeamConfig& z_seam_config = ZSeamConfig(),
+        coord_t wall_0_wipe_dist = 0,
+        bool spiralize = false,
+        const Ratio flow_ratio = 1.0_r,
+        bool always_retract = false,
+        bool reverse_order = false,
+        bool scarf_seam = false,
+        bool smooth_speed = false);
 
     /*!
      *  @brief Send a GCodePath line to the communication object, applying proper Z offsets
@@ -1150,6 +1219,16 @@ class LayerPlan : public NoCopy
         const std::optional<TravelAntiOozing>& priming_amounts,
         const Velocity& speed,
         const size_t point_index);
+
+    /*!
+     * Generates an extrusion move that goes as inwards as possible given a skeletized contour, starting from the given point
+     * @param trapezoidal_edges The edges of the skeletal trapezoidation for the contour
+     * @param start_point The point to start generating the move from
+     * @param move_inwards_length The length of the move to be generated
+     * @return Extrusion path to be started from the given start point, going further inwards. It may be empty if not possible or if the start point is
+     *         already inwards the contour enough.
+     */
+    static OpenPolyline makeInwardsMove(const std::list<STHalfEdge>& trapezoidal_edges, const Point2LL& start_point, const coord_t move_inwards_length);
 };
 
 } // namespace cura

include/SkeletalTrapezoidationGraph.h

@@ -33,8 +33,10 @@ class STHalfEdge : public HalfEdge<SkeletalTrapezoidationJoint, SkeletalTrapezoi
     /*!
      * Check whether the edge goes from a lower to a higher distance_to_boundary.
      * Effectively deals with equidistant edges by looking beyond this edge.
+     *
+     * \param strict Whether equidistant edges can count as going upwards
      */
-    bool isUpward() const;
+    bool isUpward(const bool strict = false) const;
 
     /*!
      * Calculate the traversed distance until we meet an upward edge.

include/geometry/ClosedPolyline.h

@@ -15,37 +15,37 @@ class OpenPolyline;
  *  @sa https://github.com/Ultimaker/CuraEngine/wiki/Geometric-Base-Types#closedpolyline
  *
  *  The path may be closed:
- *    * Explicitely, which means the last point is at the same position as the first point.
+ *    * Explicitly, which means the last point is at the same position as the first point.
  *      In this case, in order to iterate over the segments, you just have to iterate over
  *      the actual points.
- *    * Implicitely, which means the last and first point are at different positions. In this
+ *    * Implicitly, which means the last and first point are at different positions. In this
  *      case, to iterate over the segments, you have to consider an additional segment
  *      between the last and first point
  *
  *  The difference is made because it is easier to iterate over segments when the path is
- *  explicitely closed, but ClipperLib uses implicitely closed paths. It is also a bit healthier
- *  to use implicitely closed because there is no risk that the first and last point become different
+ *  explicitly closed, but ClipperLib uses implicitly closed paths. It is also a bit healthier
+ *  to use implicitly closed because there is no risk that the first and last point become different
  */
 class ClosedPolyline : public Polyline
 {
 private:
-    bool explicitely_closed_{ false };
+    bool explicitly_closed_{ false };
 
 public:
     /*!
      * \brief Builds an empty closed polyline
-     * \warning By default, the line is tagged as non explicitely closed. We need this default
+     * \warning By default, the line is tagged as non explicitly closed. We need this default
      *          constructor in various places, but be careful that the interpretation of the points
      *          added later will depend on this.
      */
     ClosedPolyline() = default;
 
     /*!
      * \brief Builds an empty closed polyline
-     * \param explicitely_closed Indicates whether the line will be explicitely closed
+     * \param explicitly_closed Indicates whether the line will be explicitly closed
      */
-    explicit ClosedPolyline(const bool explicitely_closed)
-        : explicitely_closed_{ explicitely_closed }
+    explicit ClosedPolyline(const bool explicitly_closed)
+        : explicitly_closed_{ explicitly_closed }
     {
     }
 
@@ -57,31 +57,31 @@ class ClosedPolyline : public Polyline
 
     /*!
      * \brief Constructor with a points initializer list, provided for convenience
-     * \param explicitely_closed Specify whether the given points form an explicitely closed line
+     * \param explicitly_closed Specify whether the given points form an explicitly closed line
      */
-    ClosedPolyline(const std::initializer_list<Point2LL>& initializer, bool explicitely_closed)
+    ClosedPolyline(const std::initializer_list<Point2LL>& initializer, bool explicitly_closed)
         : Polyline{ initializer }
-        , explicitely_closed_{ explicitely_closed }
+        , explicitly_closed_{ explicitly_closed }
     {
     }
 
     /*!
      * \brief Constructor with an existing list of points
-     * \param explicitely_closed Specify whether the given points form an explicitely closed line
+     * \param explicitly_closed Specify whether the given points form an explicitly closed line
      */
-    explicit ClosedPolyline(const ClipperLib::Path& points, bool explicitely_closed)
+    explicit ClosedPolyline(const ClipperLib::Path& points, bool explicitly_closed)
         : Polyline{ points }
-        , explicitely_closed_{ explicitely_closed }
+        , explicitly_closed_{ explicitly_closed }
     {
     }
 
     /*!
      * \brief Constructor that takes ownership of the given list of points
-     * \param explicitely_closed Specify whether the given points form an explicitely closed line
+     * \param explicitly_closed Specify whether the given points form an explicitly closed line
      */
-    explicit ClosedPolyline(ClipperLib::Path&& points, bool explicitely_closed)
+    explicit ClosedPolyline(ClipperLib::Path&& points, bool explicitly_closed)
         : Polyline{ std::move(points) }
-        , explicitely_closed_{ explicitely_closed }
+        , explicitly_closed_{ explicitly_closed }
     {
     }
 
@@ -90,7 +90,7 @@ class ClosedPolyline : public Polyline
     /*! @see Polyline::hasClosingSegment() */
     [[nodiscard]] bool hasClosingSegment() const override
     {
-        return ! explicitely_closed_;
+        return ! explicitly_closed_;
     }
 
     /*! @see Polyline::addClosingSegment() */
@@ -103,19 +103,19 @@ class ClosedPolyline : public Polyline
 
     ClosedPolyline& operator=(ClosedPolyline&& other) = default;
 
-    [[nodiscard]] bool isExplicitelyClosed() const
+    [[nodiscard]] bool isExplicitlyClosed() const
     {
-        return explicitely_closed_;
+        return explicitly_closed_;
     }
 
     /*!
-     * \brief Sets whether the points set is to be treated as explicitely or implicitely closed
+     * \brief Sets whether the points set is to be treated as explicitly or implicitly closed
      * \warning This does not actually changes the points set, only the interpretation of it will
      *          change. So use this method only if you really know what you are doing.
      */
-    void setExplicitelyClosed(bool explicitely_closed)
+    void setExplicitlyClosed(bool explicitly_closed)
     {
-        explicitely_closed_ = explicitely_closed;
+        explicitly_closed_ = explicitly_closed;
     }
 
     /*!
@@ -136,6 +136,9 @@ class ClosedPolyline : public Polyline
      * \return An open polyline instance, with the end point at the same position of the start point
      */
     [[nodiscard]] OpenPolyline toPseudoOpenPolyline() const;
+
+    /*! Shifts the points of the line so that it will now start at the point with the given index */
+    void shiftVerticesToStartPoint(const size_t start_index);
 };
 
 } // namespace cura