Slic3r::Arachne::WallToolPaths Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Arachne/WallToolPaths.hpp>

Collaboration diagram for Slic3r::Arachne::WallToolPaths:

Public Types
using	ExtrusionLineSet = ankerl::unordered_dense::set<std::pair<const ExtrusionLine *, const ExtrusionLine *>, boost::hash<std::pair<const ExtrusionLine *, const ExtrusionLine *>>>

Public Member Functions
	WallToolPaths (const Polygons &outline, coord_t bead_width_0, coord_t bead_width_x, size_t inset_count, coord_t wall_0_inset, coordf_t layer_height, const WallToolPathsParams &params)
const std::vector< VariableWidthLines > &	generate ()
const std::vector< VariableWidthLines > &	getToolPaths ()
void	separateOutInnerContour ()
const Polygons &	getInnerContour ()

Static Public Member Functions
static bool	removeEmptyToolPaths (std::vector< VariableWidthLines > &toolpaths)
static ExtrusionLineSet	getRegionOrder (const std::vector< ExtrusionLine * > &input, bool outer_to_inner)

Protected Member Functions
void	removeSmallLines (std::vector< VariableWidthLines > &toolpaths)

Static Protected Member Functions
static void	stitchToolPaths (std::vector< VariableWidthLines > &toolpaths, coord_t bead_width_x)
static void	simplifyToolPaths (std::vector< VariableWidthLines > &toolpaths, const WallToolPathsParams &params)

Private Attributes
const Polygons &	outline
coord_t	bead_width_0
coord_t	bead_width_x
size_t	inset_count
coord_t	wall_0_inset
coordf_t	layer_height
bool	print_thin_walls
coord_t	min_feature_size
coord_t	min_bead_width
double	small_area_length
coord_t	wall_transition_filter_deviation
	The allowed line width deviation induced by filtering.
bool	toolpaths_generated
std::vector< VariableWidthLines >	toolpaths
Polygons	inner_contour
const WallToolPathsParams	m_params

Detailed Description

Member Typedef Documentation

ExtrusionLineSet

using Slic3r::Arachne::WallToolPaths::ExtrusionLineSet = ankerl::unordered_dense::set<std::pair<const ExtrusionLine *, const ExtrusionLine *>, boost::hash<std::pair<const ExtrusionLine *, const ExtrusionLine *>>>

Constructor & Destructor Documentation

WallToolPaths()

Slic3r::Arachne::WallToolPaths::WallToolPaths	(	const Polygons &	outline,
		coord_t	bead_width_0,
		coord_t	bead_width_x,
		size_t	inset_count,
		coord_t	wall_0_inset,
		coordf_t	layer_height,
		const WallToolPathsParams &	params )

A class that creates the toolpaths given an outline, nominal bead width and maximum amount of walls

Parameters

outline	An outline of the area in which the ToolPaths are to be generated
bead_width_0	The bead width of the first wall used in the generation of the toolpaths
bead_width_x	The bead width of the inner walls used in the generation of the toolpaths
inset_count	The maximum number of parallel extrusion lines that make up the wall
wall_0_inset	How far to inset the outer wall, to make it adhere better to other walls.

    : outline(outline)
    , bead_width_0(bead_width_0)
    , bead_width_x(bead_width_x)
    , inset_count(inset_count)
    , wall_0_inset(wall_0_inset)
    , layer_height(layer_height)
    , print_thin_walls(Slic3r::Arachne::fill_outline_gaps)
    , min_feature_size(scaled<coord_t>(params.min_feature_size))
    , min_bead_width(scaled<coord_t>(params.min_bead_width))
    , small_area_length(static_cast<double>(bead_width_0) / 2.)
    , wall_transition_filter_deviation(scaled<coord_t>(params.wall_transition_filter_deviation))
    , toolpaths_generated(false)
    , m_params(params)
{
}

References bead_width_0, bead_width_x, Slic3r::Arachne::fill_outline_gaps, inset_count, layer_height, m_params, min_bead_width, min_feature_size, outline, print_thin_walls, Slic3r::scaled(), small_area_length, toolpaths_generated, wall_0_inset, and wall_transition_filter_deviation.

