CURA-12992 Fix slicing crashes (#2301)

Author: HellAholic

include/WallToolPaths.h

@@ -102,9 +102,9 @@ class WallToolPaths
      *
      * Works on both toolpaths and inner contours simultaneously.
      *
-     * \param settings The settings as provided by the user
+     * \param stitch_distance The stitch distance to be used
      */
-    static void stitchToolPaths(std::vector<VariableWidthLines>& toolpaths, const Settings& settings);
+    static void stitchToolPaths(std::vector<VariableWidthLines>& toolpaths, const coord_t stitch_distance);
 
     /*!
      * Remove polylines shorter than half the smallest line width along that polyline, if that polyline isn't part of an outer wall.
@@ -128,8 +128,16 @@ class WallToolPaths
     bool print_thin_walls_; //<! Whether to enable the widening beading meta-strategy for thin features
     coord_t min_feature_size_; //<! The minimum size of the features that can be widened by the widening beading meta-strategy. Features thinner than that will not be printed
     coord_t min_bead_width_; //<! The minimum bead size to use when widening thin model features with the widening beading meta-strategy
-    double small_area_length_; //<! The length of the small features which are to be filtered out, this is squared into a surface
-    coord_t transition_length_; //<! The transitioning length when the amount of extrusion lines changes
+    const AngleRadians wall_transition_angle_;
+    const coord_t wall_transition_length_;
+    const double min_even_wall_line_width_;
+    const double wall_line_width_0_;
+    const double min_odd_wall_line_width_;
+    const double wall_line_width_x_;
+    const int wall_distribution_count_;
+    const coord_t wall_transition_filter_distance_;
+    const coord_t wall_transition_filter_deviation_;
+    const coord_t stitch_distance_;
     bool toolpaths_generated_; //<! Are the toolpaths generated
     std::vector<VariableWidthLines> toolpaths_; //<! The generated toolpaths binned by inset_idx.
     Shape inner_contour_; //<! The inner contour of the generated toolpaths

include/arachne/SkeletalTrapezoidation.h

@@ -20,6 +20,7 @@
 #include "utils/ExtrusionJunction.h"
 #include "utils/ExtrusionLine.h"
 #include "utils/PolygonsSegmentIndex.h"
+#include "utils/VoronoiUtils.h"
 #include "utils/section_type.h"
 
 namespace cura
@@ -46,8 +47,8 @@ deposition modeling" by Kuipers et al.
  */
 class SkeletalTrapezoidation
 {
-    using pos_t = double;
-    using vd_t = boost::polygon::voronoi_diagram<pos_t>;
+    using pos_t = VoronoiUtils::voronoi_data_t;
+    using vd_t = VoronoiUtils::vd_t;
     using graph_t = SkeletalTrapezoidationGraph;
     using edge_t = STHalfEdge;
     using node_t = STHalfEdgeNode;
@@ -248,7 +249,8 @@ class SkeletalTrapezoidation
         vd_t::edge_type*& starting_vd_edge,
         vd_t::edge_type*& ending_vd_edge,
         const std::vector<Point2LL>& points,
-        const std::vector<Segment>& segments);
+        const std::vector<Segment>& segments,
+        const Shape& polys);
 
     /*!
      * Compute the range of line segments that surround a cell of the skeletal

include/arachne/SkeletalTrapezoidationEdge.h

@@ -123,9 +123,9 @@ class SkeletalTrapezoidationEdge
     {
         extrusion_junctions_ = storage;
     }
-    std::shared_ptr<LineJunctions> getExtrusionJunctions()
+    std::shared_ptr<LineJunctions> getExtrusionJunctions() const
     {
-        return extrusion_junctions_.lock();
+        return const_cast<SkeletalTrapezoidationEdge*>(this)->extrusion_junctions_.lock();
     }
 
     Central is_central; //! whether the edge is significant; whether the source segments have a sharp angle; -1 is unknown

include/infill.h

@@ -384,6 +384,7 @@ class Infill
         Shape& result_polygons,
         OpenLinesSet& result_lines,
         const Settings& settings,
+        const int layer_idx,
         const std::shared_ptr<SierpinskiFillProvider>& cross_fill_pattern,
         const std::shared_ptr<LightningLayer>& lightning_layer,
         const SliceMeshStorage* mesh,
@@ -398,6 +399,7 @@ class Infill
         Shape& result_polygons,
         OpenLinesSet& result_lines,
         const Settings& settings,
+        const int layer_idx,
         const std::shared_ptr<SierpinskiFillProvider>& cross_fill_pattern,
         const std::shared_ptr<LightningLayer>& lightning_layer,
         const SliceMeshStorage* mesh);
@@ -446,10 +448,11 @@ class Infill
     /*!
      * Generate sparse concentric infill
      *
-     * \param toolpaths (output) The resulting toolpaths. Binned by inset_idx.
-     * \param inset_value The offset between each consecutive two polygons
+     * \param[out] toolpaths The resulting toolpaths. Binned by inset_idx.
+     * \param settings The settings to be used for processing
+     * \param layer_idx The current layer index
      */
