Better tree support for pointy overhangs: Cradle Generation

CMakeLists.txt

@@ -165,6 +165,7 @@ set(engine_SRCS # Except main.cpp.
         src/geometry/Polyline.cpp
         src/geometry/ClosedPolyline.cpp
         src/geometry/MixedLinesSet.cpp
+        src/TreeSupportCradle.cpp
 )
 
 add_library(_CuraEngine STATIC ${engine_SRCS} ${engine_PB_SRCS})

include/FffGcodeWriter.h

@@ -11,6 +11,7 @@
 #include "FanSpeedLayerTime.h"
 #include "GCodePathConfig.h"
 #include "LayerPlanBuffer.h"
+#include "SupportInfillPart.h"
 #include "gcodeExport.h"
 #include "utils/LayerVector.h"
 #include "utils/NoCopy.h"
@@ -635,12 +636,11 @@ class FffGcodeWriter : public NoCopy
      * layer.
      *
      * \param[in] storage Where the slice data is stored.
-     * \param[in] support_roof_outlines which polygons to generate roofs for.
-     * \param[in] current_roof_config config to be used.
+     * \param[in] support_roof_outlines Collection of polygons to generate roofs for.
      * \param gcodeLayer The initial planning of the g-code of the layer.
      * \return Whether any support skin was added to the layer plan.
      */
-    bool addSupportRoofsToGCode(const SliceDataStorage& storage, const Shape& support_roof_outlines, const GCodePathConfig& current_roof_config, LayerPlan& gcode_layer) const;
+    bool addSupportRoofsToGCode(const SliceDataStorage& storage, const std::vector<SupportInfillPart>& support_roof_outlines, LayerPlan& gcode_layer) const;
 
     /*!
      * Add the support bottoms to the layer plan \p gcodeLayer of the current

include/PathOrderOptimizer.h

@@ -205,7 +205,7 @@ class PathOrderOptimizer
 
         // For some Z seam types the start position can be pre-computed.
         // This is faster since we don't need to re-compute the start position at each step then.
-        precompute_start &= seam_config_.type_ == EZSeamType::RANDOM || seam_config_.type_ == EZSeamType::USER_SPECIFIED || seam_config_.type_ == EZSeamType::SHARPEST_CORNER;
+        precompute_start &= seam_config_.type_ == EZSeamType::RANDOM || seam_config_.type_ == EZSeamType::USER_SPECIFIED || seam_config_.type_ == EZSeamType::INTERNAL_SPECIFIED || seam_config_.type_ == EZSeamType::SHARPEST_CORNER;
         if (precompute_start)
         {
             for (auto& path : paths_)
@@ -584,7 +584,7 @@ class PathOrderOptimizer
             }
 
             const bool precompute_start
-                = seam_config_.type_ == EZSeamType::RANDOM || seam_config_.type_ == EZSeamType::USER_SPECIFIED || seam_config_.type_ == EZSeamType::SHARPEST_CORNER;
+                = seam_config_.type_ == EZSeamType::RANDOM || seam_config_.type_ == EZSeamType::USER_SPECIFIED || seam_config_.type_ == EZSeamType::INTERNAL_SPECIFIED ||seam_config_.type_ == EZSeamType::SHARPEST_CORNER;
             if (! path->is_closed_ || ! precompute_start) // Find the start location unless we've already precomputed it.
             {
                 path->start_vertex_ = findStartLocation(*path, start_position);
@@ -676,6 +676,14 @@ class PathOrderOptimizer
     {
         if (! path.is_closed_)
         {
+            if (seam_config_.type_ == EZSeamType::INTERNAL_SPECIFIED)
+            {
+                if(getDirectDistance(path.converted_->back(), seam_config_.pos_) < getDirectDistance(path.converted_->front(), seam_config_.pos_))
+                {
+                    return path.converted_->size() - 1; // Back end is closer.
+                }
+                return 0;
+            }
             // For polylines, the seam settings are not applicable. Simply choose the position closest to target_pos then.
             const coord_t back_distance
                 = (combing_boundary_ == nullptr) ? getDirectDistance(path.converted_->back(), target_pos) : getCombingDistance(path.converted_->back(), target_pos);

include/SupportInfillPart.h

@@ -4,10 +4,12 @@
 #ifndef SUPPORT_INFILL_PART_H
 #define SUPPORT_INFILL_PART_H
 
+#include <optional>
 #include <vector>
 
 #include "geometry/Polygon.h"
 #include "geometry/SingleShape.h"
+#include "settings/EnumSettings.h"
 #include "utils/AABB.h"
 #include "utils/ExtrusionLine.h"
 
@@ -36,8 +38,17 @@ class SupportInfillPart
 
     coord_t custom_line_distance_; //!< The distance between support infill lines. 0 means use the default line distance instead.
     bool use_fractional_config_; //!< Request to use the configuration used to fill a partial layer height here, instead of the normal full layer height configuration.
+    EFillMethod custom_line_pattern_;
+    std::optional<Point2LL> start_near_location;
 
-    SupportInfillPart(const SingleShape& outline, coord_t support_line_width, bool use_fractional_config, int inset_count_to_generate = 0, coord_t custom_line_distance = 0);
+    SupportInfillPart(const SingleShape& outline,
+                      coord_t support_line_width,
+                      bool use_fractional_config,
+                      int inset_count_to_generate = 0,
+                      coord_t custom_line_distance = 0,
+                      EFillMethod custom_line_pattern = EFillMethod::NONE,
+                      std::optional<Point2LL> start_near_location = std::optional<Point2LL>()
+                      );
 
     const Shape& getInfillArea() const;
 };

include/TreeModelVolumes.h

@@ -10,6 +10,7 @@
 #include <unordered_map>
 #include <unordered_set>
 
+#include "TreeSupportEnums.h"
 #include "TreeSupportEnums.h"
 #include "geometry/Shape.h"
 #include "settings/EnumSettings.h" //To store whether X/Y or Z distance gets priority.
@@ -40,6 +41,7 @@ class TreeModelVolumes
         coord_t max_move,
         coord_t max_move_slow,
         coord_t min_offset_per_step,
+        const coord_t min_radius,
         size_t current_mesh_idx,
         double progress_multiplier,
         double progress_offset,
@@ -50,14 +52,15 @@ class TreeModelVolumes
     TreeModelVolumes(const TreeModelVolumes&) = delete;
     TreeModelVolumes& operator=(const TreeModelVolumes&) = delete;
 
+
     /*!
      * \brief Precalculate avoidances and collisions up to this layer.
      *
      * This uses knowledge about branch angle to only calculate avoidances and collisions that could actually be needed.
      * Not calling this will cause the class to lazily calculate avoidances and collisions as needed, which will be a lot slower on systems with more then one or two cores!
      *
      */
