Slic3r::Arachne::ExtrusionLine Struct Reference

#include <src/libslic3r/Arachne/utils/ExtrusionLine.hpp>

Collaboration diagram for Slic3r::Arachne::ExtrusionLine:

Public Member Functions
size_t	size () const
bool	empty () const
	ExtrusionLine (const size_t inset_idx, const bool is_odd)
	ExtrusionLine ()
	ExtrusionLine (const ExtrusionLine &other)
ExtrusionLine &	operator= (ExtrusionLine &&other)
ExtrusionLine &	operator= (const ExtrusionLine &other)
std::vector< ExtrusionJunction >::const_iterator	begin () const
std::vector< ExtrusionJunction >::const_iterator	end () const
std::vector< ExtrusionJunction >::const_reverse_iterator	rbegin () const
std::vector< ExtrusionJunction >::const_reverse_iterator	rend () const
std::vector< ExtrusionJunction >::const_reference	front () const
std::vector< ExtrusionJunction >::const_reference	back () const
const ExtrusionJunction &	operator[] (unsigned int index) const
ExtrusionJunction &	operator[] (unsigned int index)
std::vector< ExtrusionJunction >::iterator	begin ()
std::vector< ExtrusionJunction >::iterator	end ()
std::vector< ExtrusionJunction >::reference	front ()
std::vector< ExtrusionJunction >::reference	back ()
template<typename... Args>
void	emplace_back (Args &&...args)
void	remove (unsigned int index)
void	insert (size_t index, const ExtrusionJunction &p)
template<class iterator >
std::vector< ExtrusionJunction >::iterator	insert (std::vector< ExtrusionJunction >::const_iterator pos, iterator first, iterator last)
void	clear ()
void	reverse ()
int64_t	getLength () const
int64_t	polylineLength () const
Polygon	toPolygon () const
coord_t	getMinimalWidth () const
void	simplify (int64_t smallest_line_segment_squared, int64_t allowed_error_distance_squared, int64_t maximum_extrusion_area_deviation)
bool	is_contour () const
double	area () const

Static Public Member Functions
static int64_t	calculateExtrusionAreaDeviationError (ExtrusionJunction A, ExtrusionJunction B, ExtrusionJunction C)

Public Attributes
size_t	inset_idx
bool	is_odd
bool	is_closed
std::vector< ExtrusionJunction >	junctions

Detailed Description

Represents a polyline (not just a line) that is to be extruded with variable line width.

This polyline is a sequence of ExtrusionJunction, with a bit of metadata about which inset it represents.

Constructor & Destructor Documentation

ExtrusionLine() [1/3]

Slic3r::Arachne::ExtrusionLine::ExtrusionLine	(	const size_t	inset_idx,
		const bool	is_odd
	)

: inset_idx(inset_idx), is_odd(is_odd), is_closed(false) {}

ExtrusionLine() [2/3]

Slic3r::Arachne::ExtrusionLine::ExtrusionLine ( )

inline

: inset_idx(-1), is_odd(true), is_closed(false) {}

ExtrusionLine() [3/3]

Slic3r::Arachne::ExtrusionLine::ExtrusionLine ( const ExtrusionLine &  other )

inline

: inset_idx(other.inset_idx), is_odd(other.is_odd), is_closed(other.is_closed), junctions(other.junctions) {}

Member Function Documentation

area()

double Slic3r::Arachne::ExtrusionLine::area

(

)

const

{
    assert(this->is_closed);
    double a = 0.;
    if (this->junctions.size() >= 3) {
        Vec2d p1 = this->junctions.back().p.cast<double>();
        for (const ExtrusionJunction &junction : this->junctions) {
            Vec2d p2 = junction.p.cast<double>();
            a += cross2(p1, p2);
            p1 = p2;
        }
    }
    return 0.5 * a;
}

References Slic3r::cross2(), is_closed, and junctions.

Here is the call graph for this function:

back() [1/2]

std::vector< ExtrusionJunction >::reference Slic3r::Arachne::ExtrusionLine::back ( )

inline

{ return junctions.back(); }

References junctions.

back() [2/2]

std::vector< ExtrusionJunction >::const_reference Slic3r::Arachne::ExtrusionLine::back ( ) const

inline

{ return junctions.back(); }

References junctions.

Referenced by Slic3r::fuzzy_extrusion_line(), Slic3r::Arachne::SkeletalTrapezoidation::generateLocalMaximaSingleBeads(), and getLength().

