Slic3r::Polyline Class Reference

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

Inheritance diagram for Slic3r::Polyline:

Collaboration diagram for Slic3r::Polyline:

Public Member Functions
	Polyline ()
	Polyline (const Polyline &other)
	Polyline (Polyline &&other) noexcept
	Polyline (std::initializer_list< Point > list)
	Polyline (const Point &p1, const Point &p2)
	Polyline (const Points &points)
	Polyline (Points &&points)
Polyline &	operator= (const Polyline &other)
Polyline &	operator= (Polyline &&other) noexcept
void	append (const Point &point)
void	append_before (const Point &point)
void	append (const Points &src)
void	append (const Points::const_iterator &begin, const Points::const_iterator &end)
void	append (Points &&src)
void	append (const Polyline &src)
void	append (Polyline &&src)
Point &	operator[] (Points::size_type idx)
const Point &	operator[] (Points::size_type idx) const
const Point &	last_point () const override
const Point &	leftmost_point () const
Lines	lines () const override
void	clear ()
void	reverse ()
void	clip_end (double distance)
void	clip_start (double distance)
void	extend_end (double distance)
void	extend_start (double distance)
Points	equally_spaced_points (double distance) const
void	simplify (double tolerance)
void	split_at (Point &point, Polyline *p1, Polyline *p2) const
bool	split_at_index (const size_t index, Polyline *p1, Polyline *p2) const
bool	split_at_length (const double length, Polyline *p1, Polyline *p2) const
bool	is_straight () const
bool	is_closed () const
void	simplify_by_fitting_arc (double tolerance)
void	reset_to_linear_move ()
Polylines	equally_spaced_lines (double distance) const
void	scale (double factor)
void	scale (double factor_x, double factor_y)
void	translate (double x, double y)
void	translate (const Point &vector)
void	rotate (double angle)
void	rotate (double cos_angle, double sin_angle)
void	rotate (double angle, const Point &center)
const Point &	front () const
const Point &	back () const
const Point &	first_point () const
size_t	size () const
bool	empty () const
double	length () const
bool	is_valid () const
int	find_point (const Point &point) const
int	find_point (const Point &point, const double scaled_epsilon) const
bool	has_boundary_point (const Point &point) const
int	closest_point_index (const Point &point) const
const Point *	closest_point (const Point &point) const
double	distance_to (const Point &point) const
BoundingBox	bounding_box () const
bool	has_duplicate_points () const
bool	remove_duplicate_points ()
bool	intersection (const Line &line, Point *intersection) const
bool	first_intersection (const Line &line, Point *intersection) const
bool	intersections (const Line &line, Points *intersections) const
void	symmetric_y (const coord_t &y_axis)
auto	begin ()
auto	begin () const
auto	end ()
auto	end () const
auto	cbegin () const
auto	cend () const

Static Public Member Functions
static Polyline	new_scale (const std::vector< Vec2d > &points)
static Points	_douglas_peucker (const Points &points, const double tolerance)
static Points	visivalingam (const Points &pts, const double tolerance)
static Points	concave_hull_2d (const Points &pts, const double tolerence)
static double	minimumDistanceBetweenLinesDefinedByPoints (const Points &A, const Points &B)
	Calculates the minimum distance between two lines defined by sets of points.

Public Attributes
std::vector< PathFittingData >	fitting_result
Points	points

Private Member Functions
void	append_fitting_result_after_append_points ()
void	append_fitting_result_after_append_polyline (const Polyline &src)
bool	split_fitting_result_before_index (const size_t index, Point &new_endpoint, std::vector< PathFittingData > &data) const
bool	split_fitting_result_after_index (const size_t index, Point &new_startpoint, std::vector< PathFittingData > &data) const

Static Private Member Functions
static double	squaredDistanceToLineSegment (const Point &p, const Point &v, const Point &w)
	Calculates the squared distance between a point and a line segment defined by two points.

Detailed Description

Constructor & Destructor Documentation

Polyline() [1/7]

Slic3r::Polyline::Polyline ( )

inline

{};

Referenced by Polyline(), Polyline(), append(), append(), append_fitting_result_after_append_polyline(), equally_spaced_lines(), new_scale(), operator=(), operator=(), split_at(), split_at_index(), and split_at_length().

Here is the caller graph for this function:

Polyline() [2/7]

Slic3r::Polyline::Polyline ( const Polyline & other )

inline

: MultiPoint(other.points), fitting_result(other.fitting_result) {}

References Slic3r::MultiPoint::MultiPoint(), Polyline(), fitting_result, and Slic3r::MultiPoint::points.

Here is the call graph for this function:

Polyline() [3/7]

Slic3r::Polyline::Polyline ( Polyline && other )

inlinenoexcept

: MultiPoint(std::move(other.points)), fitting_result(std::move(other.fitting_result))  {}

References Polyline().

Here is the call graph for this function:

Polyline() [4/7]

Slic3r::Polyline::Polyline ( std::initializer_list< Point > list )

inline

                                              : MultiPoint(list) { 
        fitting_result.clear();
    }

References Slic3r::MultiPoint::MultiPoint(), and fitting_result.

Here is the call graph for this function:

Polyline() [5/7]

Slic3r::Polyline::Polyline ( const Point & p1, const Point & p2 )

inlineexplicit

                                                        {
        points.reserve(2);
        points.emplace_back(p1);
        points.emplace_back(p2);
        fitting_result.clear();
    }

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

Polyline() [6/7]

Slic3r::Polyline::Polyline ( const Points & points )

inlineexplicit

                                            : MultiPoint(points) {
        fitting_result.clear();
    }

References Slic3r::MultiPoint::MultiPoint(), fitting_result, and Slic3r::MultiPoint::points.

Here is the call graph for this function:

Polyline() [7/7]

Slic3r::Polyline::Polyline ( Points && points )

inlineexplicit

                                       : MultiPoint(std::move(points)) {
        fitting_result.clear();
    }

References Slic3r::MultiPoint::MultiPoint(), fitting_result, and Slic3r::MultiPoint::points.

Here is the call graph for this function:

Member Function Documentation

_douglas_peucker()

Points Slic3r::MultiPoint::_douglas_peucker ( const Points & points, const double tolerance )

staticinherited

{
    Points result_pts;
  double tolerance_sq = tolerance * tolerance;
    if (! pts.empty()) {
        const Point  *anchor      = &pts.front();
        size_t        anchor_idx  = 0;
        const Point  *floater     = &pts.back();
        size_t        floater_idx = pts.size() - 1;
        result_pts.reserve(pts.size());
        result_pts.emplace_back(*anchor);
        if (anchor_idx != floater_idx) {
            assert(pts.size() > 1);
            std::vector<size_t> dpStack;
            dpStack.reserve(pts.size());
            dpStack.emplace_back(floater_idx);
            for (;;) {
                double max_dist_sq  = 0.0;
                size_t furthest_idx = anchor_idx;
                // find point furthest from line seg created by (anchor, floater) and note it
                for (size_t i = anchor_idx + 1; i < floater_idx; ++ i) {
                    double dist_sq = Line::distance_to_squared(pts[i], *anchor, *floater);
                    if (dist_sq > max_dist_sq) {
                        max_dist_sq  = dist_sq;
                        furthest_idx = i;
                    }
                }
                // remove point if less than tolerance
                if (max_dist_sq <= tolerance_sq) {
                    result_pts.emplace_back(*floater);
                    anchor_idx = floater_idx;
                    anchor     = floater;
                    assert(dpStack.back() == floater_idx);
                    dpStack.pop_back();
                    if (dpStack.empty())
                        break;
                    floater_idx = dpStack.back();
                } else {
                    floater_idx = furthest_idx;
                    dpStack.emplace_back(floater_idx);
                }
                floater = &pts[floater_idx];
            }
        }
        assert(result_pts.front() == pts.front());
        assert(result_pts.back()  == pts.back());
 
#if 0
        {
            static int iRun = 0;
      BoundingBox bbox(pts);
      BoundingBox bbox2(result_pts);
      bbox.merge(bbox2);
            SVG svg(debug_out_path("douglas_peucker_%d.svg", iRun ++).c_str(), bbox);
            if (pts.front() == pts.back())
                svg.draw(Polygon(pts), "black");
            else
                svg.draw(Polyline(pts), "black");
            if (result_pts.front() == result_pts.back())
                svg.draw(Polygon(result_pts), "green", scale_(0.1));
            else
                svg.draw(Polyline(result_pts), "green", scale_(0.1));
        }
#endif
    }
    return result_pts;
}

References Slic3r::debug_out_path(), Slic3r::Line::distance_to_squared(), Slic3r::SVG::draw(), Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), and scale_.

Referenced by Slic3r::ArcFitter::do_arc_fitting_and_simplify(), Slic3r::Polygon::douglas_peucker(), Slic3r::GUI::GLGizmoBrimEars::generate_points(), Slic3r::GUI::GLGizmoBrimEars::get_detection_radius_max(), Slic3r::make_brim_ears_auto(), Slic3r::polygons_simplify(), Slic3r::Polygon::simplify(), Slic3r::Polyline::simplify(), Slic3r::ExPolygon::simplify_p(), and Slic3r::Geometry::simplify_polygons().

Here is the call graph for this function:

Here is the caller graph for this function:

append() [1/6]

void Slic3r::Polyline::append ( const Point & point )

inline

                                    {
        //BBS: don't need to append same point
        if (!this->empty() && this->last_point() == point)
            return;
        MultiPoint::append(point);
        append_fitting_result_after_append_points();
    }

References Slic3r::MultiPoint::append(), append_fitting_result_after_append_points(), Slic3r::MultiPoint::empty(), and last_point().