-    void precalculate(coord_t max_layer);
+    void precalculate(LayerIndex max_layer);
 
     /*!
      * \brief Provides the areas that have to be avoided by the tree's branches to prevent collision with the model on this layer.
@@ -129,6 +132,7 @@ class TreeModelVolumes
      */
     const Shape& getWallRestriction(coord_t radius, LayerIndex layer_idx, bool min_xy_dist);
 
+
     /*!
      * \brief Round \p radius upwards to either a multiple of radius_sample_resolution_ or a exponentially increasing value
      *
@@ -143,12 +147,46 @@ class TreeModelVolumes
     /*!
      * \brief Round \p radius upwards to the maximum that would still round up to the same value as the provided one.
      *
-     * \param radius The radius of the node of interest
+     * \param radius The radius of the element of interest
      * \param min_xy_dist is the minimum xy distance used.
      * \return The maximum radius, resulting in the same rounding.
      */
     coord_t getRadiusNextCeil(coord_t radius, bool min_xy_dist) const;
 
+    LayerIndex getFirstAntiPreferredLayerIdx();
+
+    /*!
+     * \brief Provide hints which areas should be avoided in the future.
+     * \param area The area that should be avoided in the future.
+     * \param layer_idx The layer said area is on.
+     */
+    void addAreaToAntiPreferred(const Shape area, LayerIndex layer_idx);
+
+    void precalculateAntiPreferred();
+
+    /*!
+     * \brief Get areas that were additionally set to be avoided
+     * \param layer_idx The layer said area is on.
+     * \param radius The radius of the node of interest.
+     * \returns The area that should be avoided
+     */
+    const Shape& getAntiPreferredAreas(LayerIndex layer_idx, coord_t radius);
+
+    /*!
+     * \brief Get avoidance areas for areas that were additionally set to be avoided
+     * \param layer_idx The layer said area is on.
+     * \param radius The radius of the node of interest.
+     * \returns The area that should be avoided
+     */
+    const Shape& getAntiPreferredAvoidance(coord_t radius, LayerIndex layer_idx, AvoidanceType type, bool to_model, bool min_xy_dist);
+
+    /*!
+     * \brief Get areas that were are classified as support blocker
+     * \param layer_idx The layer said area is on.
+     * \returns The area should not contain support
+     */
+    const Shape& getSupportBlocker(LayerIndex layer_idx);
+
 
 private:
     /*!
@@ -309,6 +347,17 @@ class TreeModelVolumes
         calculateAvoidanceToModel(std::deque<RadiusLayerPair>{ RadiusLayerPair(key) });
     }
 
+    /*!
+     * \brief Creates the areas that have to be avoided by the tree's branches to prevent collision with the model with radius 0 from the smallest actual avoidance.
+     * This is done as a real 0 radius avoidance would not be able to be printed. These 0 radius avoidances are used for calculating roof and cradle.
+     *
+     * The result is a 2D area that would cause nodes of radius 0 to
+     * collide with the model in a not wanted way. Result is saved in the cache.
+     * \param max_layer The result will be calculated up to the this layer.
+     */
+    void calculateFake0Avoidances(const LayerIndex max_layer);
+
+
     /*!
      * \brief Creates the areas that can not be passed when expanding an area downwards. As such these areas are an somewhat abstract representation of a wall (as in a printed
      * object).
@@ -463,6 +512,18 @@ class TreeModelVolumes
      */
     RestPreference support_rest_preference_;
 