Here is the caller graph for this function:

begin() [1/2]

std::vector< ExtrusionJunction >::iterator Slic3r::Arachne::ExtrusionLine::begin ( )

inline

{ return junctions.begin(); }

References junctions.

begin() [2/2]

std::vector< ExtrusionJunction >::const_iterator Slic3r::Arachne::ExtrusionLine::begin ( ) const

inline

{ return junctions.begin(); }

References junctions.

Referenced by Slic3r::Arachne::to_thick_polyline().

Here is the caller graph for this function:

calculateExtrusionAreaDeviationError()

int64_t Slic3r::Arachne::ExtrusionLine::calculateExtrusionAreaDeviationError ( ExtrusionJunction  A, ExtrusionJunction  B, ExtrusionJunction  C  )

static

Computes and returns the total area error (in μm²) of the AB and BC segments of an ABC straight ExtrusionLine when the junction B with a width B.w is removed from the ExtrusionLine. The area changes due to the fact that the new simplified line AC has a uniform width which equals to the weighted average of the width of the subsegments (based on their length).

Parameters

A	Start point of the 3-point-straight line
B	Intermediate point of the 3-point-straight line
C	End point of the 3-point-straight line

                                                                                                                         {
    /*
     * A             B                          C              A                                        C
     * ---------------                                         **************
     * |             |                                         ------------------------------------------
     * |             |--------------------------|  B removed   |            |***************************|
     * |             |                          |  --------->  |            |                           |
     * |             |--------------------------|              |            |***************************|
     * |             |                                         ------------------------------------------
     * ---------------             ^                           **************
     *       ^                B.w + C.w / 2                                       ^
     *  A.w + B.w / 2                                               new_width = weighted_average_width
     *
     *
     * ******** denote the total extrusion area deviation error in the consecutive segments as a result of using the
     * weighted-average width for the entire extrusion line.
     *
     * */
    const int64_t ab_length = (B.p - A.p).cast<int64_t>().norm();
    const int64_t bc_length = (C.p - B.p).cast<int64_t>().norm();
    if (const coord_t width_diff = std::max(std::abs(B.w - A.w), std::abs(C.w - B.w)); width_diff > 1) {
        // Adjust the width only if there is a difference, or else the rounding errors may produce the wrong
        // weighted average value.
        const int64_t ab_weight              = (A.w + B.w) / 2;
        const int64_t bc_weight              = (B.w + C.w) / 2;
        const int64_t weighted_average_width = (ab_length * ab_weight + bc_length * bc_weight) / (ab_length + bc_length);
        const int64_t ac_length              = (C.p - A.p).cast<int64_t>().norm();
        return std::abs((ab_weight * ab_length + bc_weight * bc_length) - (weighted_average_width * ac_length));
    } else {
        // If the width difference is very small, then select the width of the segment that is longer
        return ab_length > bc_length ? int64_t(width_diff) * bc_length : int64_t(width_diff) * ab_length;
    }
}

References Slic3r::Arachne::ExtrusionJunction::p, and Slic3r::Arachne::ExtrusionJunction::w.

Referenced by simplify().

Here is the caller graph for this function:

clear()

void Slic3r::Arachne::ExtrusionLine::clear ( )

inline

{ junctions.clear(); }

References junctions.

emplace_back()

template<typename... Args>

void Slic3r::Arachne::ExtrusionLine::emplace_back ( Args &&...  args )

inline

{ junctions.emplace_back(args...); }

References junctions.

empty()

bool Slic3r::Arachne::ExtrusionLine::empty ( ) const

inline

Whether there are no junctions.

{ return junctions.empty(); }

References junctions.

Referenced by Slic3r::traverse_extrusions().

Here is the caller graph for this function:

end() [1/2]

std::vector< ExtrusionJunction >::iterator Slic3r::Arachne::ExtrusionLine::end ( )

inline

{ return junctions.end(); }

References junctions.

end() [2/2]

std::vector< ExtrusionJunction >::const_iterator Slic3r::Arachne::ExtrusionLine::end ( ) const

inline

{ return junctions.end(); }

References junctions.

Referenced by Slic3r::Arachne::to_thick_polyline().

Here is the caller graph for this function:

front() [1/2]

std::vector< ExtrusionJunction >::reference Slic3r::Arachne::ExtrusionLine::front ( )

inline

{ return junctions.front(); }

References junctions.