Here is the call graph for this function:

Member Function Documentation

generate()

const std::vector< VariableWidthLines > & Slic3r::Arachne::WallToolPaths::generate

(

)

Generates the Toolpaths

Returns

A reference to the newly create ToolPaths

{
    if (this->inset_count < 1)
        return toolpaths;
 
    const coord_t smallest_segment = m_params.wall_maximum_resolution;
    const coord_t allowed_distance = m_params.wall_maximum_deviation;
    const coord_t epsilon_offset = (allowed_distance / 2) - 1;
    const double  transitioning_angle = Geometry::deg2rad(m_params.wall_transition_angle);
    const coord_t discretization_step_size = scaled<coord_t>(0.8);
 
    // Simplify outline for boost::voronoi consumption. Absolutely no self intersections or near-self intersections allowed:
    // TODO: Open question: Does this indeed fix all (or all-but-one-in-a-million) cases for manifold but otherwise possibly complex polygons?
    Polygons prepared_outline = offset(offset(offset(outline, -epsilon_offset), epsilon_offset * 2), -epsilon_offset);
    simplify(prepared_outline, smallest_segment, allowed_distance);
    fixSelfIntersections(epsilon_offset, prepared_outline);
    removeDegenerateVerts(prepared_outline);
    removeColinearEdges(prepared_outline, 0.005);
    // Removing collinear edges may introduce self intersections, so we need to fix them again
    fixSelfIntersections(epsilon_offset, prepared_outline);
    removeDegenerateVerts(prepared_outline);
    removeSmallAreas(prepared_outline, small_area_length * small_area_length, false);
 
    // The functions above could produce intersecting polygons that could cause a crash inside Arachne.
    // Applying Clipper union should be enough to get rid of this issue.
    // Clipper union also fixed an issue in Arachne that in post-processing Voronoi diagram, some edges
    // didn't have twin edges. (a non-planar Voronoi diagram probably caused this).
    prepared_outline = union_(prepared_outline);
 
    if (area(prepared_outline) <= 0) {
        assert(toolpaths.empty());
        return toolpaths;
    }
 
    const float external_perimeter_extrusion_width = Flow::rounded_rectangle_extrusion_width_from_spacing(unscale<float>(bead_width_0), float(this->layer_height));
    const float perimeter_extrusion_width          = Flow::rounded_rectangle_extrusion_width_from_spacing(unscale<float>(bead_width_x), float(this->layer_height));
 
    const coord_t wall_transition_length = scaled<coord_t>(this->m_params.wall_transition_length);
  
  const double wall_split_middle_threshold = std::clamp(2. * unscaled<double>(this->min_bead_width) / external_perimeter_extrusion_width - 1., 0.01, 0.99); // For an uneven nr. of lines: When to split the middle wall into two.
    const double wall_add_middle_threshold   = std::clamp(unscaled<double>(this->min_bead_width) / perimeter_extrusion_width, 0.01, 0.99); // For an even nr. of lines: When to add a new middle in between the innermost two walls.
    
    const int wall_distribution_count = this->m_params.wall_distribution_count;
    const size_t max_bead_count = (inset_count < std::numeric_limits<coord_t>::max() / 2) ? 2 * inset_count : std::numeric_limits<coord_t>::max();
    const auto beading_strat = BeadingStrategyFactory::makeStrategy
        (
            bead_width_0,
            bead_width_x,
            wall_transition_length,
            transitioning_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 coord_t transition_filter_dist   = scaled<coord_t>(100.f);
    const coord_t allowed_filter_deviation = wall_transition_filter_deviation;
    SkeletalTrapezoidation wall_maker
    (
        prepared_outline,
        *beading_strat,
        beading_strat->getTransitioningAngle(),
        discretization_step_size,
        transition_filter_dist,
        allowed_filter_deviation,
        wall_transition_length
    );
    wall_maker.generateToolpaths(toolpaths);
 
    stitchToolPaths(toolpaths, this->bead_width_x);
 
    removeSmallLines(toolpaths);
 
    separateOutInnerContour();
 
    simplifyToolPaths(toolpaths, m_params);
 
    removeEmptyToolPaths(toolpaths);
    assert(std::is_sorted(toolpaths.cbegin(), toolpaths.cend(),
                          [](const VariableWidthLines& l, const VariableWidthLines& r)
                          {
                              return l.front().inset_idx < r.front().inset_idx;
                          }) && "WallToolPaths should be sorted from the outer 0th to inner_walls");
    toolpaths_generated = true;
    return toolpaths;
}

References Slic3r::area(), bead_width_0, bead_width_x, Slic3r::Geometry::deg2rad(), Slic3r::Arachne::fixSelfIntersections(), Slic3r::Arachne::SkeletalTrapezoidation::generateToolpaths(), inset_count, layer_height, m_params, Slic3r::Arachne::BeadingStrategyFactory::makeStrategy(), min_bead_width, min_feature_size, Slic3r::offset(), outline, print_thin_walls, Slic3r::Arachne::removeColinearEdges(), Slic3r::Arachne::removeDegenerateVerts(), removeEmptyToolPaths(), Slic3r::Arachne::removeSmallAreas(), removeSmallLines(), Slic3r::Flow::rounded_rectangle_extrusion_width_from_spacing(), Slic3r::scaled(), separateOutInnerContour(), Slic3r::Arachne::simplify(), simplifyToolPaths(), small_area_length, stitchToolPaths(), toolpaths, toolpaths_generated, Slic3r::union_(), Slic3r::unscale(), Slic3r::unscaled(), wall_0_inset, and wall_transition_filter_deviation.

Referenced by getInnerContour(), and getToolPaths().

Here is the call graph for this function:

Here is the caller graph for this function:

getInnerContour()

const Polygons & Slic3r::Arachne::WallToolPaths::getInnerContour

(

)

Gets the inner contour of the area which is inside of the generated tool paths.

If the walls haven't been generated yet, this will lazily call the generate() function to generate the walls with variable width. The resulting polygon will snugly match the inside of the variable-width walls where the walls get limited by the LimitedBeadingStrategy to a maximum wall count. If there are no walls, the outline will be returned.

Returns

The inner contour of the generated walls.

{
    if (!toolpaths_generated && inset_count > 0)
    {
        generate();
    }
    else if(inset_count == 0)
    {
        return outline;
    }
    return inner_contour;
}

References generate(), inner_contour, inset_count, outline, and toolpaths_generated.

Here is the call graph for this function:

getRegionOrder()

WallToolPaths::ExtrusionLineSet Slic3r::Arachne::WallToolPaths::getRegionOrder ( const std::vector< ExtrusionLine * > & input, bool outer_to_inner )

static

Get the order constraints of the insets when printing walls per region / hole. Each returned pair consists of adjacent wall lines where the left has an inset_idx one lower than the right.

Odd walls should always go after their enclosing wall polygons.

Parameters

outer_to_inner

Whether the wall polygons with a lower inset_idx should go before those with a higher one.

Get the order constraints of the insets when printing walls per region / hole. Each returned pair consists of adjacent wall lines where the left has an inset_idx one lower than the right.

Odd walls follow the same order as even ones, so that the centre line of a narrow wall is an inner wall like any other when printing inner to outer.

Parameters

outer_to_inner

Whether the wall polygons with a lower inset_idx should go before those with a higher one.

{
    ExtrusionLineSet order_requirements;
    // We build a grid where we map toolpath vertex locations to toolpaths,
    // so that we can easily find which two toolpaths are next to each other,
    // which is the requirement for there to be an order constraint.
    //
    // We use a PointGrid rather than a LineGrid to save on computation time.
    // In very rare cases two insets might lie next to each other without having neighboring vertices, e.g.
    //  \            .
    //   |  /        .
    //   | /         .
    //   ||          .
    //   | \         .
    //   |  \        .
    //  /            .
    // However, because of how Arachne works this will likely never be the case for two consecutive insets.
    // On the other hand one could imagine that two consecutive insets of a very large circle
    // could be simplify()ed such that the remaining vertices of the two insets don't align.
    // In those cases the order requirement is not captured,
    // which means that the PathOrderOptimizer *might* result in a violation of the user set path order.
    // This problem is expected to be not so severe and happen very sparsely.
 
    coord_t max_line_w = 0u;
    for (const ExtrusionLine *line : input) // compute max_line_w
        for (const ExtrusionJunction &junction : *line)
            max_line_w = std::max(max_line_w, junction.w);
    if (max_line_w == 0u)
        return order_requirements;
 
    struct LineLoc
    {
        ExtrusionJunction    j;
        const ExtrusionLine *line;
    };
    struct Locator
    {
        Point operator()(const LineLoc &elem) { return elem.j.p; }
    };
 
    // How much farther two verts may be apart due to corners.
    // This distance must be smaller than 2, because otherwise
    // we could create an order requirement between e.g.
    // wall 2 of one region and wall 3 of another region,
    // while another wall 3 of the first region would lie in between those two walls.
    // However, higher values are better against the limitations of using a PointGrid rather than a LineGrid.
    constexpr float diagonal_extension = 1.9f;
    const auto      searching_radius   = coord_t(max_line_w * diagonal_extension);
    using GridT                        = SparsePointGrid<LineLoc, Locator>;
    GridT grid(searching_radius);
 
    for (const ExtrusionLine *line : input)
        for (const ExtrusionJunction &junction : *line) grid.insert(LineLoc{junction, line});
    for (const std::pair<const SquareGrid::GridPoint, LineLoc> &pair : grid) {
        const LineLoc       &lineloc_here = pair.second;
        const ExtrusionLine *here         = lineloc_here.line;
        Point                loc_here     = pair.second.j.p;
        std::vector<LineLoc> nearby_verts = grid.getNearby(loc_here, searching_radius);
        for (const LineLoc &lineloc_nearby : nearby_verts) {
            const ExtrusionLine *nearby = lineloc_nearby.line;
            if (nearby == here)
                continue;
            if (nearby->inset_idx == here->inset_idx)
                continue;
            if (nearby->inset_idx > here->inset_idx + 1)
                continue; // not directly adjacent
            if (here->inset_idx > nearby->inset_idx + 1)
                continue; // not directly adjacent
            if (!shorter_then(loc_here - lineloc_nearby.j.p, (lineloc_here.j.w + lineloc_nearby.j.w) / 2 * diagonal_extension))
                continue; // points are too far away from each other
            if ((nearby->inset_idx < here->inset_idx) == outer_to_inner) {
                order_requirements.emplace(std::make_pair(nearby, here));
            } else {
                assert((nearby->inset_idx > here->inset_idx) == outer_to_inner);
                order_requirements.emplace(std::make_pair(here, nearby));
            }
        }
    }
    return order_requirements;
}

References Slic3r::grid(), Slic3r::Arachne::ExtrusionLine::inset_idx, and Slic3r::shorter_then().

Here is the call graph for this function:

getToolPaths()

const std::vector< VariableWidthLines > & Slic3r::Arachne::WallToolPaths::getToolPaths

(

)

Gets the toolpaths, if this called before generate() it will first generate the Toolpaths

Returns

a reference to the toolpaths

{
    if (!toolpaths_generated)
        return generate();
    return toolpaths;
}

References generate(), toolpaths, and toolpaths_generated.

Referenced by Slic3r::FillConcentric::_fill_surface_single(), Slic3r::FillSpiralInset::_fill_surface_single(), and Slic3r::FillConcentricInternal::fill_surface_extrusion().

Here is the call graph for this function:

Here is the caller graph for this function:

removeEmptyToolPaths()

bool Slic3r::Arachne::WallToolPaths::removeEmptyToolPaths ( std::vector< VariableWidthLines > & toolpaths )

static

Removes empty paths from the toolpaths

Parameters

toolpaths

the VariableWidthPaths generated with generate()

Returns

true if there are still paths left. If all toolpaths were removed it returns false

{
    toolpaths.erase(std::remove_if(toolpaths.begin(), toolpaths.end(), [](const VariableWidthLines& lines)
                                   {
                                       return lines.empty();
                                   }), toolpaths.end());
    return toolpaths.empty();
}

References toolpaths.

Referenced by generate().

Here is the caller graph for this function:

removeSmallLines()

void Slic3r::Arachne::WallToolPaths::removeSmallLines ( std::vector< VariableWidthLines > & toolpaths )

protected

Remove polylines shorter than half the smallest line width along that polyline.

{
    for (VariableWidthLines &inset : toolpaths) {
        for (size_t line_idx = 0; line_idx < inset.size(); line_idx++) {
            ExtrusionLine &line      = inset[line_idx];
            coord_t        min_width = std::numeric_limits<coord_t>::max();
            for (const ExtrusionJunction &j : line)
                min_width = std::min(min_width, j.w);
            // Only use min_length_factor for non-topmost, to prevent top gaps. Otherwise use default value.
            if (line.is_odd && !line.is_closed && shorterThan(line, m_params.is_top_or_bottom_layer ? (min_width / 2) : (min_width * m_params.min_length_factor))) { // remove line
                line = std::move(inset.back());
                inset.erase(--inset.end());
                line_idx--; // reconsider the current position
            }
        }
    }
}

References Slic3r::Arachne::ExtrusionLine::is_closed, Slic3r::Arachne::ExtrusionLine::is_odd, m_params, Slic3r::Arachne::shorterThan(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), and toolpaths.

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

separateOutInnerContour()

void Slic3r::Arachne::WallToolPaths::separateOutInnerContour

(

)

Compute the inner contour of the walls. This contour indicates where the walled area ends and its infill begins. The inside can then be filled, e.g. with skin/infill for the walls of a part, or with a pattern in the case of infill with extra infill walls.

{
    //We'll remove all 0-width paths from the original toolpaths and store them separately as polygons.
    std::vector<VariableWidthLines> actual_toolpaths;
    actual_toolpaths.reserve(toolpaths.size()); //A bit too much, but the correct order of magnitude.
    std::vector<VariableWidthLines> contour_paths;
    contour_paths.reserve(toolpaths.size() / inset_count);
    inner_contour.clear();
    for (const VariableWidthLines &inset : toolpaths) {
        if (inset.empty())
            continue;
        bool is_contour = false;
        for (const ExtrusionLine &line : inset) {
            for (const ExtrusionJunction &j : line) {
                if (j.w == 0)
                    is_contour = true;
                else
                    is_contour = false;
                break;
            }
        }
 
        if (is_contour) {
#ifdef DEBUG
            for (const ExtrusionLine &line : inset)
                for (const ExtrusionJunction &j : line)
                    assert(j.w == 0);
#endif // DEBUG
            for (const ExtrusionLine &line : inset) {
                if (line.is_odd)
                    continue;            // odd lines don't contribute to the contour
                else if (line.is_closed) // sometimes an very small even polygonal wall is not stitched into a polygon
                    inner_contour.emplace_back(line.toPolygon());
            }
        } else {
            actual_toolpaths.emplace_back(inset);
        }
    }
    if (!actual_toolpaths.empty())
        toolpaths = std::move(actual_toolpaths); // Filtered out the 0-width paths.
    else
        toolpaths.clear();
 
    //The output walls from the skeletal trapezoidation have no known winding order, especially if they are joined together from polylines.
    //They can be in any direction, clockwise or counter-clockwise, regardless of whether the shapes are positive or negative.
    //To get a correct shape, we need to make the outside contour positive and any holes inside negative.
    //This can be done by applying the even-odd rule to the shape. This rule is not sensitive to the winding order of the polygon.
    //The even-odd rule would be incorrect if the polygon self-intersects, but that should never be generated by the skeletal trapezoidation.
    inner_contour = union_(inner_contour, pftEvenOdd);
}

References inner_contour, inset_count, Slic3r::pftEvenOdd, toolpaths, and Slic3r::union_().

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

simplifyToolPaths()

void Slic3r::Arachne::WallToolPaths::simplifyToolPaths ( std::vector< VariableWidthLines > & toolpaths, const WallToolPathsParams & params )

staticprotected

Simplifies the variable-width toolpaths by calling the simplify on every line in the toolpath using the provided settings.

Parameters

toolpaths	The toolpaths vector to simplify
params	The settings as provided by the user

Returns

{
    const int64_t maximum_resolution = params.wall_maximum_resolution;
    const int64_t maximum_deviation  = params.wall_maximum_deviation;
 
    const int64_t smallest_line_segment_squared  = maximum_resolution * maximum_resolution;
    const int64_t allowed_error_distance_squared = maximum_deviation * maximum_deviation;
 
    const int64_t maximum_extrusion_area_deviation = Slic3r::Arachne::meshfix_maximum_extrusion_area_deviation(); // unit: μm²
 
    for (VariableWidthLines& lines : toolpaths)
    {
        for (ExtrusionLine& line : lines)
        {
            line.simplify(smallest_line_segment_squared, allowed_error_distance_squared, maximum_extrusion_area_deviation);
        }
    }
}

References Slic3r::Arachne::meshfix_maximum_extrusion_area_deviation(), toolpaths, Slic3r::Arachne::WallToolPathsParams::wall_maximum_deviation, and Slic3r::Arachne::WallToolPathsParams::wall_maximum_resolution.

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

stitchToolPaths()

void Slic3r::Arachne::WallToolPaths::stitchToolPaths ( std::vector< VariableWidthLines > & toolpaths, coord_t bead_width_x )

staticprotected

Stitch the polylines together and form closed polygons.

Works on both toolpaths and inner contours simultaneously.

{
    const coord_t stitch_distance = bead_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];
 
        VariableWidthLines stitched_polylines;
        VariableWidthLines closed_polygons;
        PolylineStitcher<VariableWidthLines, ExtrusionLine, ExtrusionJunction>::stitch(wall_lines, stitched_polylines, closed_polygons, stitch_distance);
#ifdef ARACHNE_STITCH_PATCH_DEBUG
        for (const ExtrusionLine& line : stitched_polylines) {
            if ( ! line.is_odd && line.polylineLength() > 3 * stitch_distance && line.size() > 3) {
                BOOST_LOG_TRIVIAL(error) << "Some even contour lines could not be closed into polygons!";
                assert(false && "Some even contour lines could not be closed into polygons!");
                BoundingBox aabb;
                for (auto line2 : wall_lines)
                    for (auto j : line2)
                        aabb.merge(j.p);
                {
                    static int iRun = 0;
                    SVG svg(debug_out_path("contours_before.svg-%d.png", iRun), aabb);
                    std::array<const char *, 8> colors    = {"gray", "black", "blue", "green", "lime", "purple", "red", "yellow"};
                    size_t                      color_idx = 0;
                    for (auto& inset : toolpaths)
                        for (auto& line2 : inset) {
                            // svg.writePolyline(line2.toPolygon(), col);
 
                            Polygon poly = line2.toPolygon();
                            Point last = poly.front();
                            for (size_t idx = 1 ; idx < poly.size(); idx++) {
                                Point here = poly[idx];
                                svg.draw(Line(last, here), colors[color_idx]);
//                                svg.draw_text((last + here) / 2, std::to_string(line2.junctions[idx].region_id).c_str(), "black");
                                last = here;
                            }
                            svg.draw(poly[0], colors[color_idx]);
                            // svg.nextLayer();
                            // svg.writePoints(poly, true, 0.1);
                            // svg.nextLayer();
                            color_idx = (color_idx + 1) % colors.size();
                        }
                }
                {
                    static int iRun = 0;
                    SVG svg(debug_out_path("contours-%d.svg", iRun), aabb);
                    for (auto& inset : toolpaths)
                        for (auto& line2 : inset)
                            svg.draw_outline(line2.toPolygon(), "gray");
                    for (auto& line2 : stitched_polylines) {
                        const char *col = line2.is_odd ? "gray" : "red";
                        if ( ! line2.is_odd)
                            std::cerr << "Non-closed even wall of size: " << line2.size()  << " at " << line2.front().p << "\n";
                        if ( ! line2.is_odd)
                            svg.draw(line2.front().p);
                        Polygon poly = line2.toPolygon();
                        Point last = poly.front();
                        for (size_t idx = 1 ; idx < poly.size(); idx++)
                        {
                            Point here = poly[idx];
                            svg.draw(Line(last, here), col);
                            last = here;
                        }
                    }
                    for (auto line2 : closed_polygons)
                        svg.draw(line2.toPolygon());
                }
            }
        }
#endif // ARACHNE_STITCH_PATCH_DEBUG
        wall_lines = stitched_polylines; // replace input toolpaths with stitched polylines
 
        for (ExtrusionLine& wall_polygon : closed_polygons)
        {
            if (wall_polygon.junctions.empty())
            {
                continue;
            }
 
            // PolylineStitcher, in some cases, produced closed extrusion (polygons),
            // but the endpoints differ by a small distance. So we reconnect them.
            // FIXME Lukas H.: Investigate more deeply why it is happening.
            if (wall_polygon.junctions.front().p != wall_polygon.junctions.back().p &&
                (wall_polygon.junctions.back().p - wall_polygon.junctions.front().p).cast<double>().norm() < stitch_distance) {
                wall_polygon.junctions.emplace_back(wall_polygon.junctions.front());
            }
            wall_polygon.is_closed = true;
            wall_lines.emplace_back(std::move(wall_polygon)); // add stitched polygons to result
        }
#ifdef DEBUG
        for (ExtrusionLine& line : wall_lines)
        {
            assert(line.inset_idx == wall_idx);
        }
#endif // DEBUG
    }
}

