Generate multiple overhang areas for different speeds

wawanbreton · wawanbreton · commit 20090e8a5a4b · 2024-12-10T15:24:44.000+01:00
CURA-11966
diff --git a/include/LayerPlan.h b/include/LayerPlan.h
@@ -60,6 +60,12 @@ class LayerPlan : public NoCopy
 #endif
 
 public:
+    struct OverhangMask
+    {
+        Shape mask;
+        Ratio speed_ratio;
+    };
+
     const PathConfigStorage configs_storage_; //!< The line configs for this layer for each feature type
     const coord_t z_;
     coord_t final_travel_z_;
@@ -115,7 +121,8 @@ class LayerPlan : public NoCopy
     Comb* comb_;
     coord_t comb_move_inside_distance_; //!< Whenever using the minimum boundary for combing it tries to move the coordinates inside by this distance after calculating the combing.
     Shape bridge_wall_mask_; //!< The regions of a layer part that are not supported, used for bridging
-    Shape overhang_mask_; //!< The regions of a layer part where the walls overhang
+    std::vector<OverhangMask>
+        overhang_masks_; //!< The regions of a layer part where the walls overhang, calculated for multiple overhang angles. The latter is the most overhanging.
     Shape seam_overhang_mask_; //!< The regions of a layer part where the walls overhang, specifically as defined for the seam
     Shape roofing_mask_; //!< The regions of a layer part where the walls are exposed to the air
 
@@ -295,11 +302,11 @@ class LayerPlan : public NoCopy
     void setBridgeWallMask(const Shape& polys);
 
     /*!
-     * Set overhang_mask.
+     * Set overhang_masks.
      *
-     * \param polys The overhung areas of the part currently being processed that will require modified print settings
+     * \param masks The overhung areas of the part currently being processed that will require modified print settings
      */
