Merge remote-tracking branch 'origin/5.9'

Author: wawanbreton

include/ExtruderPlan.h

@@ -124,6 +124,11 @@ class ExtruderPlan
      */
     void applyBackPressureCompensation(const Ratio back_pressure_compensation);
 
+    /*!
+     * Gets the mesh being printed first on this plan
+     */
+    std::shared_ptr<const SliceMeshStorage> findFirstPrintedMesh() const;
+
 private:
     LayerIndex layer_nr_{ 0 }; //!< The layer number at which we are currently printing.
     bool is_initial_layer_{ false }; //!< Whether this extruder plan is printed on the very first layer (which might be raft)

include/LayerPlan.h

@@ -761,6 +761,11 @@ class LayerPlan : public NoCopy
      */
     void applyGradualFlow();
 
+    /*!
+     * Gets the mesh being printed first on this layer
+     */
+    std::shared_ptr<const SliceMeshStorage> findFirstPrintedMesh() const;
+
 private:
     /*!
      * \brief Compute the preferred or minimum combing boundary
@@ -881,9 +886,10 @@ class LayerPlan : public NoCopy
      * \param compute_distance_to_bridge_start Whether we should compute the distance to start of bridge. This is
      *                                         possible only if PathType is ExtrusionLine and will be ignored otherwise.
      * \param func_add_segment The function to be called to actually add an extrusion segment with the given parameters
+     * \return The index of the last traversed point, and the final position with the scarf seam
      */
     template<class PathType>