front() [2/2]

std::vector< ExtrusionJunction >::const_reference Slic3r::Arachne::ExtrusionLine::front ( ) const

inline

{ return junctions.front(); }

References junctions.

Referenced by Slic3r::fuzzy_extrusion_line(), getLength(), and Slic3r::Arachne::to_thick_polyline().

Here is the caller graph for this function:

getLength()

int64_t Slic3r::Arachne::ExtrusionLine::getLength

(

)

const

Sum the total length of this path.

{
    if (junctions.empty())
        return 0;
 
    int64_t           len  = 0;
    ExtrusionJunction prev = junctions.front();
    for (const ExtrusionJunction &next : junctions) {
        len += (next.p - prev.p).cast<int64_t>().norm();
        prev = next;
    }
    if (is_closed)
        len += (front().p - back().p).cast<int64_t>().norm();
 
    return len;
}

References back(), front(), is_closed, junctions, and Slic3r::Arachne::ExtrusionJunction::p.

Referenced by polylineLength().

Here is the call graph for this function:

Here is the caller graph for this function:

getMinimalWidth()

coord_t Slic3r::Arachne::ExtrusionLine::getMinimalWidth

(

)

const

Get the minimal width of this path

{
    return std::min_element(junctions.cbegin(), junctions.cend(),
                            [](const ExtrusionJunction& l, const ExtrusionJunction& r)
                            {
                                return l.w < r.w;
                            })->w;
}

References junctions.

insert() [1/2]

void Slic3r::Arachne::ExtrusionLine::insert ( size_t  index, const ExtrusionJunction &  p  )

inline

{ junctions.insert(junctions.begin() + index, p); }

References junctions.

insert() [2/2]

template<class iterator >

std::vector< ExtrusionJunction >::iterator Slic3r::Arachne::ExtrusionLine::insert ( std::vector< ExtrusionJunction >::const_iterator  pos, iterator  first, iterator  last  )

inline

    {
        return junctions.insert(pos, first, last);
    }

References junctions.

is_contour()

bool Slic3r::Arachne::ExtrusionLine::is_contour

(

)

const

{
    if (!this->is_closed)
        return false;
 
    Polygon poly;
    poly.points.reserve(this->junctions.size());
    for (const ExtrusionJunction &junction : this->junctions)
        poly.points.emplace_back(junction.p);
 
    // Arachne produces contour with clockwise orientation and holes with counterclockwise orientation.
    return poly.is_clockwise();
}

References Slic3r::Polygon::is_clockwise(), is_closed, junctions, and Slic3r::MultiPoint::points.

Here is the call graph for this function:

operator=() [1/2]

ExtrusionLine & Slic3r::Arachne::ExtrusionLine::operator= ( const ExtrusionLine &  other )

inline

    {
        junctions = other.junctions;
        inset_idx = other.inset_idx;
        is_odd    = other.is_odd;
        is_closed = other.is_closed;
        return *this;
    }

References inset_idx, is_closed, is_odd, and junctions.

operator=() [2/2]

ExtrusionLine & Slic3r::Arachne::ExtrusionLine::operator= ( ExtrusionLine &&  other )

inline

    {
        junctions = std::move(other.junctions);
        inset_idx = other.inset_idx;
        is_odd    = other.is_odd;
        is_closed = other.is_closed;
        return *this;
    }

References inset_idx, is_closed, is_odd, and junctions.

operator[]() [1/2]

ExtrusionJunction & Slic3r::Arachne::ExtrusionLine::operator[] ( unsigned int  index )

inline

{ return junctions[index]; }

References junctions.

operator[]() [2/2]

const ExtrusionJunction & Slic3r::Arachne::ExtrusionLine::operator[] ( unsigned int  index ) const

inline

{ return junctions[index]; }

References junctions.

polylineLength()

int64_t Slic3r::Arachne::ExtrusionLine::polylineLength ( ) const

inline

{ return getLength(); }

References getLength().

Here is the call graph for this function:

rbegin()

std::vector< ExtrusionJunction >::const_reverse_iterator Slic3r::Arachne::ExtrusionLine::rbegin ( ) const

inline

{ return junctions.rbegin(); }

References junctions.

remove()

void Slic3r::Arachne::ExtrusionLine::remove ( unsigned int  index )

inline

{ junctions.erase(junctions.begin() + index); }

References junctions.

rend()