References bead_width_x, Slic3r::debug_out_path(), Slic3r::SVG::draw(), Slic3r::SVG::draw_outline(), Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::Arachne::PolylineStitcher< Paths, Path, Junction >::stitch(), and toolpaths.

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bead_width_0

coord_t Slic3r::Arachne::WallToolPaths::bead_width_0

private

Referenced by WallToolPaths(), and generate().

bead_width_x

coord_t Slic3r::Arachne::WallToolPaths::bead_width_x

private

Referenced by WallToolPaths(), generate(), and stitchToolPaths().

inner_contour

Polygons Slic3r::Arachne::WallToolPaths::inner_contour

private

Referenced by getInnerContour(), and separateOutInnerContour().

inset_count

size_t Slic3r::Arachne::WallToolPaths::inset_count

private

Referenced by WallToolPaths(), generate(), getInnerContour(), and separateOutInnerContour().

layer_height

coordf_t Slic3r::Arachne::WallToolPaths::layer_height

private

Referenced by WallToolPaths(), and generate().

m_params

const WallToolPathsParams Slic3r::Arachne::WallToolPaths::m_params

private

Referenced by WallToolPaths(), generate(), and removeSmallLines().

min_bead_width

coord_t Slic3r::Arachne::WallToolPaths::min_bead_width