-    void addSplitWall(
+    std::tuple<size_t, Point2LL> addSplitWall(
         const PathAdapter<PathType>& wall,
         const coord_t wall_length,
         const size_t start_idx,
@@ -926,9 +932,10 @@ class LayerPlan : public NoCopy
      * \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
      * \param func_add_segment The function to be called to actually add an extrusion segment with the given parameters
+     * \return The index of the last traversed point, and the final position with the scarf seam
      */
     template<class PathType>
-    void addWallWithScarfSeam(
+    std::tuple<size_t, Point2LL> addWallWithScarfSeam(
         const PathAdapter<PathType>& wall,
         size_t start_idx,
         const Settings& settings,
@@ -942,6 +949,18 @@ class LayerPlan : public NoCopy
         const bool smooth_speed,
         const AddExtrusionSegmentFunction& func_add_segment);
 
+    /*!
+     * \brief Add a wipe travel after the given path has been extruded
+     * \tparam PathType The type of path to be processed, either ExtrusionLine or some subclass of Polyline
+     * \param path The path that has just been extruded
+     * \param wipe_distance The length of the wipe move to be added
+     * \param backwards Indicates if the path has been processed backwards
+     * \param start_index The index of the point where o start printing the path
+     * \param last_path_position The actual last position of the extruder, which may be slightly forwards on the last printed segment
+     */
+    template<class PathType>
+    void addWipeTravel(const PathAdapter<PathType>& path, const coord_t wipe_distance, const bool backwards, const size_t start_index, const Point2LL& last_path_position);
+
     /*!
      * Pre-calculates the coasting to be applied on the paths
      *

include/PathOrderOptimizer.h

@@ -740,7 +740,10 @@ class PathOrderOptimizer
 
         if (path.force_start_index_.has_value()) // Actually handles EZSeamType::USER_SPECIFIED
         {
-            main_criterion.criterion = std::make_shared<DistanceScoringCriterion>(points, points.at(path.force_start_index_.value()));
+            // Use a much smaller distance divider because we want points around the forced points to be filtered out very easily
+            constexpr double distance_divider = 1.0;
+            constexpr auto distance_type = DistanceScoringCriterion::DistanceType::Euclidian;
+            main_criterion.criterion = std::make_shared<DistanceScoringCriterion>(points, points.at(path.force_start_index_.value()), distance_type, distance_divider);
         }
         else
         {

include/TreeSupportSettings.h

@@ -39,7 +39,7 @@ struct TreeSupportSettings
         , maximum_move_distance((angle < TAU / 4) ? std::llround(tan(angle) * layer_height) : std::numeric_limits<coord_t>::max())
         , maximum_move_distance_slow((angle_slow < TAU / 4) ? std::llround(tan(angle_slow) * layer_height) : std::numeric_limits<coord_t>::max())
         , support_bottom_layers(mesh_group_settings.get<bool>("support_bottom_enable") ? round_divide(mesh_group_settings.get<coord_t>("support_bottom_height"), layer_height) : 0)
-        , tip_layers(std::max((branch_radius - min_radius) / (support_line_width / 3), branch_radius / layer_height))
+        , tip_layers(std::max(std::max((branch_radius - min_radius) / (support_line_width / 3), branch_radius / layer_height), 1LL))
         , // Ensure lines always stack nicely even if layer height is large
         diameter_angle_scale_factor(sin(mesh_group_settings.get<AngleRadians>("support_tree_branch_diameter_angle")) * layer_height / branch_radius)
         , max_to_model_radius_increase(mesh_group_settings.get<coord_t>("support_tree_max_diameter_increase_by_merges_when_support_to_model") / 2)

include/skin.h

@@ -135,14 +135,9 @@ class SkinInfillAreaComputation
     void generateRoofingFillAndSkinFill(SliceLayerPart& part);
 
     /*!
-     * Remove the areas which are directly under air in the top-most surface and directly above air in bottom-most
-     * surfaces from the \ref SkinPart::inner_infill and save them in the \ref SkinPart::bottom_most_surface_fill and
-     * \ref SkinPart::top_most_surface_fill (respectively) of the \p part.
-     *
-     * \param[in,out] part Where to get the SkinParts to get the outline info from and to store the top and bottom-most
-     * infill areas
+     * Generate the top and bottom-most surfaces of the given \p part, i.e. the surfaces that have nothing above or below
      */
-    void generateTopAndBottomMostSkinFill(SliceLayerPart& part);
+    void generateTopAndBottomMostSurfaces(SliceLayerPart& part);
 
     /*!
      * Helper function to calculate and return the areas which are 'directly' under air.

include/sliceDataStorage.h

@@ -45,8 +45,6 @@ class SkinPart
                          //!< roofing and non-roofing.
     Shape skin_fill; //!< The part of the skin which is not roofing.
     Shape roofing_fill; //!< The inner infill which has air directly above
-    Shape top_most_surface_fill; //!< The inner infill of the uppermost top layer which has air directly above.
-    Shape bottom_most_surface_fill; //!< The inner infill of the bottommost bottom layer which has air directly below.
 };
 
 /*!
@@ -69,6 +67,8 @@ class SliceLayerPart
     std::vector<SkinPart> skin_parts; //!< The skin parts which are filled for 100% with lines and/or insets.
     std::vector<VariableWidthLines> wall_toolpaths; //!< toolpaths for walls, will replace(?) the insets. Binned by inset_idx.
     std::vector<VariableWidthLines> infill_wall_toolpaths; //!< toolpaths for the walls of the infill areas. Binned by inset_idx.
+    Shape top_most_surface; //!< Sub-part of the outline containing the area that is not covered by something above
+    Shape bottom_most_surface; //!< Sub-part of the outline containing the area that has nothing below
 
     /*!
      * The areas inside of the mesh.

include/utils/scoring/DistanceScoringCriterion.h

@@ -30,8 +30,18 @@ class DistanceScoringCriterion : public ScoringCriterion
     const Point2LL& target_pos_;
     const DistanceType distance_type_;
 
+    /*!
+     * Fixed divider for shortest distances computation. The divider should be set so that the minimum encountered
+     * distance gives a score very close to 1.0, and a medium-far distance gives a score close to 0.5
+     */
+    const double distance_divider_;
+
 public:
-    explicit DistanceScoringCriterion(const PointsSet& points, const Point2LL& target_pos, DistanceType distance_type = DistanceType::Euclidian);
+    explicit DistanceScoringCriterion(
+        const PointsSet& points,
+        const Point2LL& target_pos,
+        DistanceType distance_type = DistanceType::Euclidian,
+        const double distance_divider = 20.0);
 
     virtual double computeScore(const size_t candidate_index) const override;
 };

src/ExtruderPlan.cpp

@@ -70,4 +70,18 @@ void ExtruderPlan::applyBackPressureCompensation(const Ratio back_pressure_compe
         path.speed_back_pressure_factor = std::max(epsilon_speed_factor, 1.0 + (nominal_width_for_path / line_width_for_path - 1.0) * back_pressure_compensation);
     }
 }
+
+std::shared_ptr<const SliceMeshStorage> ExtruderPlan::findFirstPrintedMesh() const
+{
+    for (const GCodePath& path : paths_)
+    {
+        if (path.mesh)
+        {
+            return path.mesh;
+        }
+    }
+
+    return nullptr;
+}
+
 } // namespace cura