std::vector< ExtrusionJunction >::const_reverse_iterator Slic3r::Arachne::ExtrusionLine::rend ( ) const

inline

{ return junctions.rend(); }

References junctions.

reverse()

void Slic3r::Arachne::ExtrusionLine::reverse ( )

inline

{ std::reverse(junctions.begin(), junctions.end()); }

References junctions.

simplify()

void Slic3r::Arachne::ExtrusionLine::simplify	(	int64_t	smallest_line_segment_squared,
		int64_t	allowed_error_distance_squared,
		int64_t	maximum_extrusion_area_deviation
	)

Removes vertices of the ExtrusionLines to make sure that they are not too high resolution.

This removes junctions which are connected to line segments that are shorter than the smallest_line_segment, unless that would introduce a deviation in the contour of more than allowed_error_distance.

Criteria:

1. Never remove a junction if either of the connected segments is larger than smallest_line_segment
2. Never remove a junction if the distance between that junction and the final resulting polygon would be higher than allowed_error_distance
3. The direction of segments longer than smallest_line_segment always remains unaltered (but their end points may change if it is connected to a small segment)
4. Never remove a junction if it has a distinctively different width than the next junction, as this can introduce unwanted irregularities on the wall widths.

Simplify uses a heuristic and doesn't necessarily remove all removable vertices under the above criteria, but simplify may never violate these criteria. Unless the segments or the distance is smaller than the rounding error of 5 micron.

Vertices which introduce an error of less than 5 microns are removed anyway, even if the segments are longer than the smallest line segment. This makes sure that (practically) co-linear line segments are joined into a single line segment.

Parameters

smallest_line_segment	Maximal length of removed line segments.
allowed_error_distance	If removing a vertex introduces a deviation from the original path that is more than this distance, the vertex may not be removed.
maximum_extrusion_area_deviation	The maximum extrusion area deviation allowed when removing intermediate junctions from a straight ExtrusionLine

