Merge remote-tracking branch 'origin/CURA-12833_improve-bridge-lines-direction' into CURA-12361_add-skin-support

Author: wawanbreton

include/FffGcodeWriter.h

@@ -592,6 +592,7 @@ class FffGcodeWriter : public NoCopy
      * minimise travel moves (``false``).
      * \param[out] added_something Whether this function added anything to the layer plan
      * \param fan_speed fan speed override for this skin area
+     * \param forced_small_area_width A specific value to be used for small_area_width when generating the infill, or nullopt to use the normal value
      */
     void processSkinPrintFeature(
         const SliceDataStorage& storage,
@@ -607,7 +608,8 @@ class FffGcodeWriter : public NoCopy
         const LinesOrderingMethod ordering,
         const bool is_roofing_flooring,
         bool& added_something,
-        double fan_speed = GCodePathConfig::FAN_SPEED_DEFAULT) const;
+        double fan_speed = GCodePathConfig::FAN_SPEED_DEFAULT,
+        std::optional<coord_t> forced_small_area_width = std::nullopt) const;
 
     /*!
      *  see if we can avoid printing a lines or zig zag style skin part in multiple segments by moving to

src/FffGcodeWriter.cpp

@@ -3235,6 +3235,7 @@ void FffGcodeWriter::processTopBottom(
     const bool bridge_enable_more_layers = bridge_settings_enabled && mesh.settings.get<bool>("bridge_enable_more_layers");
     const Ratio support_threshold = bridge_settings_enabled ? mesh.settings.get<Ratio>("bridge_skin_support_threshold") : 0.0_r;
     const size_t bottom_layers = mesh.settings.get<size_t>("bottom_layers");
+    std::optional<coord_t> forced_small_area_width;
 
     // if support is enabled, consider the support outlines so we don't generate bridges over support
 
@@ -3292,6 +3293,7 @@ void FffGcodeWriter::processTopBottom(
                     break;
                 }
             }
+            forced_small_area_width = 0;
             pattern = EFillMethod::LINES; // force lines pattern when bridging
             if (bridge_settings_enabled)
             {
@@ -3391,7 +3393,8 @@ void FffGcodeWriter::processTopBottom(
         ordering,
         is_roofing_flooring,
         added_something,
-        fan_speed);
+        fan_speed,
+        forced_small_area_width);
 }
 
 void FffGcodeWriter::processSkinPrintFeature(
@@ -3408,7 +3411,8 @@ void FffGcodeWriter::processSkinPrintFeature(
     const LinesOrderingMethod ordering,
     const bool is_roofing_flooring,
     bool& added_something,
-    double fan_speed) const
+    double fan_speed,
+    std::optional<coord_t> forced_small_area_width) const
 {
     Shape skin_polygons;
     OpenLinesSet skin_lines;
@@ -3431,7 +3435,8 @@ void FffGcodeWriter::processSkinPrintFeature(
     constexpr coord_t pocket_size = 0;
     const bool small_areas_on_surface = mesh.settings.get<bool>("small_skin_on_surface");
     const coord_t line_width = config.getLineWidth();
-    const coord_t small_area_width = (small_areas_on_surface || ! is_roofing_flooring) ? mesh.settings.get<coord_t>("small_skin_width") : line_width / 4;
+    const coord_t small_area_width
+        = forced_small_area_width.value_or((small_areas_on_surface || ! is_roofing_flooring) ? mesh.settings.get<coord_t>("small_skin_width") : line_width / 4);
     const auto& current_layer = mesh.layers[gcode_layer.getLayerNr()];
     const auto& exposed_to_air = current_layer.top_surface.areas.unionPolygons(current_layer.bottom_surface);
 

src/bridge/bridge.cpp

@@ -61,8 +61,8 @@ std::vector<coord_t> shapeLineIntersections(const coord_t line_y, const Transfor
  *
  * The score is based on the following criteria:
  *   - Properly bridging segments, i.e. between two supported areas, add their length to the score
- *   - Hanging segments, i.e. supported on one side but not the other (or not at all), subtract their length to the score
- *   - Segments that lie on a supported area are not accounted for  */
+ *   - Hanging segments, i.e. supported on one side but not the other (or not at all), subtract their length from the score
+ *   - Segments that lie on a supported area substract part of their length from the score  */
 coord_t evaluateBridgeLine(const coord_t line_y, const TransformedShape& transformed_skin_area, const TransformedShape& transformed_supported_area)
 {
     // Calculate intersections with skin outline to see which segments should actually be printed
@@ -154,8 +154,7 @@ coord_t evaluateBridgeLine(const coord_t line_y, const TransformedShape& transfo
 
         const bool leaving_skin = next_intersection_is_skin_area && ! next_inside_skin_area;
         const bool reaching_supported = next_intersection_is_supported_area && next_inside_supported_area;
-        bool add_bridging_segment = false;
-        bool add_hanging_segment = false;
+        double add_segment_score_weight = 0.0;
 
         switch (bridge_status)
         {
@@ -165,31 +164,33 @@ coord_t evaluateBridgeLine(const coord_t line_y, const TransformedShape& transfo
 
         case BridgeStatus::Supported:
             bridge_status = leaving_skin ? BridgeStatus::Outside : BridgeStatus::Anchored;
+            // Negatively account for fully supported lines to avoid lonely line parts over the supported areas
+            add_segment_score_weight = -0.1;
             break;
 
         case BridgeStatus::Hanging:
-            add_hanging_segment = true;
+            add_segment_score_weight = -1.0;
             bridge_status = reaching_supported ? BridgeStatus::Supported : BridgeStatus::Outside;
             break;
 
         case BridgeStatus::Anchored:
             if (reaching_supported)
             {
-                add_bridging_segment = true;
+                add_segment_score_weight = 1.0;
                 bridge_status = BridgeStatus::Supported;
             }
             else if (leaving_skin)
             {
-                add_hanging_segment = true;
+                add_segment_score_weight = -1.0;
                 bridge_status = BridgeStatus::Outside;
             }
             break;
         }
 
-        if (add_bridging_segment || add_hanging_segment)
+        if (add_segment_score_weight != 0.0)
         {
             const coord_t segment_length = next_intersection - last_position;
-            segment_score += add_bridging_segment ? segment_length : -segment_length;
+            segment_score += std::llrint(segment_length * add_segment_score_weight);
         }
 
         last_position = next_intersection;