-    void setOverhangMask(const Shape& polys);
+    void setOverhangMasks(const std::vector<OverhangMask>& masks);
 
     /*!
      * Set seam_overhang_mask.
diff --git a/src/FffGcodeWriter.cpp b/src/FffGcodeWriter.cpp
@@ -3082,18 +3082,33 @@ bool FffGcodeWriter::processInsets(
 
         const auto get_overhang_region = [&](const AngleDegrees overhang_angle) -> Shape
         {
-            if (overhang_angle >= 90)
-            {
-                return Shape(); // keep empty to disable overhang detection
-            }
             // the overhang mask is set to the area of the current part's outline minus the region that is considered to be supported
             // the supported region is made up of those areas that really are supported by either model or support on the layer below
             // expanded to take into account the overhang angle, the greater the overhang angle, the larger the supported area is
             // considered to be
             const coord_t overhang_width = layer_height * std::tan(overhang_angle / (180 / std::numbers::pi));
             return part.outline.offset(-half_outer_wall_width).difference(outlines_below.offset(10 + overhang_width - half_outer_wall_width)).offset(10);
         };
-        gcode_layer.setOverhangMask(get_overhang_region(mesh.settings.get<AngleDegrees>("wall_overhang_angle")));
+
+        // Build overhang masks for all the overhang speeds
+        std::vector<LayerPlan::OverhangMask> overhang_masks;
+        const auto overhang_speed_factors = mesh.settings.get<std::vector<Ratio>>("wall_overhang_speed_factors");
+        const size_t overhang_angles_count = overhang_speed_factors.size();
+        if (overhang_angles_count > 0)
+        {
+            const auto wall_overhang_angle = mesh.settings.get<AngleDegrees>("wall_overhang_angle");
+            if (wall_overhang_angle < 90.0)
+            {
+                const AngleDegrees overhang_step = (90.0 - wall_overhang_angle) / static_cast<double>(overhang_angles_count);
+                for (size_t angle_index = 0; angle_index < overhang_angles_count; ++angle_index)
+                {
+                    const AngleDegrees actual_wall_overhang_angle = wall_overhang_angle + static_cast<double>(angle_index) * overhang_step;
+                    overhang_masks.emplace_back(get_overhang_region(actual_wall_overhang_angle), overhang_speed_factors[angle_index]);
+                }
+            }
+        }
+        gcode_layer.setOverhangMasks(overhang_masks);
+
         gcode_layer.setSeamOverhangMask(get_overhang_region(mesh.settings.get<AngleDegrees>("seam_overhang_angle")));
 
         const auto roofing_mask_fn = [&]() -> Shape
@@ -3125,7 +3140,7 @@ bool FffGcodeWriter::processInsets(
         // clear to disable use of bridging settings
         gcode_layer.setBridgeWallMask(Shape());
         // clear to disable overhang detection
-        gcode_layer.setOverhangMask(Shape());
+        gcode_layer.setOverhangMasks({});
         // clear to disable overhang detection
         gcode_layer.setSeamOverhangMask(Shape());
         // clear to disable use of roofing settings
diff --git a/src/LayerPlan.cpp b/src/LayerPlan.cpp
@@ -57,14 +57,15 @@ GCodePath* LayerPlan::getLatestPathWithConfig(
     {
         return &paths.back();
     }
-    paths.emplace_back(GCodePath{ .z_offset = z_offset,
-                                  .config = config,
-                                  .mesh = current_mesh_,
-                                  .space_fill_type = space_fill_type,
-                                  .flow = flow,
-                                  .width_factor = width_factor,
-                                  .spiralize = spiralize,
-                                  .speed_factor = speed_factor });
+    paths.emplace_back(
+        GCodePath{ .z_offset = z_offset,
+                   .config = config,
+                   .mesh = current_mesh_,
+                   .space_fill_type = space_fill_type,
+                   .flow = flow,
+                   .width_factor = width_factor,
+                   .spiralize = spiralize,
+                   .speed_factor = speed_factor });
 
     GCodePath* ret = &paths.back();
     ret->skip_agressive_merge_hint = mode_skip_agressive_merge_;
@@ -724,14 +725,15 @@ void LayerPlan::addWallLine(
     double distance_to_bridge_start,
     const bool travel_to_z)
 {
-    const coord_t min_line_len = 5; // we ignore lines less than 5um long
-    const double acceleration_segment_len = MM2INT(1); // accelerate using segments of this length
-    const double acceleration_factor = 0.75; // must be < 1, the larger the value, the slower the acceleration
-    const bool spiralize = false;
+    constexpr coord_t min_line_len = 5; // we ignore lines less than 5um long
+    constexpr double acceleration_segment_len = MM2INT(1); // accelerate using segments of this length
+    constexpr double acceleration_factor = 0.75; // must be < 1, the larger the value, the slower the acceleration
+    constexpr bool spiralize = false;
 
     const coord_t min_bridge_line_len = settings.get<coord_t>("bridge_wall_min_length");
     const Ratio bridge_wall_coast = settings.get<Ratio>("bridge_wall_coast");
     const Ratio overhang_speed_factor = settings.get<Ratio>("wall_overhang_speed_factor");
+    const auto overhang_speed_factors = settings.get<std::vector<int>>("wall_overhang_speed_factors");
 
     Point3LL cur_point = p0;
 
@@ -1322,7 +1324,7 @@ std::vector<LayerPlan::PathCoasting>
 
         for (const auto& reversed_chunk : paths | ranges::views::enumerate | ranges::views::reverse
                                               | ranges::views::chunk_by(
-                                                  [](const auto&path_a, const auto&path_b)
+                                                  [](const auto& path_a, const auto& path_b)
                                                   {
                                                       return (! std::get<1>(path_a).isTravelPath()) || std::get<1>(path_b).isTravelPath();
                                                   }))
@@ -1948,9 +1950,11 @@ void LayerPlan::addLinesInGivenOrder(
 
 bool LayerPlan::segmentIsOnOverhang(const Point3LL& p0, const Point3LL& p1) const
 {
-    const OpenPolyline segment{ p0.toPoint2LL(), p1.toPoint2LL() };
-    const OpenLinesSet intersected_lines = overhang_mask_.intersection(OpenLinesSet{ segment });
-    return ! intersected_lines.empty() && (static_cast<double>(intersected_lines.length()) / segment.length()) > 0.5;
+    // const OpenPolyline segment{ p0.toPoint2LL(), p1.toPoint2LL() };
+    // const OpenLinesSet intersected_lines = overhang_mask_.intersection(OpenLinesSet{ segment });
+    // return ! intersected_lines.empty() && (static_cast<double>(intersected_lines.length()) / segment.length()) > 0.5;
+
+    return false;
 }
 
 void LayerPlan::sendLineTo(const GCodePath& path, const Point3LL& position, const double extrude_speed)
@@ -3154,9 +3158,9 @@ void LayerPlan::setBridgeWallMask(const Shape& polys)
     bridge_wall_mask_ = polys;
 }
 
-void LayerPlan::setOverhangMask(const Shape& polys)
+void LayerPlan::setOverhangMasks(const std::vector<OverhangMask>& masks)
 {
-    overhang_mask_ = polys;
+    overhang_masks_ = masks;
 }
 
 void LayerPlan::setSeamOverhangMask(const Shape& polys)
diff --git a/src/settings/Settings.cpp b/src/settings/Settings.cpp
@@ -183,7 +183,7 @@ Acceleration Settings::get<Acceleration>(const std::string& key) const
 template<>
 Ratio Settings::get<Ratio>(const std::string& key) const
 {
-    return get<double>(key) / 100.0; // The settings are all in percentages, but we need to interpret them as radians.
+    return get<double>(key) / 100.0; // The settings are all in percentages, but we need to interpret them as ratios.
 }
 
 template<>
@@ -787,6 +787,22 @@ std::vector<double> Settings::get<std::vector<double>>(const std::string& key) c
     return result;
 }
 
+template<>
+std::vector<Ratio> Settings::get<std::vector<Ratio>>(const std::string& key) const
+{
+    auto values_double = get<std::vector<double>>(key);
+
+    // The settings are all in percentages, but we need to interpret them as ratios.
+    std::vector<Ratio> result;
+    result.reserve(values_double.size());
+    for (const auto& value_double : values_double)
+    {
+        result.emplace_back(value_double / 100.0);
+    }
+
+    return result;
+}
+
 template<>
 std::vector<int> Settings::get<std::vector<int>>(const std::string& key) const
 {