private

Referenced by WallToolPaths(), and generate().

min_feature_size

coord_t Slic3r::Arachne::WallToolPaths::min_feature_size

private

Referenced by WallToolPaths(), and generate().

outline

const Polygons& Slic3r::Arachne::WallToolPaths::outline

private

Referenced by WallToolPaths(), generate(), and getInnerContour().

print_thin_walls

bool Slic3r::Arachne::WallToolPaths::print_thin_walls

private

Referenced by WallToolPaths(), and generate().

small_area_length

double Slic3r::Arachne::WallToolPaths::small_area_length

private

Referenced by WallToolPaths(), and generate().

toolpaths

std::vector<VariableWidthLines> Slic3r::Arachne::WallToolPaths::toolpaths

private

Referenced by generate(), getToolPaths(), removeEmptyToolPaths(), removeSmallLines(), separateOutInnerContour(), simplifyToolPaths(), and stitchToolPaths().

toolpaths_generated

bool Slic3r::Arachne::WallToolPaths::toolpaths_generated

private

Referenced by WallToolPaths(), generate(), getInnerContour(), and getToolPaths().

wall_0_inset

coord_t Slic3r::Arachne::WallToolPaths::wall_0_inset

private

Referenced by WallToolPaths(), and generate().

wall_transition_filter_deviation

coord_t Slic3r::Arachne::WallToolPaths::wall_transition_filter_deviation

private

The allowed line width deviation induced by filtering.

Referenced by WallToolPaths(), and generate().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Arachne/WallToolPaths.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Arachne/WallToolPaths.cpp