{
    const size_t min_path_size = is_closed ? 3 : 2;
    if (junctions.size() <= min_path_size)
        return;
 
    // TODO: allow for the first point to be removed in case of simplifying closed Extrusionlines.
 
    /* ExtrusionLines are treated as (open) polylines, so in case an ExtrusionLine is actually a closed polygon, its
     * starting and ending points will be equal (or almost equal). Therefore, the simplification of the ExtrusionLine
     * should not touch the first and last points. As a result, start simplifying from point at index 1.
     * */
    std::vector<ExtrusionJunction> new_junctions;
    // Starting junction should always exist in the simplified path
    new_junctions.emplace_back(junctions.front());
 
    /* Initially, previous_previous is always the same as previous because, for open ExtrusionLines the last junction
     * cannot be taken into consideration when checking the points at index 1. For closed ExtrusionLines, the first and
     * last junctions are anyway the same.
     * */
    ExtrusionJunction previous_previous = junctions.front();
    ExtrusionJunction previous = junctions.front();
 
    /* When removing a vertex, we check the height of the triangle of the area
     being removed from the original polygon by the simplification. However,
     when consecutively removing multiple vertices the height of the previously
     removed vertices w.r.t. the shortcut path changes.
     In order to not recompute the new height value of previously removed
     vertices we compute the height of a representative triangle, which covers
     the same amount of area as the area being cut off. We use the Shoelace
     formula to accumulate the area under the removed segments. This works by
     computing the area in a 'fan' where each of the blades of the fan go from
     the origin to one of the segments. While removing vertices the area in
     this fan accumulates. By subtracting the area of the blade connected to
     the short-cutting segment we obtain the total area of the cutoff region.
     From this area we compute the height of the representative triangle using
     the standard formula for a triangle area: A = .5*b*h
     */
    const ExtrusionJunction& initial = junctions.at(1);
    int64_t accumulated_area_removed = int64_t(previous.p.x()) * int64_t(initial.p.y()) - int64_t(previous.p.y()) * int64_t(initial.p.x()); // Twice the Shoelace formula for area of polygon per line segment.
 
    for (size_t point_idx = 1; point_idx < junctions.size() - 1; point_idx++)
    {
        const ExtrusionJunction& current = junctions[point_idx];
 
        // Spill over in case of overflow, unless the [next] vertex will then be equal to [previous].
        const bool spill_over = point_idx + 1 == junctions.size() && new_junctions.size() > 1;
        ExtrusionJunction& next = spill_over ? new_junctions[0] : junctions[point_idx + 1];
 
        const int64_t removed_area_next = int64_t(current.p.x()) * int64_t(next.p.y()) - int64_t(current.p.y()) * int64_t(next.p.x()); // Twice the Shoelace formula for area of polygon per line segment.
        const int64_t negative_area_closing = int64_t(next.p.x()) * int64_t(previous.p.y()) - int64_t(next.p.y()) * int64_t(previous.p.x()); // Area between the origin and the short-cutting segment
        accumulated_area_removed += removed_area_next;
 
        const int64_t length2 = (current - previous).cast<int64_t>().squaredNorm();
        if (length2 < scaled<coord_t>(0.025))
        {
            // We're allowed to always delete segments of less than 5 micron. The width in this case doesn't matter that much.
            continue;
        }
 
        const int64_t area_removed_so_far = accumulated_area_removed + negative_area_closing; // Close the shortcut area polygon
        const int64_t base_length_2 = (next - previous).cast<int64_t>().squaredNorm();
 
        if (base_length_2 == 0) // Two line segments form a line back and forth with no area.
        {
            continue; // Remove the junction (vertex).
        }
        //We want to check if the height of the triangle formed by previous, current and next vertices is less than allowed_error_distance_squared.
        //1/2 L = A           [actual area is half of the computed shoelace value] // Shoelace formula is .5*(...) , but we simplify the computation and take out the .5
        //A = 1/2 * b * h     [triangle area formula]
        //L = b * h           [apply above two and take out the 1/2]
        //h = L / b           [divide by b]
        //h^2 = (L / b)^2     [square it]
        //h^2 = L^2 / b^2     [factor the divisor]
        const auto    height_2 = int64_t(double(area_removed_so_far) * double(area_removed_so_far) / double(base_length_2));
        const int64_t extrusion_area_error = calculateExtrusionAreaDeviationError(previous, current, next);
        if ((height_2 <= scaled<coord_t>(0.001) //Almost exactly colinear (barring rounding errors).
             && Line::distance_to_infinite(current.p, previous.p, next.p) <= scaled<double>(0.001)) // Make sure that height_2 is not small because of cancellation of positive and negative areas
            // We shouldn't remove middle junctions of colinear segments if the area changed for the C-P segment is exceeding the maximum allowed
             && extrusion_area_error <= maximum_extrusion_area_deviation)
        {
            // Remove the current junction (vertex).
            continue;
        }
 
        if (length2 < smallest_line_segment_squared
            && height_2 <= allowed_error_distance_squared) // Removing the junction (vertex) doesn't introduce too much error.
        {
            const int64_t next_length2 = (current - next).cast<int64_t>().squaredNorm();
            if (next_length2 > 4 * smallest_line_segment_squared)
            {
                // Special case; The next line is long. If we were to remove this, it could happen that we get quite noticeable artifacts.
                // We should instead move this point to a location where both edges are kept and then remove the previous point that we wanted to keep.
                // By taking the intersection of these two lines, we get a point that preserves the direction (so it makes the corner a bit more pointy).
                // We just need to be sure that the intersection point does not introduce an artifact itself.
                Point intersection_point;
                bool has_intersection = Line(previous_previous.p, previous.p).intersection_infinite(Line(current.p, next.p), &intersection_point);
                if (!has_intersection
                    || Line::distance_to_infinite_squared(intersection_point, previous.p, current.p) > double(allowed_error_distance_squared)
                    || (intersection_point - previous.p).cast<int64_t>().squaredNorm() > smallest_line_segment_squared  // The intersection point is way too far from the 'previous'
                    || (intersection_point - next.p).cast<int64_t>().squaredNorm() > smallest_line_segment_squared)     // and 'next' points, so it shouldn't replace 'current'
                {
                    // We can't find a better spot for it, but the size of the line is more than 5 micron.
                    // So the only thing we can do here is leave it in...
                }
                else
                {
                    // New point seems like a valid one.
                    const ExtrusionJunction new_to_add = ExtrusionJunction(intersection_point, current.w, current.perimeter_index);
                    // If there was a previous point added, remove it.
                    if(!new_junctions.empty())
                    {
                        new_junctions.pop_back();
                        previous = previous_previous;
                    }
 
                    // The junction (vertex) is replaced by the new one.
                    accumulated_area_removed = removed_area_next; // So that in the next iteration it's the area between the origin, [previous] and [current]
                    previous_previous = previous;
                    previous = new_to_add; // Note that "previous" is only updated if we don't remove the junction (vertex).
                    new_junctions.push_back(new_to_add);
                    continue;
                }
            }
            else
            {
                continue; // Remove the junction (vertex).
            }
        }
        // The junction (vertex) isn't removed.
        accumulated_area_removed = removed_area_next; // So that in the next iteration it's the area between the origin, [previous] and [current]
        previous_previous = previous;
        previous = current; // Note that "previous" is only updated if we don't remove the junction (vertex).
        new_junctions.push_back(current);
    }
 
    // Ending junction (vertex) should always exist in the simplified path
    new_junctions.emplace_back(junctions.back());
 
    /* In case this is a closed polygon (instead of a poly-line-segments), the invariant that the first and last points are the same should be enforced.
     * Since one of them didn't move, and the other can't have been moved further than the constraints, if originally equal, they can simply be equated.
     */
    if ((junctions.front().p - junctions.back().p).cast<int64_t>().squaredNorm() == 0)
    {
        new_junctions.back().p = junctions.front().p;
    }
 
    junctions = new_junctions;
}