-    void generateConcentricInfill(const Shape& outline, std::vector<VariableWidthLines>& toolpaths, const Settings& settings);
+    void generateConcentricInfill(const Shape& outline, std::vector<VariableWidthLines>& toolpaths, const Settings& settings, const int layer_idx);
 
     /*!
      * Generate a rectangular grid of infill lines

include/utils/SVG.h

@@ -21,6 +21,7 @@ class Point2D;
 class MixedLinesSet;
 class SkeletalTrapezoidationGraph;
 class STHalfEdge;
+class STHalfEdgeNode;
 
 class SVG : NoCopy
 {
@@ -144,6 +145,10 @@ class SVG : NoCopy
 
         ~LineAttributes() override = default;
 
+        static LineAttributes hidden()
+        {
+            return LineAttributes(ColorObject(), 0.0);
+        }
         bool isDisplayed() const override
         {
             return ElementAttributes::isDisplayed() && width > 0.0;
@@ -158,6 +163,14 @@ class SVG : NoCopy
 
         VerticesAttributes() = default;
 
+        VerticesAttributes(const ColorObject& color, const double radius, const bool write_coords, const double font_size)
+            : ElementAttributes(color)
+            , radius(radius)
+            , write_coords(write_coords)
+            , font_size(font_size)
+        {
+        }
+
         VerticesAttributes(const ColorObject& color, const double radius)
             : ElementAttributes(color)
             , radius(radius)
@@ -183,6 +196,11 @@ class SVG : NoCopy
 
         ~VerticesAttributes() override = default;
 
+        static VerticesAttributes hidden()
+        {
+            return VerticesAttributes(SVG::ColorObject(), 0.0);
+        }
+
         bool isDisplayed() const override
         {
             return ElementAttributes::isDisplayed() && (radius > 0.0 || (write_coords && font_size > 0.0));
@@ -196,6 +214,33 @@ class SVG : NoCopy
         VerticesAttributes vertices{ ColorObject(), 0.0 };
     };
 
+    struct DiagramVisualAttributes : VisualAttributes
+    {
+        bool edges_arrows{ true };
+
+        DiagramVisualAttributes(const VisualAttributes& visual_attributes, const bool edges_arrows = true)
+            : VisualAttributes(visual_attributes)
+            , edges_arrows(edges_arrows)
+        {
+        }
+    };
+
+    struct STVisualAttributes : DiagramVisualAttributes
+    {
+        VerticesAttributes beads_count;
+        VerticesAttributes junctions;
+
+        STVisualAttributes(
+            const DiagramVisualAttributes& diagram_attributes,
+            const VerticesAttributes& beads_count = VerticesAttributes::hidden(),
+            const VerticesAttributes& junctions = VerticesAttributes::hidden())
+            : DiagramVisualAttributes(diagram_attributes)
+            , beads_count(beads_count)
+            , junctions(junctions)
+        {
+        }
+    };
+
 private:
     static std::string toString(const ColorObject& color);
     static std::string toString(const std::vector<int>& dash_array);
@@ -260,18 +305,18 @@ class SVG : NoCopy
 
     void write(const std::string& text, const Point2LL& p, const VerticesAttributes& vertices_attributes, const bool flush = true) const;
 
-    void write(const SkeletalTrapezoidationGraph& graph, const VisualAttributes& visual_attributes, const bool flush = true) const;
+    void write(const SkeletalTrapezoidationGraph& graph, const STVisualAttributes& visual_attributes, const bool flush = true) const;
 
-    void write(const STHalfEdge& edge, const VisualAttributes& visual_attributes, const bool flush = true) const;
+    void write(const STHalfEdge& edge, const STVisualAttributes& visual_attributes, const bool flush = true, const std::set<const STHalfEdgeNode*>& drawn_nodes = {}) const;
 
     template<typename T>
-    void write(const boost::polygon::voronoi_diagram<T>& voronoi_diagram, const VisualAttributes& visual_attributes, const bool flush = true) const;
+    void write(const boost::polygon::voronoi_diagram<T>& voronoi_diagram, const DiagramVisualAttributes& visual_attributes, const bool flush = true) const;
 
     template<typename T>
-    void write(const boost::polygon::voronoi_edge<T>& edge, const VisualAttributes& visual_attributes, const bool flush = true) const;
+    void write(const boost::polygon::voronoi_edge<T>& edge, const DiagramVisualAttributes& visual_attributes, const bool flush = true) const;
 
     template<typename T>
-    void write(const boost::polygon::voronoi_cell<T>& cell, const VisualAttributes& visual_attributes, const bool flush = true) const;
+    void write(const boost::polygon::voronoi_cell<T>& cell, const DiagramVisualAttributes& visual_attributes, const bool flush = true) const;
 
     void writeArrow(const Point2LL& a, const Point2LL& b, const ColorObject color = Color::BLACK, const double stroke_width = 1.0, const double head_size = 5.0) const;
 

include/utils/VoronoiUtils.h

@@ -12,6 +12,27 @@
 #include "PolygonsSegmentIndex.h"
 
 
+namespace boost::polygon
+{
+template<>
+struct voronoi_diagram_traits<cura::coord_t>
+{
+    typedef cura::coord_t coordinate_type;
+    typedef voronoi_cell<coordinate_type> cell_type;
+    typedef voronoi_vertex<coordinate_type> vertex_type;
+    typedef voronoi_edge<coordinate_type> edge_type;
+
+    class vertex_equality_predicate_type
+    {
+    public:
+        bool operator()(const vertex_type& v1, const vertex_type& v2) const
+        {
+            return v1.x() == v2.x() && v1.y() == v2.y();
+        }
+    };
+};
+} // namespace boost::polygon
+
 namespace cura
 {
 
@@ -21,7 +42,7 @@ class VoronoiUtils
 {
 public:
     using Segment = PolygonsSegmentIndex;
-    using voronoi_data_t = double;
+    using voronoi_data_t = coord_t;
     using vd_t = boost::polygon::voronoi_diagram<voronoi_data_t>;
 
     static Point2LL getSourcePoint(const vd_t::cell_type& cell, const std::vector<Point2LL>& points, const std::vector<Segment>& segments);
@@ -30,9 +51,9 @@ class VoronoiUtils
 
     static Point2LL p(const vd_t::vertex_type* node);
 
-    static bool isSourcePoint(Point2LL p, const vd_t::cell_type& cell, const std::vector<Point2LL>& points, const std::vector<Segment>& segments, coord_t snap_dist = 10);
+    static bool isSourcePoint(const Point2LL& p, const vd_t::cell_type& cell, const std::vector<Point2LL>& points, const std::vector<Segment>& segments, coord_t snap_dist = 10);
 
-    static coord_t getDistance(Point2LL p, const vd_t::cell_type& cell, const std::vector<Point2LL>& points, const std::vector<Segment>& segments);
+    static coord_t getDistance(const Point2LL& p, const vd_t::cell_type& cell, const std::vector<Point2LL>& points, const std::vector<Segment>& segments);
 
     /*!
      * Discretize a parabola based on (approximate) step size.

src/TreeModelVolumes.cpp

@@ -902,15 +902,17 @@ void TreeModelVolumes::calculateCollisionAvoidance(const std::deque<RadiusLayerP
 // defined by the collision when offsetting to fast.
 Shape TreeModelVolumes::safeOffset(const Shape& me, coord_t distance, ClipperLib::JoinType jt, coord_t max_safe_step_distance, const Shape& collision) const
 {
-    const size_t steps = std::abs(distance / std::max(min_offset_per_step_, std::abs(max_safe_step_distance)));
-    assert(distance * max_safe_step_distance >= 0);
+    assert(distance * max_safe_step_distance >= 0); // Make sure they are the same sign (or one of them is null)
+    const uint8_t offset_sign = sign(distance);
+    const coord_t step_distance = offset_sign * std::max(min_offset_per_step_, std::abs(max_safe_step_distance));
+    const size_t steps = std::abs(distance / step_distance);
     Shape ret = me;
 
     for (size_t i = 0; i < steps; ++i)
     {
-        ret = ret.offset(max_safe_step_distance, jt).unionPolygons(collision);
+        ret = ret.offset(step_distance, jt).unionPolygons(collision);
     }
-    ret = ret.offset(distance % max_safe_step_distance, jt);
+    ret = ret.offset(distance % step_distance, jt);
 
     return ret.unionPolygons(collision);
 }

src/WallToolPaths.cpp

@@ -36,9 +36,18 @@ WallToolPaths::WallToolPaths(
     , inset_count_(inset_count)
     , wall_0_inset_(wall_0_inset)
     , print_thin_walls_(settings.get<bool>("fill_outline_gaps"))
-    , min_feature_size_(settings.get<coord_t>("min_feature_size"))
-    , min_bead_width_(settings.get<coord_t>("min_bead_width"))
-    , small_area_length_(INT2MM(static_cast<double>(nominal_bead_width) / 2))
+    , min_feature_size_(nominal_bead_width / 4)
+    , min_bead_width_(std::min(min_even_wall_line_width_, min_odd_wall_line_width_))
+    , wall_transition_angle_(AngleDegrees(10))
+    , wall_transition_length_(nominal_bead_width)
+    , min_even_wall_line_width_(std::llrint(nominal_bead_width * 0.85))
+    , wall_line_width_0_(nominal_bead_width)
+    , min_odd_wall_line_width_(min_even_wall_line_width_)
+    , wall_line_width_x_(nominal_bead_width)
+    , wall_distribution_count_(1)
+    , wall_transition_filter_distance_(MM2INT(100))
+    , wall_transition_filter_deviation_(nominal_bead_width / 4)
+    , stitch_distance_(nominal_bead_width - 1)
     , toolpaths_generated_(false)
     , settings_(settings)
     , layer_idx_(layer_idx)
@@ -63,7 +72,16 @@ WallToolPaths::WallToolPaths(
     , print_thin_walls_(settings.get<bool>("fill_outline_gaps"))
     , min_feature_size_(settings.get<coord_t>("min_feature_size"))
     , min_bead_width_(settings.get<coord_t>("min_bead_width"))
-    , small_area_length_(INT2MM(static_cast<double>(bead_width_0) / 2))
+    , wall_transition_angle_(settings.get<AngleRadians>("wall_transition_angle"))
+    , wall_transition_length_(settings.get<coord_t>("wall_transition_length"))
+    , min_even_wall_line_width_(settings.get<double>("min_even_wall_line_width"))
+    , wall_line_width_0_(settings.get<double>("wall_line_width_0"))
+    , min_odd_wall_line_width_(settings.get<double>("min_odd_wall_line_width"))
+    , wall_line_width_x_(settings.get<double>("wall_line_width_x"))
+    , wall_distribution_count_(settings.get<int>("wall_distribution_count"))
+    , wall_transition_filter_distance_(settings.get<coord_t>("wall_transition_filter_distance"))
+    , wall_transition_filter_deviation_(settings.get<coord_t>("wall_transition_filter_deviation"))
+    , stitch_distance_(settings.get<coord_t>("wall_line_width_x") - 1) // In 0-width contours, junctions can cause up to 1-line-width gaps. Don't stitch more than 1 line width.
     , toolpaths_generated_(false)
     , settings_(settings)
     , layer_idx_(layer_idx)
@@ -80,45 +98,37 @@ const std::vector<VariableWidthLines>& WallToolPaths::generate()
         return toolpaths_;
     }
 
-    const auto transitioning_angle = settings_.get<AngleRadians>("wall_transition_angle");
+
     constexpr coord_t discretization_step_size = MM2INT(0.8);
-    const coord_t wall_transition_length = settings_.get<coord_t>("wall_transition_length");
 
     // When to split the middle wall into two:
-    const double min_even_wall_line_width = settings_.get<double>("min_even_wall_line_width");
-    const double wall_line_width_0 = settings_.get<double>("wall_line_width_0");
-    const Ratio wall_split_middle_threshold = std::max(1.0, std::min(99.0, 100.0 * (2.0 * min_even_wall_line_width - wall_line_width_0) / wall_line_width_0)) / 100.0;
+    const Ratio wall_split_middle_threshold = std::max(1.0, std::min(99.0, 100.0 * (2.0 * min_even_wall_line_width_ - wall_line_width_0_) / wall_line_width_0_)) / 100.0;
 
     // When to add a new middle in between the innermost two walls:
-    const double min_odd_wall_line_width = settings_.get<double>("min_odd_wall_line_width");
-    const double wall_line_width_x = settings_.get<double>("wall_line_width_x");
-    const Ratio wall_add_middle_threshold = std::max(1.0, std::min(99.0, 100.0 * min_odd_wall_line_width / wall_line_width_x)) / 100.0;
+    const Ratio wall_add_middle_threshold = std::max(1.0, std::min(99.0, 100.0 * min_odd_wall_line_width_ / wall_line_width_x_)) / 100.0;
 
-    const int wall_distribution_count = settings_.get<int>("wall_distribution_count");
     const size_t max_bead_count = (inset_count_ < std::numeric_limits<size_t>::max() / 2) ? 2 * inset_count_ : std::numeric_limits<size_t>::max();
     const auto beading_strat = BeadingStrategyFactory::makeStrategy(
         bead_width_0_,
         bead_width_x_,
-        wall_transition_length,
-        transitioning_angle,
+        wall_transition_length_,
+        wall_transition_angle_,
         print_thin_walls_,
         min_bead_width_,
         min_feature_size_,
         wall_split_middle_threshold,
         wall_add_middle_threshold,
         max_bead_count,
         wall_0_inset_,
-        wall_distribution_count);
-    const auto transition_filter_dist = settings_.get<coord_t>("wall_transition_filter_distance");
-    const auto allowed_filter_deviation = settings_.get<coord_t>("wall_transition_filter_deviation");
+        wall_distribution_count_);
     SkeletalTrapezoidation wall_maker(
         prepared_outline,
         *beading_strat,
         beading_strat->getTransitioningAngle(),
         discretization_step_size,
-        transition_filter_dist,
-        allowed_filter_deviation,
-        wall_transition_length,
+        wall_transition_filter_distance_,
+        wall_transition_filter_deviation_,
+        wall_transition_length_,
         layer_idx_,
         section_type_);
     wall_maker.generateToolpaths(toolpaths_);
@@ -133,7 +143,7 @@ const std::vector<VariableWidthLines>& WallToolPaths::generate()
         scripta::PointVDI{ "width", &ExtrusionJunction::w_ },
         scripta::PointVDI{ "perimeter_index", &ExtrusionJunction::perimeter_index_ });
 
-    stitchToolPaths(toolpaths_, settings_);
+    stitchToolPaths(toolpaths_, stitch_distance_);
     scripta::log(
         "toolpaths_1",
         toolpaths_,
@@ -206,11 +216,8 @@ const std::vector<VariableWidthLines>& WallToolPaths::generate()
 }
 
 
-void WallToolPaths::stitchToolPaths(std::vector<VariableWidthLines>& toolpaths, const Settings& settings)
+void WallToolPaths::stitchToolPaths(std::vector<VariableWidthLines>& toolpaths, const coord_t stitch_distance)
 {
-    const coord_t stitch_distance
-        = settings.get<coord_t>("wall_line_width_x") - 1; // In 0-width contours, junctions can cause up to 1-line-width gaps. Don't stitch more than 1 line width.
-
     for (unsigned int wall_idx = 0; wall_idx < toolpaths.size(); wall_idx++)
     {
         VariableWidthLines& wall_lines = toolpaths[wall_idx];