Referenced by append(), append(), append(), append_before(), Slic3r::append_path(), Slic3r::Wipe::calculateWipeRetractionLengths(), Slic3r::FillAdaptive::connect_lines_using_hooks(), equally_spaced_lines(), extend_end(), Slic3r::LoopInterfaceProcessor::generate(), Slic3r::GCode::needs_retraction(), Slic3r::reconnect_polylines(), split_at(), split_at_index(), split_at_length(), anonymous_namespace{NSVGUtils.cpp}::to_dashes(), Slic3r::to_polyline(), Slic3r::GCode::travel_to(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

append() [2/6]

void Slic3r::Polyline::append ( const Points & src )

inline

                                   {
        //BBS: don't need to append same point
        if (!this->empty() && !src.empty() && this->last_point() == src[0])
            this->append(src.begin() + 1, src.end());
        else
            this->append(src.begin(), src.end());
    }

References append(), and Slic3r::MultiPoint::empty().

Here is the call graph for this function:

append() [3/6]

void Slic3r::Polyline::append ( const Points::const_iterator & begin, const Points::const_iterator & end )

inline

                                                                                    {
        //BBS: don't need to append same point
        if (!this->empty() && begin != end && this->last_point() == *begin)
            MultiPoint::append(begin + 1, end);
        else
            MultiPoint::append(begin, end);
        append_fitting_result_after_append_points();
    }

References Slic3r::MultiPoint::append(), append_fitting_result_after_append_points(), Slic3r::MultiPoint::begin(), Slic3r::MultiPoint::empty(), Slic3r::MultiPoint::end(), and last_point().

Here is the call graph for this function:

append() [4/6]

void Slic3r::Polyline::append

(

const Polyline &

src

)

{
    if (!src.is_valid()) return;
 
    if (this->points.empty()) {
        this->points = src.points;
        this->fitting_result = src.fitting_result;
    } else {
        //BBS: append the first point to create connection first, update the fitting date as well
        this->append(src.points[0]);
        //BBS: append a polyline which has fitting data to a polyline without fitting data.
        //Then create a fake fitting data first, so that we can keep the fitting data in last polyline
        if (this->fitting_result.empty() &&
            !src.fitting_result.empty()) {
            this->fitting_result.emplace_back(PathFittingData{ 0, this->points.size() - 1, EMovePathType::Linear_move, ArcSegment() });
        }
        //BBS: then append the remain points
        MultiPoint::append(src.points.begin() + 1, src.points.end());
        //BBS: finally append the fitting data
        append_fitting_result_after_append_polyline(src);
    }
}

References Polyline(), Slic3r::MultiPoint::append(), append(), append_fitting_result_after_append_polyline(), fitting_result, Slic3r::MultiPoint::is_valid(), Slic3r::Linear_move, and Slic3r::MultiPoint::points.

Here is the call graph for this function:

append() [5/6]

void Slic3r::Polyline::append ( Points && src )

inline

    {
        MultiPoint::append(std::move(src));
        append_fitting_result_after_append_points();
    }

References Slic3r::MultiPoint::append(), and append_fitting_result_after_append_points().

Here is the call graph for this function:

append() [6/6]

void Slic3r::Polyline::append

(

Polyline &&

src

)

{
    if (!src.is_valid()) return;
 
    if (this->points.empty()) {
        this->points = std::move(src.points);
        this->fitting_result = std::move(src.fitting_result);
    } else {
        //BBS: append the first point to create connection first, update the fitting date as well
        this->append(src.points[0]);
        //BBS: append a polyline which has fitting data to a polyline without fitting data.
        //Then create a fake fitting data first, so that we can keep the fitting data in last polyline
        if (this->fitting_result.empty() &&
            !src.fitting_result.empty()) {
            this->fitting_result.emplace_back(PathFittingData{ 0, this->points.size() - 1, EMovePathType::Linear_move, ArcSegment() });
        }
        //BBS: then append the remain points
        MultiPoint::append(src.points.begin() + 1, src.points.end());
        //BBS: finally append the fitting data
        append_fitting_result_after_append_polyline(src);
        src.points.clear();
        src.fitting_result.clear();
    }
}

References Polyline(), Slic3r::MultiPoint::append(), append(), append_fitting_result_after_append_polyline(), fitting_result, Slic3r::Linear_move, and Slic3r::MultiPoint::points.

Here is the call graph for this function:

append_before()

void Slic3r::Polyline::append_before ( const Point & point )

inline

                                           {
        //BBS: don't need to append same point
        if (!this->empty() && this->first_point() == point)
            return;
        if (this->size() == 1) {
            this->fitting_result.clear();
            MultiPoint::append(point);
            MultiPoint::reverse();
        } else {
            this->reverse();
            this->append(point);
            this->reverse();
        }
    }

References Slic3r::MultiPoint::append(), append(), Slic3r::MultiPoint::empty(), Slic3r::MultiPoint::first_point(), fitting_result, Slic3r::MultiPoint::reverse(), reverse(), and Slic3r::MultiPoint::size().

Referenced by split_at(), and split_at_length().

Here is the call graph for this function:

Here is the caller graph for this function:

append_fitting_result_after_append_points()

void Slic3r::Polyline::append_fitting_result_after_append_points ( )

private

                                                         {
    if (!fitting_result.empty()) {
        if (fitting_result.back().is_linear_move()) {
            fitting_result.back().end_point_index = this->points.size() - 1;
        } else {
            size_t new_start = fitting_result.back().end_point_index;
            size_t new_end = this->points.size() - 1;
            if (new_start != new_end)
                fitting_result.emplace_back(PathFittingData{ new_start, new_end, EMovePathType::Linear_move, ArcSegment() });
        }
    }
}

References fitting_result, Slic3r::Linear_move, and Slic3r::MultiPoint::points.

Referenced by append(), append(), and append().

Here is the caller graph for this function:

append_fitting_result_after_append_polyline()

void Slic3r::Polyline::append_fitting_result_after_append_polyline ( const Polyline & src )

private

{
    if (!this->fitting_result.empty()) {
        //BBS: offset and save the fitting_result from src polyline
        if (!src.fitting_result.empty()) {
            size_t old_size = this->fitting_result.size();
            size_t index_offset = this->fitting_result.back().end_point_index;
            this->fitting_result.insert(this->fitting_result.end(), src.fitting_result.begin(), src.fitting_result.end());
            for (size_t i = old_size; i < this->fitting_result.size(); i++) {
                this->fitting_result[i].start_point_index += index_offset;
                this->fitting_result[i].end_point_index += index_offset;
            }
        } else {
            //BBS: the append polyline has no fitting data, then append as linear move directly
            size_t new_start = this->fitting_result.back().end_point_index;
            size_t new_end = this->size() - 1;
            if (new_start != new_end)
                this->fitting_result.emplace_back(PathFittingData{ new_start, new_end, EMovePathType::Linear_move, ArcSegment() });
        }
    }
}

References Polyline(), fitting_result, Slic3r::Linear_move, and Slic3r::MultiPoint::size().

Referenced by append(), and append().

Here is the call graph for this function:

Here is the caller graph for this function:

back()

const Point & Slic3r::MultiPoint::back ( ) const

inlineinherited

{ return this->points.back(); }

Referenced by Slic3r::Arachne::removeDegenerateVerts(), Slic3r::FillLightning::Node::removeJunctionOverlap(), Slic3r::GCode::travel_to(), and Slic3r::tree_supports_generate_paths().

Here is the caller graph for this function:

begin() [1/2]

auto Slic3r::MultiPoint::begin ( )

inlineinherited

{ return points.begin(); }

References points.

Referenced by append(), Slic3r::Polyline::append(), Slic3r::generate_transform_pattern(), and Slic3r::Polyline::split_at_index().

Here is the caller graph for this function:

begin() [2/2]

auto Slic3r::MultiPoint::begin ( ) const

inlineinherited

{ return points.begin(); }

References points.

bounding_box()

BoundingBox Slic3r::MultiPoint::bounding_box ( ) const

inherited

{
    return BoundingBox(this->points);
}

References points.

Referenced by Slic3r::Fill3DHoneycomb::_fill_surface_single(), Slic3r::FillConcentric::_fill_surface_single(), Slic3r::FillConcentric::_fill_surface_single(), Slic3r::FillCrossHatch::_fill_surface_single(), Slic3r::FillGyroid::_fill_surface_single(), Slic3r::FillHoneycomb::_fill_surface_single(), Slic3r::FillLine::_fill_surface_single(), Slic3r::FillSpiralInset::_fill_surface_single(), Slic3r::FillSpiralInset::_fill_surface_single(), Slic3r::FillTpmsD::_fill_surface_single(), Slic3r::FillTpmsFK::_fill_surface_single(), Slic3r::Fill::_infill_direction(), Slic3r::GCodeProcessor::check_multi_extruder_gcode_valid(), Slic3r::compacted_wipe_tower_clearance(), Slic3r::compacted_wipe_tower_zone(), Slic3r::FillConcentricInternal::fill_surface_extrusion(), Slic3r::GUI::PartPlate::get_build_volume(), Slic3r::get_extents(), Slic3r::arrangement::get_shrink_bedpts(), Slic3r::GUI::FillBedJob::prepare(), Slic3r::GUI::Bed_2D::repaint(), Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance(), and Slic3r::arrangement::update_selected_items_inflation().

Here is the caller graph for this function:

cbegin()

auto Slic3r::MultiPoint::cbegin ( ) const

inlineinherited

{ return points.begin(); }

References points.

cend()

auto Slic3r::MultiPoint::cend ( ) const

inlineinherited

{ return points.end();   }

References points.

clear()

void Slic3r::Polyline::clear ( )

inline

{ MultiPoint::clear(); this->fitting_result.clear(); }

References Slic3r::MultiPoint::clear(), and fitting_result.

Referenced by Slic3r::ThickPolyline::clear(), Slic3r::TreeSupport3D::ensure_maximum_distance_polyline(), equally_spaced_lines(), Slic3r::evaluate_support_arches(), split_at_index(), split_at_length(), and anonymous_namespace{NSVGUtils.cpp}::to_dashes().

Here is the call graph for this function:

Here is the caller graph for this function:

clip_end()

void Slic3r::Polyline::clip_end

(

double

distance

)

{
    bool last_point_inserted = false;
    size_t remove_after_index = MultiPoint::size();
    while (distance > 0) {
        Vec2d  last_point = this->last_point().cast<double>();
        this->points.pop_back();
        remove_after_index--;
        if (this->points.empty()) {
            this->fitting_result.clear();
            return;
        }
        Vec2d  v    = this->last_point().cast<double>() - last_point;
        double lsqr = v.squaredNorm();
        if (lsqr > distance * distance) {
            this->points.emplace_back((last_point + v * (distance / sqrt(lsqr))).cast<coord_t>());
            last_point_inserted = true;
            break;
        }
        distance -= sqrt(lsqr);
    }
 
    //BBS: don't need to clip fitting result if it's empty
    if (fitting_result.empty())
        return;
    while (!fitting_result.empty() && fitting_result.back().start_point_index >= remove_after_index)
        fitting_result.pop_back();
    if (!fitting_result.empty()) {
        //BBS: last remaining segment is arc move, then clip the arc at last point
        if (fitting_result.back().path_type == EMovePathType::Arc_move_ccw
            || fitting_result.back().path_type == EMovePathType::Arc_move_cw) {
            if (fitting_result.back().arc_data.clip_end(this->last_point()))
                //BBS: succeed to clip arc, then update the last point
                this->points.back() = fitting_result.back().arc_data.end_point;
            else
                //BBS: Failed to clip arc, then back to linear move
                fitting_result.back().path_type = EMovePathType::Linear_move;
        }
        fitting_result.back().end_point_index = this->points.size() - 1;
    }
}

References Slic3r::Arc_move_ccw, Slic3r::Arc_move_cw, Slic3r::cast(), fitting_result, last_point(), Slic3r::Linear_move, Slic3r::MultiPoint::points, and Slic3r::MultiPoint::size().

Referenced by Slic3r::clip_path_end(), clip_start(), Slic3r::Fill::connect_base_support(), Slic3r::draw_perimeters(), Slic3r::TreeSupport3D::ensure_maximum_distance_polyline(), Slic3r::offset_wipe_path(), Slic3r::store_wipe_path(), Slic3r::tree_supports_generate_paths(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

clip_start()

void Slic3r::Polyline::clip_start

(

double

distance

)

{
    this->reverse();
    this->clip_end(distance);
    if (this->points.size() >= 2)
        this->reverse();
}

References clip_end(), Slic3r::MultiPoint::points, and reverse().

Referenced by Slic3r::Fill::connect_base_support().

Here is the call graph for this function:

Here is the caller graph for this function:

closest_point()

const Point * Slic3r::MultiPoint::closest_point ( const Point & point ) const

inlineinherited

{ return this->points.empty() ? nullptr : &this->points[this->closest_point_index(point)]; }

References closest_point_index().

Referenced by distance_to().

Here is the call graph for this function:

Here is the caller graph for this function:

closest_point_index()

int Slic3r::MultiPoint::closest_point_index ( const Point & point ) const

inlineinherited

                                                       {
        int idx = -1;
        if (! this->points.empty()) {
            idx = 0;
            double dist_min = (point - this->points.front()).cast<double>().norm();
            for (int i = 1; i < int(this->points.size()); ++ i) {
                double d = (this->points[i] - point).cast<double>().norm();
                if (d < dist_min) {
                    dist_min = d;
                    idx = i;
                }
            }
        }
        return idx;
    }

References Slic3r::cast().

Referenced by closest_point(), and Slic3r::remove_points_from_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

concave_hull_2d()

Points Slic3r::MultiPoint::concave_hull_2d ( const Points & pts, const double tolerence )

staticinherited

{
    Points hull;
    int n = (int)pts.size();
    if (n >= 3) {
        int k = 0;
        hull.resize(n);
        for (int i = 0; i < n; ++i) {
            while (k >= 2 && pts[i].ccw(hull[k - 2], hull[k - 1]) <= 0 && -pts[i].ccw(hull[k - 2], hull[k - 1]) / (pts[i] - hull[k - 1]).norm() < tolerence)
                --k;
            hull[k++] = pts[i];
        }
        hull.resize(k);
        if (hull.front() == hull.back())
            hull.pop_back();
    }
    return hull;
}

distance_to()

double Slic3r::MultiPoint::distance_to ( const Point & point ) const

inlineinherited

                                                 {
        const Point* cl = closest_point(point);
        return (*cl - point).cast<double>().norm();
    }

References closest_point().

Here is the call graph for this function:

empty()

bool Slic3r::MultiPoint::empty ( ) const

inlineinherited

{ return points.empty(); }

References points.

Referenced by Slic3r::Polyline::append(), Slic3r::Polyline::append(), Slic3r::Polyline::append(), Slic3r::Polyline::append_before(), Slic3r::append_path(), Slic3r::belt_brim_clip_leading_edge(), Slic3r::GCodeProcessor::check_multi_extruder_gcode_valid(), Slic3r::ExtrusionLoop::collect_polylines(), Slic3r::ExtrusionMultiPath::collect_polylines(), Slic3r::Fill::connect_base_support(), Slic3r::connect_brim_lines(), Slic3r::Fill::connect_infill(), Slic3r::FillAdaptive::connect_lines_using_hooks(), Slic3r::contour_distance(), Slic3r::EdgeGrid::Grid::create(), Slic3r::EdgeGrid::Grid::create(), anonymous_namespace{TextLines.cpp}::create_its(), Slic3r::GUI::GLCanvas3D::get_empty_cells(), anonymous_namespace{TextLines.cpp}::its_create_torus(), Slic3r::join_close_ends(), Slic3r::make_belt_brim(), Slic3r::Algorithm::merge_expansions_into_expolygons(), Slic3r::Polygon::overlaps(), Slic3r::Arachne::simplify(), Slic3r::take_ccw_full(), Slic3r::take_ccw_limited(), Slic3r::take_cw_full(), Slic3r::take_cw_limited(), anonymous_namespace{NSVGUtils.cpp}::to_dashes(), Slic3r::AvoidCrossingPerimeters::travel_to(), Slic3r::trim_loop(), Slic3r::GUI::GLCanvas3D::update_sequential_clearance(), and Slic3r::Wipe::wipe().

Here is the caller graph for this function:

end() [1/2]

auto Slic3r::MultiPoint::end ( )

inlineinherited

{ return points.end();   }

References points.

Referenced by append(), Slic3r::Polyline::append(), and Slic3r::generate_transform_pattern().

Here is the caller graph for this function:

end() [2/2]

auto Slic3r::MultiPoint::end ( ) const

inlineinherited

{ return points.end();   }

References points.

equally_spaced_lines()

Polylines Slic3r::Polyline::equally_spaced_lines

(

double

distance

)

const

{
    Polylines lines;
    Polyline line;
    line.append(this->first_point());
    double len = 0;
 
    for (Points::const_iterator it = this->points.begin() + 1; it != this->points.end(); ++it) {
        Vec2d  p1 = line.points.back().cast<double>();
        Vec2d  v = it->cast<double>() - p1;
        double segment_length = v.norm();
        len += segment_length;
        if (len < distance)
            continue;
        if (len == distance) {
            line.append(*it);
            lines.emplace_back(line);
            
            line.clear();
            line.append(*it);
            len = 0;
            continue;
        }
        double take = distance;  // how much we take of this segment
        line.append((p1 + v * (take / v.norm())).cast<coord_t>());
        lines.emplace_back(line);
 
        line.clear();
        line.append(lines.back().last_point());
        --it;
        len = -take;
    }
    // add the last reminder
    if (line.size() == 1) {
        line.append(this->last_point());
        if(line.first_point()!=line.last_point())
            lines.emplace_back(line);
    }
    return lines;
}

References Polyline(), append(), clear(), Slic3r::MultiPoint::first_point(), last_point(), lines(), Slic3r::MultiPoint::points, Slic3r::segment_length(), Slic3r::MultiPoint::size(), and Slic3r::take().

Here is the call graph for this function:

equally_spaced_points()

Points Slic3r::Polyline::equally_spaced_points

(

double

distance

)

const

{
    Points points;
    points.emplace_back(this->first_point());
    double len = 0;
    
    for (Points::const_iterator it = this->points.begin() + 1; it != this->points.end(); ++it) {
        Vec2d  p1 = (it-1)->cast<double>();
        Vec2d  v  = it->cast<double>() - p1;
        double segment_length = v.norm();
        len += segment_length;
        if (len < distance)
            continue;
        if (len == distance) {
            points.emplace_back(*it);
            len = 0;
            continue;
        }
        double take = segment_length - (len - distance);  // how much we take of this segment
        points.emplace_back((p1 + v * (take / v.norm())).cast<coord_t>());
        -- it;
        len = - take;
    }
    return points;
}

References Slic3r::cast(), Slic3r::MultiPoint::first_point(), Slic3r::MultiPoint::points, Slic3r::segment_length(), and Slic3r::take().

Referenced by Slic3r::Polygon::equally_spaced_points().

Here is the call graph for this function:

Here is the caller graph for this function:

extend_end()

void Slic3r::Polyline::extend_end

(

double

distance

)

{
    //BBS: append a new last point by extending the last segment by the specified length
    Vec2d v = (this->points.back() - *(this->points.end() - 2)).cast<double>().normalized();
    Point new_last_point = this->points.back() + (v * distance).cast<coord_t>();
    this->append(new_last_point);
}

References append(), Slic3r::cast(), and Slic3r::MultiPoint::points.

Referenced by extend_start().

Here is the call graph for this function:

Here is the caller graph for this function:

extend_start()

void Slic3r::Polyline::extend_start

(

double

distance

)

{
    this->reverse();
    this->extend_end(distance);
    this->reverse();
}

References extend_end(), and reverse().

Here is the call graph for this function:

find_point() [1/2]

int Slic3r::MultiPoint::find_point ( const Point & point ) const

inherited

{
    for (const Point &pt : this->points)
        if (pt == point)
            return int(&pt - &this->points.front());
    return -1;  // not found
}

References points.

Referenced by find_point(), Slic3r::Polyline::split_at(), and Slic3r::Polyline::split_at_length().

Here is the caller graph for this function:

find_point() [2/2]

int Slic3r::MultiPoint::find_point ( const Point & point, const double scaled_epsilon ) const

inherited

{
    if (scaled_epsilon == 0) return this->find_point(point);
 
    auto dist2_min = std::numeric_limits<double>::max();
    auto eps2      = scaled_epsilon * scaled_epsilon;
    int  idx_min   = -1;
    for (const Point &pt : this->points) {
        double d2 = (pt - point).cast<double>().squaredNorm();
        if (d2 < dist2_min) {
            idx_min   = int(&pt - &this->points.front());
            dist2_min = d2;
        }
    }
    return dist2_min < eps2 ? idx_min : -1;
}

References Slic3r::cast(), find_point(), and points.

Here is the call graph for this function:

first_intersection()

bool Slic3r::MultiPoint::first_intersection ( const Line & line, Point * intersection ) const

inherited

{
    bool   found = false;
    double dmin  = 0.;
    for (const Line &l : this->lines()) {
        Point ip;
        if (l.intersection(line, &ip)) {
            if (! found) {
                found = true;
                dmin = (line.a - ip).cast<double>().norm();
                *intersection = ip;
            } else {
                double d = (line.a - ip).cast<double>().norm();
                if (d < dmin) {
                    dmin = d;
                    *intersection = ip;
                }
            }
        }
    }
    return found;
}

References Slic3r::Line::a, Slic3r::cast(), intersection(), and lines().

Here is the call graph for this function:

first_point()

const Point & Slic3r::MultiPoint::first_point ( ) const

inlineinherited

{ return this->front(); }

References front().

Referenced by Slic3r::FillPlanePath::_fill_surface_single(), Slic3r::Polyline::append_before(), Slic3r::Geometry::MedialAxis::build(), Slic3r::connect_brim_lines(), Slic3r::Polyline::equally_spaced_lines(), Slic3r::Polyline::equally_spaced_points(), Slic3r::LoopInterfaceProcessor::generate(), Slic3r::Polyline::is_straight(), Slic3r::material_side_support_lines(), Slic3r::ExPolygon::medial_axis(), Slic3r::need_wipe(), Slic3r::offset_wipe_path(), Slic3r::optimize_polylines_by_reversing(), Slic3r::PerimeterGenerator::process_classic(), Slic3r::reconnect_polylines(), Slic3r::restore_source_path_order(), Slic3r::sample_polyline_at_distance(), Slic3r::Polyline::split_at(), Slic3r::Polyline::split_at_index(), Slic3r::Polyline::split_at_length(), and Slic3r::support_offset_at_start().

Here is the call graph for this function:

Here is the caller graph for this function:

front()

const Point & Slic3r::MultiPoint::front ( ) const

inlineinherited

{ return this->points.front(); }

Referenced by first_point(), Slic3r::Algorithm::merge_expansions_into_expolygons(), and Slic3r::precompute_expolygon_distances().

Here is the caller graph for this function:

has_boundary_point()

bool Slic3r::MultiPoint::has_boundary_point ( const Point & point ) const

inherited

{
    double dist = (point.projection_onto(*this) - point).cast<double>().norm();
    return dist < SCALED_EPSILON;
}

References Slic3r::Geometry::dist(), Slic3r::Point::projection_onto(), and SCALED_EPSILON.

Here is the call graph for this function:

has_duplicate_points()

bool Slic3r::MultiPoint::has_duplicate_points ( ) const

inherited

{
    for (size_t i = 1; i < points.size(); ++i)
        if (points[i-1] == points[i])
            return true;
    return false;
}

References points.

Referenced by Slic3r::polylines_from_paths(), and Slic3r::traverse_graph_generate_polylines().

Here is the caller graph for this function:

intersection()

bool Slic3r::MultiPoint::intersection ( const Line & line, Point * intersection ) const

inherited

{
    Lines lines = this->lines();
    for (Lines::const_iterator it = lines.begin(); it != lines.end(); ++it) {
        if (it->intersection(line, intersection)) return true;
    }
    return false;
}

References intersection(), and lines().

Referenced by first_intersection(), intersection(), and intersections().

Here is the call graph for this function:

Here is the caller graph for this function:

intersections()

bool Slic3r::MultiPoint::intersections ( const Line & line, Points * intersections ) const

inherited

{
    size_t intersections_size = intersections->size();
    for (const Line &polygon_line : this->lines()) {
        Point intersection;
        if (polygon_line.intersection(line, &intersection))
            intersections->emplace_back(std::move(intersection));
    }
    return intersections->size() > intersections_size;
}

References intersection(), intersections(), and lines().

Referenced by intersections().

Here is the call graph for this function:

Here is the caller graph for this function:

is_closed()

bool Slic3r::Polyline::is_closed ( ) const

inline

{ return this->points.front() == this->points.back(); }

References Slic3r::MultiPoint::points.

Referenced by Slic3r::connect_brim_lines(), and Slic3r::optimize_polylines_by_reversing().

Here is the caller graph for this function:

is_straight()

bool Slic3r::Polyline::is_straight

(

)

const

{
    // Check that each segment's direction is equal to the line connecting
    // first point and last point. (Checking each line against the previous
    // one would cause the error to accumulate.)
    double dir = Line(this->first_point(), this->last_point()).direction();
    for (const auto &line: this->lines())
        if (! line.parallel_to(dir))
            return false;
    return true;
}

References Slic3r::Line::direction(), Slic3r::MultiPoint::first_point(), last_point(), and lines().

Here is the call graph for this function:

is_valid()

bool Slic3r::MultiPoint::is_valid ( ) const

inlineinherited

{ return this->points.size() >= 2; }

Referenced by Slic3r::Polyline::append(), and Slic3r::Polyline::split_at().

Here is the caller graph for this function:

last_point()

const Point & Slic3r::Polyline::last_point ( ) const

inlineoverridevirtual

Implements Slic3r::MultiPoint.

{ return this->points.back(); }

References Slic3r::MultiPoint::points.

Referenced by Slic3r::FillPlanePath::_fill_surface_single(), append(), append(), Slic3r::Geometry::MedialAxis::build(), Slic3r::chain_lines(), clip_end(), Slic3r::connect_brim_lines(), equally_spaced_lines(), Slic3r::LoopInterfaceProcessor::generate(), is_straight(), Slic3r::material_side_support_lines(), Slic3r::ExPolygon::medial_axis(), Slic3r::need_wipe(), Slic3r::offset_wipe_path_toward_support(), Slic3r::optimize_polylines_by_reversing(), Slic3r::reconnect_polylines(), Slic3r::restore_source_path_order(), split_at(), split_at_index(), and split_at_length().

Here is the caller graph for this function:

leftmost_point()

const Point & Slic3r::Polyline::leftmost_point

(

)

const

{
    const Point *p = &this->points.front();
    for (Points::const_iterator it = this->points.begin() + 1; it != this->points.end(); ++ it) {
        if (it->x() < p->x()) 
          p = &(*it);
    }
    return *p;
}

References Slic3r::MultiPoint::points.

length()

double Slic3r::MultiPoint::length ( ) const

inherited

{
    const Lines& lines = this->lines();
    double len = 0;
    for (auto it = lines.cbegin(); it != lines.cend(); ++it) {
        len += it->length();
    }
    return len;
}

References lines().

Referenced by Slic3r::PreciseSeam::detail::append_fragment(), Slic3r::Wipe::calculateWipeRetractionLengths(), Slic3r::FillAdaptive::connect_lines_using_hooks(), Slic3r::make_adaptive_tpms(), Slic3r::ExPolygon::medial_axis(), Slic3r::GCode::needs_retraction(), Slic3r::offset_wipe_path(), Slic3r::Polyline::split_at_length(), Slic3r::store_wipe_path(), Slic3r::AvoidCrossingPerimeters::travel_to(), Slic3r::GCode::travel_to(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

lines()

Lines Slic3r::Polyline::lines ( ) const

overridevirtual

Implements Slic3r::MultiPoint.

{
    Lines lines;
    if (this->points.size() >= 2) {
        lines.reserve(this->points.size() - 1);
        for (Points::const_iterator it = this->points.begin(); it != this->points.end()-1; ++it) {
            lines.push_back(Line(*it, *(it + 1)));
        }
    }
    return lines;
}

References lines(), and Slic3r::MultiPoint::points.

Referenced by Slic3r::WipeInwardSupport::append(), libvgcode::convert_to_vertices(), libvgcode::convert_to_vertices(), libvgcode::convert_to_vertices(), Slic3r::LinesBucket::curLines(), equally_spaced_lines(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::_3DScene::extrusionentity_to_verts(), is_straight(), lines(), Slic3r::paths_touch(), split_at(), split_at_length(), Slic3r::ThickPolyline::thicklines(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

minimumDistanceBetweenLinesDefinedByPoints()

double Slic3r::MultiPoint::minimumDistanceBetweenLinesDefinedByPoints ( const Points & A, const Points & B )

staticinherited

Calculates the minimum distance between two lines defined by sets of points.

Parameters

A	The first set of points defining a polyline.
B	The second set of points defining a polyline.

Returns

double The minimum distance between the two polylines.

                                                                                               {
    double min_distance = std::numeric_limits<double>::infinity();
 
    // Calculate the minimum distance between segments in A and points in B
    for (size_t i = 0; i < A.size() - 1; ++i) {
        for (const auto& b : B) {
            double distance = squaredDistanceToLineSegment(b, A[i], A[i + 1]);
            min_distance = std::min(min_distance, std::sqrt(distance));
        }
    }
 
    // Calculate the minimum distance between segments in B and points in A
    for (size_t i = 0; i < B.size() - 1; ++i) {
        for (const auto& a : A) {
            double distance = squaredDistanceToLineSegment(a, B[i], B[i + 1]);
            min_distance = std::min(min_distance, std::sqrt(distance));
        }
    }
 
    return min_distance;
}

References squaredDistanceToLineSegment().

Here is the call graph for this function:

new_scale()

Polyline Slic3r::Polyline::new_scale ( const std::vector< Vec2d > & points )

inlinestatic

                                                            {
    Polyline pl;
    pl.points.reserve(points.size());
    for (const Vec2d &pt : points)
      pl.points.emplace_back(Point::new_scale(pt(0), pt(1)));
        //BBS: new_scale doesn't support arc, so clean
        pl.fitting_result.clear();
    return pl;
    }

References Polyline(), fitting_result, Slic3r::Point::new_scale(), and Slic3r::MultiPoint::points.

Here is the call graph for this function:

operator=() [1/2]

Polyline & Slic3r::Polyline::operator= ( const Polyline & other )

inline

                                               {
        points = other.points;
        fitting_result = other.fitting_result;
        return *this;
    }

References Polyline(), fitting_result, and Slic3r::MultiPoint::points.

Here is the call graph for this function:

operator=() [2/2]

Polyline & Slic3r::Polyline::operator= ( Polyline && other )

inlinenoexcept

                                                   {
        points = std::move(other.points);
        fitting_result = std::move(other.fitting_result);
        return *this;
    }

References Polyline(), fitting_result, and Slic3r::MultiPoint::points.

Here is the call graph for this function:

operator[]() [1/2]

Point & Slic3r::Polyline::operator[] ( Points::size_type idx )

inline

{ return this->points[idx]; }

References Slic3r::MultiPoint::points.

operator[]() [2/2]

const Point & Slic3r::Polyline::operator[] ( Points::size_type idx ) const

inline

{ return this->points[idx]; }

References Slic3r::MultiPoint::points.

remove_duplicate_points()

bool Slic3r::MultiPoint::remove_duplicate_points ( )

inherited

{
    size_t j = 0;
    for (size_t i = 1; i < points.size(); ++i) {
        if (points[j] == points[i]) {
            // Just increase index i.
        } else {
            ++ j;
            if (j < i)
                points[j] = points[i];
        }
    }
    if (++ j < points.size()) {
        points.erase(points.begin() + j, points.end());
        return true;
    }
    return false;
}

References points.

Referenced by Slic3r::ExPolygonWithOffset::ExPolygonWithOffset(), libvgcode::convert_to_vertices(), libvgcode::convert_to_vertices(), libvgcode::convert_to_vertices(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::polylines_from_paths(), Slic3r::WipeTower::rib_section(), Slic3r::rounding_polygon(), Slic3r::WipeTower::rounding_polygon(), Slic3r::smooth_polyline_corners(), and Slic3r::traverse_graph_generate_polylines().

Here is the caller graph for this function:

reset_to_linear_move()

void Slic3r::Polyline::reset_to_linear_move

(

)

{
    this->fitting_result.clear();
    fitting_result.emplace_back(PathFittingData{ 0, points.size() - 1, EMovePathType::Linear_move, ArcSegment() });
    this->fitting_result.shrink_to_fit();
}

References fitting_result, Slic3r::Linear_move, and Slic3r::MultiPoint::points.

Referenced by Slic3r::WipeTowerWriter::polygon(), and Slic3r::store_wipe_path().

Here is the caller graph for this function:

reverse()

void Slic3r::Polyline::reverse

(

)

{
    //BBS: reverse points
    MultiPoint::reverse();
    //BBS: reverse the fitting_result
    if (!this->fitting_result.empty()) {
        for (size_t i = 0; i < this->fitting_result.size(); i++) {
            std::swap(fitting_result[i].start_point_index, fitting_result[i].end_point_index);
            fitting_result[i].start_point_index = MultiPoint::size() - 1 - fitting_result[i].start_point_index;
            fitting_result[i].end_point_index = MultiPoint::size() - 1 - fitting_result[i].end_point_index;
            if (fitting_result[i].is_arc_move())
                fitting_result[i].reverse_arc_path();
        }
        std::reverse(this->fitting_result.begin(), this->fitting_result.end());
    }
}

References fitting_result, Slic3r::MultiPoint::reverse(), and Slic3r::MultiPoint::size().

Referenced by Slic3r::FillPlanePath::_fill_surface_single(), append_before(), Slic3r::base_support_extend_infill_lines(), Slic3r::chain_lines(), clip_start(), Slic3r::Fill::connect_base_support(), Slic3r::Fill::connect_infill(), Slic3r::FillAdaptive::connect_lines_using_hooks(), Slic3r::draw_perimeters(), extend_start(), Slic3r::LoopInterfaceProcessor::generate(), Slic3r::join_close_ends(), Slic3r::modulate_extrusion_by_overlapping_layers(), Slic3r::offset_wipe_path_toward_support(), Slic3r::optimize_polylines_by_reversing(), Slic3r::reconnect_polylines(), Slic3r::restore_source_path_order(), Slic3r::ThickPolyline::reverse(), Slic3r::take_limited(), and Slic3r::tree_supports_generate_paths().

Here is the call graph for this function:

Here is the caller graph for this function:

rotate() [1/3]

void Slic3r::MultiPoint::rotate ( double angle )

inlineinherited

{ this->rotate(cos(angle), sin(angle)); }

References Slic3r::angle(), and rotate().

Referenced by Slic3r::ExPolygonWithOffset::ExPolygonWithOffset(), Slic3r::ExPolygonWithOffset::ExPolygonWithOffset(), Slic3r::FillHoneycomb::_fill_surface_single(), Slic3r::Print::_make_wipe_tower(), Slic3r::GUI::PartPlate::estimate_wipe_tower_polygon(), Slic3r::get_arrange_poly(), Slic3r::GUI::PartPlate::imex_wipe_tower_hull(), Slic3r::layered_print_cleareance_valid(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::place_wipe_tower(), rotate(), and Slic3r::ModelInstance::transform_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

rotate() [2/3]

void Slic3r::MultiPoint::rotate ( double angle, const Point & center )

inherited

{
    double s = sin(angle);
    double c = cos(angle);
    for (Point &pt : points) {
        Vec2crd v(pt - center);
        pt(0) = (coord_t)round(double(center(0)) + c * v[0] - s * v[1]);
        pt(1) = (coord_t)round(double(center(1)) + c * v[1] + s * v[0]);
    }
}

References Slic3r::angle(), Slic3r::center(), and points.

Here is the call graph for this function:

rotate() [3/3]

void Slic3r::MultiPoint::rotate ( double cos_angle, double sin_angle )

inherited

{
    for (Point &pt : this->points) {
        double cur_x = double(pt(0));
        double cur_y = double(pt(1));
        pt(0) = coord_t(round(cos_angle * cur_x - sin_angle * cur_y));
        pt(1) = coord_t(round(cos_angle * cur_y + sin_angle * cur_x));
    }
}

References points.

scale() [1/2]

void Slic3r::MultiPoint::scale ( double factor )

inherited

{
    for (Point &pt : points)
        pt *= factor;
}

References points.

Referenced by Slic3r::TreeSupport3D::RichInterfacePlacer::add_points_along_lines(), and Slic3r::ModelInstance::transform_polygon().

Here is the caller graph for this function:

scale() [2/2]

void Slic3r::MultiPoint::scale ( double factor_x, double factor_y )

inherited

{
    for (Point &pt : points)
    {
    pt(0) = coord_t(pt(0) * factor_x);
    pt(1) = coord_t(pt(1) * factor_y);
    }
}

References points.

simplify()

void Slic3r::Polyline::simplify

(

double

tolerance

)

{
    this->points = MultiPoint::_douglas_peucker(this->points, tolerance);
    this->fitting_result.clear();
}

References Slic3r::MultiPoint::_douglas_peucker(), fitting_result, and Slic3r::MultiPoint::points.

Referenced by Slic3r::GUI::GLGizmoPainterBase::get_projected_mouse_positions(), Slic3r::make_adaptive_tpms(), and Slic3r::WipeTowerWriter::polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_by_fitting_arc()

void Slic3r::Polyline::simplify_by_fitting_arc

(

double

tolerance

)

{
    //BBS: do arc fit first, then use DP simplify to handle the straight part to reduce point.
    ArcFitter::do_arc_fitting_and_simplify(this->points, this->fitting_result, tolerance);
}

References Slic3r::ArcFitter::do_arc_fitting_and_simplify(), fitting_result, and Slic3r::MultiPoint::points.

Referenced by Slic3r::WipeTowerWriter::polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

size()

size_t Slic3r::MultiPoint::size ( ) const

inlineinherited

{ return points.size(); }

References points.

Referenced by Slic3r::BuildVolume::BuildVolume(), Slic3r::GCode::_do_export(), Slic3r::FillPlanePath::_fill_surface_single(), Slic3r::add_extra_point(), Slic3r::any_expolygon_contains(), Slic3r::Polyline::append_before(), Slic3r::PreciseSeam::detail::append_exact_fragment(), Slic3r::Polyline::append_fitting_result_after_append_polyline(), Slic3r::PreciseSeam::detail::append_fragment(), Slic3r::PreciseSeam::detail::append_projected_fragment(), Slic3r::PreciseSeam::detail::bind_fragment(), Slic3r::SeamPlacerImpl::calculate_polygon_angles_at_vertices(), Slic3r::Polyline::clip_end(), Slic3r::Fill::connect_base_support(), Slic3r::Fill::connect_infill(), Slic3r::FillAdaptive::connect_lines_using_hooks(), Slic3r::contour_distance(), Slic3r::Geometry::convex_polygons_intersect(), Slic3r::create_boundary_infill_graph(), Slic3r::GUI::ImGuiWrapper::draw(), Slic3r::TreeSupport3D::ensure_maximum_distance_polyline(), Slic3r::Polyline::equally_spaced_lines(), Slic3r::PreciseSeam::extract_perimeter_segments(), Slic3r::find_first_different_vertex(), Slic3r::generate_transform_pattern(), priv::get_closest_point_index(), Slic3r::ClipperUtils::interior_point(), Slic3r::PreciseSeam::detail::interval_on_edge(), anonymous_namespace{TextLines.cpp}::its_create_torus(), Slic3r::WipeTower::its_make_rib_brim(), Slic3r::WipeTower::its_make_rib_tower(), Slic3r::mark_boundary_segments_overlapping_infill(), Slic3r::move_inside_expoly(), Slic3r::nearest_clear_wipe_tower_anchor(), Slic3r::need_wipe(), anonymous_namespace{Emboss.cpp}::point_in_distance(), anonymous_namespace{Emboss.cpp}::point_in_distance(), anonymous_namespace{Emboss.cpp}::point_in_reverse_distance(), Slic3r::polygons_match(), Slic3r::precompute_polygon_distances(), Slic3r::PreciseSeam::prepare_weak_modifier_segments(), Slic3r::arrangement::process_arrangeable(), Slic3r::SeamPlacerImpl::process_perimeter_polygon(), Slic3r::GUI::MeshClipper::recalculate_triangles(), Slic3r::remove_duplicates(), Slic3r::remove_points_from_polygon(), Slic3r::Arachne::removeColinearEdges(), Slic3r::Arachne::removeDegenerateVerts(), Slic3r::FillLightning::Node::removeJunctionOverlap(), Slic3r::resample_polygon(), Slic3r::Polyline::reverse(), Slic3r::Arachne::simplify(), Slic3r::smooth_outward(), Slic3r::smooth_outward(), Slic3r::smooth_polyline_corners(), Slic3r::PreciseSeam::detail::snap_cuts_to_adjacent_vertices(), Slic3r::Polyline::split_at_index(), Slic3r::take(), Slic3r::take_limited(), priv::to_expoly(), Slic3r::to_polyline(), Slic3r::GCode::travel_to(), Slic3r::tree_supports_generate_paths(), Slic3r::triangulate_wall(), Slic3r::trim_loop(), and Slic3r::GUI::PartPlate::wipe_tower_obstacles().

split_at()

void Slic3r::Polyline::split_at	(	Point &	point,
		Polyline *	p1,
		Polyline *	p2 ) const

{
    if (this->points.empty()) return;
 
    //0 judge whether the point is on the polyline
    int index = this->find_point(point);
    if (index != -1) {
        //BBS: the spilit point is on the polyline, then easy
        split_at_index(index, p1, p2);
        point = p1->is_valid()? p1->last_point(): p2->first_point();
        return;
    }
    
    //1 find the line to split at
    size_t line_idx = 0;
    Point p = this->first_point();
    double min = (p - point).cast<double>().norm();
    Lines lines = this->lines();
    for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) {
        Point p_tmp = point.projection_onto(*line);
        if ((p_tmp - point).cast<double>().norm() < min) {
          p = p_tmp;
          min = (p - point).cast<double>().norm();
          line_idx = line - lines.begin();
        }
    }
 
    //2 judge whether the cloest point is one vertex of polyline.
    //  and spilit the polyline at different index
    index = this->find_point(p);
    if (index != -1)
    {
        this->split_at_index(index, p1, p2);
        p1->append(point);
        p2->append_before(point);
    } else {
        Polyline temp;
        this->split_at_index(line_idx, p1, &temp);
        p1->append(point);
        this->split_at_index(line_idx + 1, &temp, p2);
        p2->append_before(point);
    }
}

References Polyline(), append(), append_before(), Slic3r::cast(), Slic3r::MultiPoint::find_point(), Slic3r::MultiPoint::first_point(), Slic3r::MultiPoint::is_valid(), last_point(), lines(), Slic3r::MultiPoint::points, Slic3r::Point::projection_onto(), and split_at_index().

Here is the call graph for this function:

split_at_index()

bool Slic3r::Polyline::split_at_index	(	const size_t	index,
		Polyline *	p1,
		Polyline *	p2 ) const

{
    if (index > this->size() - 1)
        return false;
 
    if (index == 0) {
        p1->clear();
        p1->append(this->first_point());
        *p2 = *this;
    } else if (index == this->size() - 1) {
        p2->clear();
        p2->append(this->last_point());
        *p1 = *this;
    } else {
        //BBS: spilit first part
        p1->clear();
        p1->points.reserve(index + 1);
        p1->points.insert(p1->begin(), this->begin(), this->begin() + index + 1);
        Point new_endpoint;
        if (this->split_fitting_result_before_index(index, new_endpoint, p1->fitting_result))
            p1->points.back() = new_endpoint;
 
        p2->clear();
        p2->points.reserve(this->size() - index);
        p2->points.insert(p2->begin(), this->begin() + index, this->end());
        Point new_startpoint;
        if (this->split_fitting_result_after_index(index, new_startpoint, p2->fitting_result))
            p2->points.front() = new_startpoint;
    }
    return true;
}

References Polyline(), append(), Slic3r::MultiPoint::begin(), clear(), Slic3r::MultiPoint::first_point(), fitting_result, last_point(), Slic3r::MultiPoint::points, Slic3r::MultiPoint::size(), split_fitting_result_after_index(), and split_fitting_result_before_index().

Referenced by split_at(), and split_at_length().

Here is the call graph for this function:

Here is the caller graph for this function:

split_at_length()

bool Slic3r::Polyline::split_at_length	(	const double	length,
		Polyline *	p1,
		Polyline *	p2 ) const

{
    if (this->points.empty()) return false;
    if (length < 0 || length > this->length()) {
        return false;
    }
 
    if (length < SCALED_EPSILON) {
        p1->clear();
        p1->append(this->first_point());
        *p2 = *this;
    } else if (is_approx(length, this->length(), SCALED_EPSILON)) {
        p2->clear();
        p2->append(this->last_point());
        *p1 = *this;
    } else {
        // 1 find the line to split at
        size_t line_idx = 0;
        double acc_length = 0;
        Point p = this->first_point();
        for (const auto& l : this->lines()) {
            p = l.b;
 
            const double current_length = l.length();
            if (acc_length + current_length >= length) {
                p = lerp(l.a, l.b, (length - acc_length) / current_length);
                break;
            }
            acc_length += current_length;
            line_idx++;
        }
 
        //2 judge whether the cloest point is one vertex of polyline.
        //  and spilit the polyline at different index
        int index = this->find_point(p);
        if (index != -1) {
            this->split_at_index(index, p1, p2);
        } else {
            Polyline temp;
            this->split_at_index(line_idx, p1, &temp);
            p1->append(p);
            this->split_at_index(line_idx + 1, &temp, p2);
            p2->append_before(p);
        }
    }
    return true;
}

References Polyline(), append(), append_before(), clear(), Slic3r::MultiPoint::find_point(), Slic3r::MultiPoint::first_point(), Slic3r::is_approx(), last_point(), Slic3r::MultiPoint::length(), Slic3r::lerp(), lines(), Slic3r::MultiPoint::points, SCALED_EPSILON, and split_at_index().

Here is the call graph for this function:

split_fitting_result_after_index()

bool Slic3r::Polyline::split_fitting_result_after_index ( const size_t index, Point & new_startpoint, std::vector< PathFittingData > & data ) const

private

{
    data.clear();
    new_startpoint = this->points[index];
    if (!this->fitting_result.empty()) {
        data.reserve(this->fitting_result.size());
        for (size_t i = 0; i < this->fitting_result.size(); i++) {
            if (this->fitting_result[i].end_point_index > index)
                data.push_back(this->fitting_result[i]);
        }
        if (!data.empty()) {
            for (size_t i = 0; i < data.size(); i++) {
                if (i != 0) {
                    data[i].start_point_index -= index;
                    data[i].end_point_index -= index;
                } else {
                    data[i].end_point_index -= index;
                    //BBS: need to clip the arc and generate new start point
                    if (data.front().is_arc_move() && data.front().start_point_index < index) {
                        if (!data.front().arc_data.clip_start(this->points[index]))
                            //BBS: failed to clip arc, then return to be linear move
                            data.front().path_type = EMovePathType::Linear_move;
                        else
                            //BBS: succeed to clip arc, then update and return the new start point
                            new_startpoint = data.front().arc_data.start_point;
                    }
                    data[i].start_point_index = 0;
                }
            }
        }
        data.shrink_to_fit();
        return true;
    }
    return false;
}

References fitting_result, Slic3r::Linear_move, and Slic3r::MultiPoint::points.

Referenced by split_at_index().

Here is the caller graph for this function:

split_fitting_result_before_index()

bool Slic3r::Polyline::split_fitting_result_before_index ( const size_t index, Point & new_endpoint, std::vector< PathFittingData > & data ) const

private

{
    data.clear();
    new_endpoint = this->points[index];
    if (!this->fitting_result.empty()) {
        //BBS: max size
        data.reserve(this->fitting_result.size());
        //BBS: save fitting result before index
        for (size_t i = 0; i < this->fitting_result.size(); i++)
        {
            if (this->fitting_result[i].start_point_index < index)
                data.push_back(this->fitting_result[i]);
            else
                break;
        }
 
        if (!data.empty()) {
            //BBS: need to clip the arc and generate new end point
            if (data.back().is_arc_move() && data.back().end_point_index > index) {
                if (!data.back().arc_data.clip_end(this->points[index]))
                    //BBS: failed to clip arc, then return to be linear move
                    data.back().path_type = EMovePathType::Linear_move;
                else
                    //BBS: succeed to clip arc, then update and return the new end point
                    new_endpoint = data.back().arc_data.end_point;
            }
            data.back().end_point_index = index;
        }
        data.shrink_to_fit();
        return true;
    }
    return false;
}

References fitting_result, Slic3r::Linear_move, and Slic3r::MultiPoint::points.

Referenced by split_at_index().

Here is the caller graph for this function:

squaredDistanceToLineSegment()

double Slic3r::MultiPoint::squaredDistanceToLineSegment ( const Point & p, const Point & v, const Point & w )

staticprivateinherited

Calculates the squared distance between a point and a line segment defined by two points.

Parameters

p	The point.
v	The starting point of the line segment.
w	The ending point of the line segment.

Returns

double The squared distance between the point and the line segment.

                                                                                               {
    // Calculate the squared length of the line segment
    double l2 = (v - w).squaredNorm();
    // If the segment is a single point, return the squared distance to that point
    if (l2 == 0.0) return (p - v).squaredNorm();
    // Project point p onto the line defined by v and w, and clamp the projection to the segment
    double t = std::max(0.0, std::min(1.0, ((p - v).dot(w - v)) / l2));
    // Compute the projection point
    Point projection{v.x() + t * (w.x() - v.x()), v.y() + t * (w.y() - v.y())};
    // Return the squared distance between the point and the projection
    return (p - projection).squaredNorm();
}

References Slic3r::dot(), and Slic3r::l2().

Referenced by minimumDistanceBetweenLinesDefinedByPoints().

Here is the call graph for this function:

Here is the caller graph for this function:

symmetric_y()

void Slic3r::MultiPoint::symmetric_y ( const coord_t & y_axis )

inherited

{
    for (Point &pt : points) {
        pt(0) = 2 * x_axis - pt(0);
    }
}

References points.

translate() [1/2]

void Slic3r::MultiPoint::translate ( const Point & vector )

inherited

{
    for (Point &pt : points)
        pt += v;
}

References points.

translate() [2/2]

void Slic3r::MultiPoint::translate ( double x, double y )

inlineinherited

{ this->translate(Point(coord_t(x), coord_t(y))); }

References translate().

Referenced by Slic3r::Print::_make_wipe_tower(), Slic3r::TreeSupport3D::RichInterfacePlacer::add_points_along_lines(), Slic3r::anonymous_namespace{ExclusionVolumeGeometry.cpp}::append_active_footprints(), Slic3r::GCodeProcessor::check_multi_extruder_gcode_valid(), Slic3r::GUI::PartPlate::check_outside(), Slic3r::compacted_tower_print_instance_hull(), libvgcode::convert_to_vertices(), libvgcode::convert_to_vertices(), libvgcode::convert_to_vertices(), Slic3r::LinesBucket::curLines(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::WipeTower::finish_layer_new(), Slic3r::TreeSupport3D::generate_support_areas(), Slic3r::generate_transform_pattern(), Slic3r::get_arrange_poly(), anonymous_namespace{Emboss.cpp}::heal_dupl_inter(), Slic3r::GUI::PartPlate::imex_wipe_tower_hull(), Slic3r::ExclusionVolumeTravelAvoidance::init(), Slic3r::layered_print_cleareance_valid(), Slic3r::make_gyroid_waves(), Slic3r::makeEndPoints(), Slic3r::makeZigZag(), Slic3r::GCode::needs_retraction(), translate(), Slic3r::AvoidCrossingPerimeters::travel_to(), Slic3r::GUI::PartPlate::update_exclusion_volume_preview_models(), and Slic3r::GUI::PartPlate::wipe_tower_obstacles().

Here is the call graph for this function:

Here is the caller graph for this function:

visivalingam()

Points Slic3r::MultiPoint::visivalingam ( const Points & pts, const double tolerance )

staticinherited

{
    // Make sure there's enough points in "pts" to bother with simplification.
    assert(pts.size() >= 2);
     // Result object
    Points results;
     // Lambda to calculate effective area spanned by a point and its immediate 
    // successor + predecessor.
    auto effective_area = [pts](const size_t& curr_pt_idx, const size_t& prev_pt_idx, const size_t& next_pt_idx)->coordf_t {
        const Point& curr = pts[curr_pt_idx];
        const Point& prev = pts[prev_pt_idx];
        const Point& next = pts[next_pt_idx];
        // Use point objects as vector-distances
    const Vec2d curr_to_next = (next - curr).cast<double>();
    const Vec2d prev_to_next = (prev - curr).cast<double>();
        // Take cross product of these two vector distances
    return 0.50 * abs(cross2(curr_to_next, prev_to_next));
    };
     // We store the effective areas for each node
    std::vector<coordf_t> areas;
    areas.reserve(pts.size());
     // Construct the initial set of nodes. We will make a heap out of the "heap" vector using 
    // std::make_heap. node_list is used later.
    std::vector<vis_node*> node_list;
    node_list.resize(pts.size());
    std::vector<vis_node*> heap;
    heap.reserve(pts.size());
    for (size_t i = 1; i < pts.size() - 1; ++ i) {
        // Get effective area of current node.
        coordf_t area = effective_area(i, i - 1, i + 1);
        // If area is greater than some arbitrarily small value, use it.
        node_list[i] = new vis_node(i, i - 1, i + 1, area);
        heap.push_back(node_list[i]);
    }
     // Call std::make_heap, which uses the < operator by default to make "heap" into 
    // a binheap, sorted by the < operator we defind in the vis_node struct
    std::make_heap(heap.begin(), heap.end());
     // Start comparing areas. Set min_area to an outrageous value initially.
    double min_area = -std::numeric_limits<double>::max();
    while (!heap.empty()) {
         // Get current node.
        vis_node* curr = heap.front();
         // Pop node we just retrieved off the heap. pop_heap moves front element in vector
        // to the back, so we can call pop_back()
        std::pop_heap(heap.begin(), heap.end());
        heap.pop_back();
         // Sanity assert check
        assert(curr == node_list[curr->pt_idx]);
         // If the current pt'ss area is less than that of the previous pt's area
        // use the last pt's area instead. This ensures we don't elimate the current
        // point without eliminating the previous 
        min_area = std::max(min_area, curr->area);
         // Update prev
        vis_node* prev = node_list[curr->prev_idx];
        if(prev != nullptr){
            prev->next_idx = curr->next_idx;
            prev->area = effective_area(prev->pt_idx, prev->prev_idx, prev->next_idx);
            // For some reason, std::make_heap() is the fastest way to resort the heap. Probably needs testing.
            std::make_heap(heap.begin(), heap.end());
        }
         // Update next
        vis_node* next = node_list[curr->next_idx];
        if(next != nullptr){
            next->prev_idx = curr->prev_idx;
            next->area = effective_area(next->pt_idx, next->prev_idx, next->next_idx);
            std::make_heap(heap.begin(), heap.end());
        }
         areas[curr->pt_idx] = min_area;
        node_list[curr->pt_idx] = nullptr;
        delete curr;
    }
    // Clear node list and shrink_to_fit() (to free actual memory). Not necessary. Could be removed.
    node_list.clear();
    node_list.shrink_to_fit();
    // This lambda is how we test whether or not to keep a point.
    auto use_point = [areas, tolerance](const size_t& idx)->bool {
        assert(idx < areas.size());
        // Return true at front/back of path/areas
        if(idx == 0 || idx == areas.size() - 1){
            return true;
        }
        // Return true if area at idx is greater than minimum area to consider "valid"
        else{
            return areas[idx] > tolerance;
        }
    };
    // Use previously defined lambda to build results.
    for (size_t i = 0; i < pts.size(); ++i) {
        if (use_point(i)){
            results.push_back(pts[i]);
        }
    }
     // Check that results has at least two points
    assert(results.size() >= 2);
     // Return simplified vector of points
    return results;
}

References Slic3r::area(), Slic3r::vis_node::area, Slic3r::cast(), Slic3r::cross2(), Slic3r::vis_node::next_idx, Slic3r::vis_node::prev_idx, and Slic3r::vis_node::pt_idx.

Here is the call graph for this function:

Member Data Documentation

fitting_result

std::vector<PathFittingData> Slic3r::Polyline::fitting_result

Referenced by Polyline(), Polyline(), Polyline(), Polyline(), Polyline(), append(), append(), append_before(), append_fitting_result_after_append_points(), append_fitting_result_after_append_polyline(), clear(), clip_end(), Slic3r::from_json(), new_scale(), operator=(), operator=(), Slic3r::WipeTowerWriter::polygon(), reset_to_linear_move(), reverse(), simplify(), simplify_by_fitting_arc(), split_at_index(), split_fitting_result_after_index(), split_fitting_result_before_index(), and Slic3r::to_json().

points

Points Slic3r::MultiPoint::points

inherited

Referenced by Slic3r::BuildVolume::BuildVolume(), Slic3r::ExPolygonsIndices::ExPolygonsIndices(), MultiPoint(), MultiPoint(), MultiPoint(), Slic3r::Polygon::Polygon(), Slic3r::Polygon::Polygon(), Slic3r::Polygon::Polygon(), Slic3r::Polyline::Polyline(), Slic3r::Polyline::Polyline(), Slic3r::Polyline::Polyline(), Slic3r::Polyline::Polyline(), Slic3r::GCode::_do_export(), Slic3r::FillConcentric::_fill_surface_single(), Slic3r::FillHoneycomb::_fill_surface_single(), Slic3r::FillPlanePath::_fill_surface_single(), Slic3r::Print::_make_skirt(), Slic3r::AreaMoments::add(), Slic3r::sla::ConcaveHull::add_connector_rectangles(), Slic3r::add_extra_point(), Slic3r::TreeSupport3D::RichInterfacePlacer::add_points_along_lines(), Slic3r::addTops(), Slic3r::any_expolygon_contains(), Slic3r::Polyline::append(), Slic3r::Polyline::append(), Slic3r::PreciseSeam::detail::append_exact_fragment(), Slic3r::Polyline::append_fitting_result_after_append_points(), Slic3r::anonymous_namespace{PrintConfig.cpp}::append_legacy_bed_exclude_regions(), Slic3r::append_path(), Slic3r::append_path_point(), Slic3r::append_path_point(), Slic3r::PreciseSeam::detail::append_projected_fragment(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), Slic3r::Polygon::area(), Slic3r::Polygon::area(), Slic3r::ExtrusionMultiPath::as_polyline(), Slic3r::MutablePolygon::assign(), Slic3r::bed_exclusion_arrange_polygon(), begin(), begin(), boost::polygon::polygon_traits< Slic3r::ExPolygon >::begin_points(), boost::polygon::polygon_traits< Slic3r::Polygon >::begin_points(), Slic3r::belt_brim_band_paths(), bounding_box(), Slic3r::Geometry::MedialAxis::build(), Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_attach_stray_holes(), Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_offset_expolygons(), Slic3r::SeamPlacerImpl::calculate_polygon_angles_at_vertices(), cbegin(), cend(), Slic3r::Polygon::centroid(), Slic3r::chain_lines(), Slic3r::chamfer_polygon(), Slic3r::ClipperUtils::clip_clipper_polygon_with_subject_bbox(), Slic3r::ClipperUtils::clip_clipper_polygon_with_subject_bbox(), Slic3r::Polyline::clip_end(), Slic3r::clip_inner_walls_over_top(), Slic3r::clip_path_end(), Slic3r::Polyline::clip_start(), Slic3r::colored_points_to_polygon(), Slic3r::compacted_tower_print_instance_hull(), Slic3r::Print::compacted_wipe_tower_clearance_valid(), Slic3r::compacted_wipe_tower_zone(), Slic3r::Polygon::concave_points(), Slic3r::WipeTower2::cone_base_polygon(), Slic3r::Fill::connect_base_support(), Slic3r::connect_brim_lines(), Slic3r::Fill::connect_infill(), Slic3r::Fill::connect_infill(), Slic3r::FillAdaptive::connect_lines_using_hooks(), Slic3r::TimelapsePosPicker::construct_printable_area_by_printer(), Slic3r::contains(), Slic3r::contour_distance(), Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::contour_intersections(), Slic3r::contour_to_polygons(), Slic3r::Geometry::convex_hull(), Slic3r::ModelObject::convex_hull_2d(), Slic3r::Polygon::convex_points(), Slic3r::count_points(), Slic3r::EdgeGrid::Grid::create(), Slic3r::EdgeGrid::Grid::create(), Slic3r::create_boundary_infill_graph(), Slic3r::create_polyholes(), Slic3r::Polygon::densify(), Slic3r::diff(), Slic3r::diff_ex(), Slic3r::diff_ex(), Slic3r::diff_pl(), Slic3r::diff_pl(), Slic3r::Emboss::divide_segments_for_close_point(), Slic3r::Algorithm::do_split_line(), Slic3r::Polygon::douglas_peucker(), Slic3r::GUI::ImGuiWrapper::draw(), Slic3r::draw_perimeters(), Slic3r::emit_perimeter_prev_next_segment(), Slic3r::emit_perimeter_segment_on_vertical_line(), empty(), end(), end(), boost::polygon::polygon_traits< Slic3r::ExPolygon >::end_points(), boost::polygon::polygon_traits< Slic3r::Polygon >::end_points(), Slic3r::TreeSupport3D::ensure_maximum_distance_polyline(), Slic3r::Polyline::equally_spaced_lines(), Slic3r::Polyline::equally_spaced_points(), Slic3r::estimated_wipe_tower_footprint(), Slic3r::evaluate_support_arch_cost(), Slic3r::evaluate_support_arches(), Slic3r::executable_path_length(), Slic3r::ClipperZUtils::expolygons_to_zpaths(), Slic3r::Polyline::extend_end(), Slic3r::PreciseSeam::extract_perimeter_segments(), Slic3r::extrusion_polyline_extents(), priv::fill_polygon_distances(), priv::fill_shape_distances(), Slic3r::FillConcentricInternal::fill_surface_extrusion(), Slic3r::FillRectilinear::fill_surface_trapezoidal(), priv::find_close_point(), Slic3r::find_first_different_vertex(), find_point(), find_point(), Slic3r::find_spiral_start_corner(), Slic3r::Polygon::first_intersection(), Slic3r::from_json(), Slic3r::from_json(), Slic3r::WipeTowerIntegration::generate_path_to_wipe_tower(), Slic3r::GUI::GLGizmoBrimEars::generate_points(), Slic3r::generate_rectange_polygon(), Slic3r::generate_spiral_insets(), Slic3r::generate_transform_pattern(), Slic3r::generate_tree_support_3D(), Slic3r::get_arrange_poly(), Slic3r::get_bed_shape(), Slic3r::get_bed_shape(), Slic3r::get_bed_shape_with_excluded_area(), Slic3r::GUI::GLGizmoBrimEars::get_detection_radius_max(), Slic3r::get_extents(), Slic3r::get_extents_rotated(), anonymous_namespace{Emboss.cpp}::get_glyph(), Slic3r::SVG::get_path_d(), Slic3r::get_polygon_vertex_inward_normal(), Slic3r::get_polygon_vertex_offset(), Slic3r::GUI::GLGizmoPainterBase::get_projected_mouse_positions(), Slic3r::get_shared_poly(), Slic3r::get_svg_profile(), Slic3r::has_duplicate_points(), Slic3r::has_duplicate_points(), has_duplicate_points(), Slic3r::FillAdaptive::has_no_collinear_lines(), Slic3r::Wipe::has_path(), Slic3r::imex_hull_violates_zones(), Slic3r::GUI::PartPlate::imex_wipe_tower_hull(), Slic3r::ExclusionVolumeTravelAvoidance::init(), Slic3r::GUI::init_exclusion_volume_prism_model(), Slic3r::initial_connector_is_clear(), priv::insert_edges(), priv::insert_edges(), Slic3r::PreciseSeam::insert_point_into_perimeter(), Slic3r::ClipperUtils::interior_point(), Slic3r::intersection(), Slic3r::Polygon::intersection(), Slic3r::intersection_pl(), Slic3r::intersection_pl(), Slic3r::intersection_pl(), Slic3r::Polygon::intersections(), Slic3r::ModelInstance::intersects_bed_exclude_region(), Slic3r::PreciseSeam::detail::interval_on_edge(), Slic3r::Polyline::is_closed(), Slic3r::Polygon::is_valid(), Slic3r::SupportGridPattern::island_samples(), anonymous_namespace{TextLines.cpp}::its_create_torus(), Slic3r::WipeTower::its_make_rib_tower(), Slic3r::join_close_ends(), Slic3r::Polygon::last_point(), Slic3r::Polyline::last_point(), Slic3r::layered_print_cleareance_valid(), Slic3r::Polyline::leftmost_point(), Slic3r::Polygon::length(), Slic3r::length_off_reference(), Slic3r::Polyline::lines(), Slic3r::loop_clip_length(), Slic3r::make_adaptive_infill_shells(), Slic3r::make_adaptive_tpms(), Slic3r::make_brim_ears(), Slic3r::make_brim_ears_auto(), Slic3r::make_circle_num_segments(), Slic3r::GUI::GLGizmoBrimEars::make_polygon(), Slic3r::make_wave(), Slic3r::makeEndPoints(), Slic3r::makeZigZag(), Slic3r::mark_boundary_segments_overlapping_infill(), Slic3r::material_side_support_lines(), Slic3r::ExPolygon::medial_axis(), Slic3r::modulate_extrusion_by_overlapping_layers(), Slic3r::move_inside_expoly(), Slic3r::FillAdaptive::multiline_paths(), Slic3r::nearest_clear_wipe_tower_anchor(), Slic3r::GCode::needs_retraction(), Slic3r::Polygon::new_scale(), Slic3r::Polyline::new_scale(), Slic3r::offset(), Slic3r::offset(), Slic3r::offset(), Slic3r::offset_wipe_path(), Slic3r::offset_wipe_path_toward_support(), Slic3r::open_loop(), Slic3r::operator!=(), Slic3r::operator!=(), Slic3r::operator<<(), operator=(), operator=(), Slic3r::Polygon::operator=(), Slic3r::Polygon::operator=(), Slic3r::Polyline::operator=(), Slic3r::Polyline::operator=(), Slic3r::operator==(), Slic3r::operator==(), Slic3r::Polygon::operator[](), Slic3r::Polygon::operator[](), Slic3r::Polyline::operator[](), Slic3r::Polyline::operator[](), Slic3r::Polygon::parameter_by_length(), Slic3r::anonymous_namespace{PrintConfig.cpp}::parse_exclude_polygon_points(), Slic3r::anonymous_namespace{ClipperUtils.cpp}::path_encloses(), Slic3r::patternPoints(), Slic3r::Polygon::point_projection(), Slic3r::MutablePolygon::polygon(), Slic3r::WipeTowerWriter::polygon(), Slic3r::polygon_segment_append(), Slic3r::polygon_segment_append_reversed(), Slic3r::polygon_to_string(), Slic3r::polygons_match(), Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::polyline_intersects_obstacles(), Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::polyline_length(), Slic3r::polylines_from_paths(), Slic3r::precompute_polygon_distances(), Slic3r::PreciseSeam::prepare_weak_modifier_segments(), Slic3r::GUI::PartPlateList::preprocess_exclude_areas(), Slic3r::Geometry::MedialAxis::process_edge_neighbors(), Slic3r::SeamPlacerImpl::process_perimeter_polygon(), Slic3r::reconnect_polylines(), Slic3r::PreciseSeam::refine_at_vertex(), remove_duplicate_points(), Slic3r::remove_points_from_polygon(), Slic3r::remove_same_neighbor(), Slic3r::remove_same_neighbor(), anonymous_namespace{Emboss.cpp}::remove_spikes_in_duplicates(), anonymous_namespace{Emboss.cpp}::remove_when_spike(), Slic3r::Arachne::removeColinearEdges(), Slic3r::Arachne::removeDegenerateVerts(), Slic3r::FillLightning::Node::removeJunctionOverlap(), Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::replace_segment(), Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::replacement_matches_original_segment(), Slic3r::resample_polygon(), Slic3r::Polyline::reset_to_linear_move(), Slic3r::restore_source_path_order(), Slic3r::WipeTower::rib_section(), rotate(), rotate(), Slic3r::rounding_polygon(), Slic3r::WipeTower::rounding_polygon(), Slic3r::rounding_rectangle(), Slic3r::ExclusionVolumeTravelAvoidance::route(), Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::routed_polyline_inside_bed(), Slic3r::sample_polyline_at_distance(), scale(), scale(), Slic3r::scale_polygon(), cereal::serialize(), boost::polygon::polygon_mutable_traits< Slic3r::ExPolygon >::set_points(), Slic3r::Model::setPrintSpeedTable(), Slic3r::Arachne::simplify(), Slic3r::Polygon::simplify(), Slic3r::Polyline::simplify(), Slic3r::Polyline::simplify_by_fitting_arc(), Slic3r::ExPolygon::simplify_p(), Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::simplify_path(), Slic3r::Geometry::simplify_polygons(), boost::polygon::polygon_traits< Slic3r::ExPolygon >::size(), boost::polygon::polygon_traits< Slic3r::Polygon >::size(), size(), Slic3r::slice_region_by_vertical_lines(), Slic3r::smooth_polyline_corners(), Slic3r::PreciseSeam::detail::snap_cuts_to_adjacent_vertices(), Slic3r::solid_bodies(), Slic3r::Polyline::split_at(), Slic3r::Polygon::split_at_index(), Slic3r::Polyline::split_at_index(), Slic3r::Polyline::split_at_length(), Slic3r::Polygon::split_at_vertex(), Slic3r::Polyline::split_fitting_result_after_index(), Slic3r::Polyline::split_fitting_result_before_index(), Slic3r::ThickPolyline::start_at_index(), Slic3r::starts_by_backtracking(), Slic3r::store_wipe_path(), Slic3r::GUI::ImGuiWrapper::suggest_location(), Slic3r::support_offset_at_start(), Slic3r::sweep_ex(), symmetric_y(), Slic3r::take(), Slic3r::take_ccw_full(), Slic3r::take_ccw_limited(), Slic3r::take_cw_full(), Slic3r::take_cw_limited(), Slic3r::take_limited(), Slic3r::GluTessWrapper::tesselate3d(), Slic3r::ThickPolyline::thicklines(), anonymous_namespace{NSVGUtils.cpp}::to_dashes(), Slic3r::to_json(), Slic3r::to_json(), Slic3r::to_linesf(), Slic3r::to_points(), Slic3r::to_points(), Slic3r::Arachne::to_polygon(), Slic3r::to_polygon(), Slic3r::Polyline3::to_polyline(), Slic3r::to_polyline(), Slic3r::to_polyline(), Slic3r::to_polylines(), Slic3r::to_polylines(), Slic3r::to_polylines(), Slic3r::to_polylines(), Slic3r::to_polylines(), Slic3r::Arachne::to_thick_polyline(), Slic3r::top_level_expolygons(), Slic3r::Arachne::ExtrusionLine::toPolygon(), Slic3r::Polygon::transform(), translate(), Slic3r::translated_wipe_path(), Slic3r::AvoidCrossingPerimeters::travel_to(), Slic3r::GCode::travel_to(), Slic3r::WipeTowerIntegration::travel_to_tower_gap(), Slic3r::traverse_graph_generate_polylines(), Slic3r::traverse_loops(), Slic3r::traverse_pt_outside_in(), Slic3r::tree_supports_generate_paths(), Slic3r::Triangulation::triangulate(), Slic3r::Polygon::triangulate_convex(), Slic3r::triangulate_wall(), Slic3r::anonymous_namespace{Model.cpp}::triangulated_prism_footprints(), Slic3r::trim_loop(), Slic3r::unscale_polygon(), Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance(), Slic3r::GUI::GLCanvas3D::update_sequential_clearance(), Slic3r::Print::validate_compacted_wipe_tower_clearance(), Slic3r::TreeSupport3D::validate_range(), Slic3r::variable_offset(), Slic3r::Wipe::wipe(), Slic3r::wipe_path_stays_on_material_side(), and Slic3r::wipe_path_support_score().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Polyline.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Polyline.cpp