+    /*!
+     * \brief Largest DTT a cradle supporting tip may have.
+     */
+    size_t max_cradle_dtt = 0;
+
+    LayerIndex first_anti_preferred_layer_idx_ = 0;
+
+    /*!
+     * \brief radii for which avoidance was already precalculated. Used to calculate anti preferred avoidance.
+     */
+    std::deque<RadiusLayerPair> precalculated_avoidance_radii;
+
     /*!
      * \brief Caches for the collision, avoidance and areas on the model where support can be placed safely
      * at given radius and layer indices.
@@ -520,9 +581,45 @@ class TreeModelVolumes
     mutable std::unordered_map<RadiusLayerPair, Shape> wall_restrictions_cache_min_;
     std::unique_ptr<std::mutex> critical_wall_restrictions_cache_min_ = std::make_unique<std::mutex>();
 
+    mutable std::unordered_map<RadiusLayerPair, Shape> anti_preferred_;
+    std::unique_ptr<std::mutex> critical_anti_preferred_ = std::make_unique<std::mutex>();
+
+    mutable std::unordered_map<RadiusLayerPair, Shape> anti_preferred_cache_;
+    mutable std::unordered_map<RadiusLayerPair, Shape> anti_preferred_cache_to_model_;
+    mutable std::unordered_map<RadiusLayerPair, Shape> anti_preferred_cache_collision;
+    std::unique_ptr<std::mutex> critical_anti_preferred_caches = std::make_unique<std::mutex>();
+
+    enum class CalculationType
+    {
+        AVOIDANCE,
+        AVOIDANCE_0,
+        AVOIDANCE_TO_MODEL,
+        AVOIDANCE_COLLISION,
+        COLLISION,
+        COLLISION_HOLEFREE,
+        PLACEABLE,
+        PLACEABLE_ACCUMULATED,
+        WALL_RESTRICTION
+    };
+    std::unique_ptr<std::mutex> critical_calculation_request_ = std::make_unique<std::mutex>();
+    std::unordered_map<std::pair<coord_t, CalculationType>, std::shared_ptr<std::mutex>> critical_calculation_map_;
+
+    std::shared_ptr<std::mutex> getLockForCalculation(coord_t radius, CalculationType type)
+    {
+        std::lock_guard<std::mutex> critical_section(*critical_calculation_request_);
+        std::pair<coord_t, CalculationType> key(radius, type);
+        if (! critical_calculation_map_.contains(key))
+        {
+            critical_calculation_map_[key] = std::make_shared<std::mutex>();
+        }
+        return critical_calculation_map_[key];
+    }
+
     std::unique_ptr<std::mutex> critical_progress_ = std::make_unique<std::mutex>();
 
     Simplify simplifier_ = Simplify(0, 0, 0); // a simplifier to simplify polygons. Will be properly initialised in the constructor.
+
+    Shape empty_polygon = Shape();
 };
 
 } // namespace cura