References calculateExtrusionAreaDeviationError(), Slic3r::Line::distance_to_infinite(), Slic3r::Line::distance_to_infinite_squared(), Slic3r::Line::intersection_infinite(), is_closed, junctions, Slic3r::Arachne::ExtrusionJunction::p, Slic3r::Arachne::ExtrusionJunction::perimeter_index, and Slic3r::Arachne::ExtrusionJunction::w.

Here is the call graph for this function:

size()

size_t Slic3r::Arachne::ExtrusionLine::size ( ) const

inline

Gets the number of vertices in this polygon.

Returns

The number of vertices in this polygon.

{ return junctions.size(); }

References junctions.

Referenced by Slic3r::fuzzy_extrusion_line(), Slic3r::Arachne::to_thick_polyline(), and Slic3r::traverse_extrusions().

Here is the caller graph for this function:

toPolygon()

Polygon Slic3r::Arachne::ExtrusionLine::toPolygon ( ) const

inline

Put all junction locations into a polygon object.

When this path is not closed the returned Polygon should be handled as a polyline, rather than a polygon.

    {
        Polygon ret;
        for (const ExtrusionJunction &j : junctions)
            ret.points.emplace_back(j.p);
 
        return ret;
    }

References junctions, and Slic3r::MultiPoint::points.

Member Data Documentation

inset_idx

size_t Slic3r::Arachne::ExtrusionLine::inset_idx

Which inset this path represents, counted from the outside inwards.

The outer wall has index 0.

Referenced by operator=(), operator=(), and Slic3r::traverse_extrusions().

is_closed

bool Slic3r::Arachne::ExtrusionLine::is_closed

Whether this is a closed polygonal path

Referenced by area(), getLength(), is_contour(), operator=(), operator=(), Slic3r::Arachne::WallToolPaths::removeSmallLines(), simplify(), and Slic3r::traverse_extrusions().

is_odd

bool Slic3r::Arachne::ExtrusionLine::is_odd

If a thin piece needs to be printed with an odd number of walls (e.g. 5 walls) then there will be one wall in the middle that is not a loop. This field indicates whether this path is such a line through the middle, that has no companion line going back on the other side and is not a closed loop.

Referenced by Slic3r::Arachne::PolylineStitcher< Paths, Path, Junction >::isOdd(), operator=(), operator=(), and Slic3r::Arachne::WallToolPaths::removeSmallLines().

junctions

std::vector<ExtrusionJunction> Slic3r::Arachne::ExtrusionLine::junctions

The list of vertices along which this path runs.

Each junction has a width, making this path a variable-width path.

Referenced by area(), back(), back(), begin(), begin(), clear(), emplace_back(), empty(), end(), end(), front(), front(), Slic3r::fuzzy_extrusion_line(), Slic3r::Arachne::SkeletalTrapezoidation::generateLocalMaximaSingleBeads(), getLength(), getMinimalWidth(), insert(), insert(), is_contour(), operator=(), operator=(), operator[](), operator[](), rbegin(), remove(), rend(), reverse(), simplify(), size(), Slic3r::Arachne::to_polygon(), toPolygon(), and Slic3r::traverse_extrusions().

---

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

• src/libslic3r/Arachne/utils/ExtrusionLine.hpp
• src/libslic3r/Arachne/utils/ExtrusionLine.cpp