Slic3r::MultiPoint Class Reference

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

Inheritance diagram for Slic3r::MultiPoint:

Collaboration diagram for Slic3r::MultiPoint:

Public Member Functions
	MultiPoint ()
	MultiPoint (const MultiPoint &other)
	MultiPoint (MultiPoint &&other) noexcept
	MultiPoint (std::initializer_list< Point > list)
	MultiPoint (const Points &_points)
	MultiPoint (Points &&_points) noexcept
MultiPoint &	operator= (const MultiPoint &other)
MultiPoint &	operator= (MultiPoint &&other) noexcept
virtual	~MultiPoint ()=default
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)
void	reverse ()
const Point &	front () const
const Point &	back () const
const Point &	first_point () const
virtual const Point &	last_point () const =0
virtual Lines	lines () const =0
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 ()
void	clear ()
void	append (const Point &point)
void	append (const Points &src)
void	append (const Points::const_iterator &begin, const Points::const_iterator &end)
void	append (Points &&src)
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 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
Points	points

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

MultiPoint() [1/6]

Slic3r::MultiPoint::MultiPoint ( )

inline

{}

Referenced by MultiPoint(), MultiPoint(), Slic3r::Polygon::Polygon(), Slic3r::Polygon::Polygon(), Slic3r::Polygon::Polygon(), Slic3r::Polyline::Polyline(), Slic3r::Polyline::Polyline(), Slic3r::Polyline::Polyline(), Slic3r::Polyline::Polyline(), operator=(), and operator=().

Here is the caller graph for this function:

MultiPoint() [2/6]

Slic3r::MultiPoint::MultiPoint ( const MultiPoint & other )

inline

: points(other.points) {}

References MultiPoint(), and points.

Here is the call graph for this function:

MultiPoint() [3/6]

Slic3r::MultiPoint::MultiPoint ( MultiPoint && other )

inlinenoexcept

: points(std::move(other.points)) {}

References MultiPoint().

Here is the call graph for this function:

MultiPoint() [4/6]

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

inline

: points(list) {}

References points.

MultiPoint() [5/6]

Slic3r::MultiPoint::MultiPoint ( const Points & _points )

inlineexplicit

: points(_points) {}

References points.

MultiPoint() [6/6]

Slic3r::MultiPoint::MultiPoint ( Points && _points )

inlineexplicitnoexcept

: points(std::move(_points)) {}

~MultiPoint()

virtual Slic3r::MultiPoint::~MultiPoint ( )

virtualdefault

Member Function Documentation

_douglas_peucker()

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

static

{
    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/4]

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

inline

{ this->points.push_back(point); }

Referenced by Slic3r::GCode::_do_export(), Slic3r::Polyline::append(), Slic3r::Polyline::append(), Slic3r::Polyline::append(), Slic3r::Polyline::append(), Slic3r::Polyline::append(), Slic3r::Polyline::append_before(), Slic3r::GUI::PartPlate::calc_imex_zones(), Slic3r::TreeSupport::draw_circles(), Slic3r::GUI::PartPlate::generate_exclude_polygon(), Slic3r::GUI::PartPlate::generate_logo_polygon(), Slic3r::GUI::PartPlate::generate_print_polygon(), Slic3r::GUI::PartPlateList::preprocess_exclude_areas(), Slic3r::GUI::PartPlate::render(), Slic3r::GUI::Bed_2D::repaint(), Slic3r::GCode::set_object_info(), and Slic3r::VoxelUtils::toPolygon().

Here is the caller graph for this function:

append() [2/4]

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

inline

{ this->append(src.begin(), src.end()); }

References append().

Referenced by append().

Here is the call graph for this function:

Here is the caller graph for this function:

append() [3/4]

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

inline

{ this->points.insert(this->points.end(), begin, end); }

References begin(), and end().

Here is the call graph for this function:

append() [4/4]

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

inline

    {
        if (this->points.empty()) {
            this->points = std::move(src);
        } else {
            this->points.insert(this->points.end(), src.begin(), src.end());
            src.clear();
        }
    }

back()

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

inline

{ 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 ( )

inline

{ 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

inline

{ return points.begin(); }

References points.

bounding_box()

BoundingBox Slic3r::MultiPoint::bounding_box

(

)

const

{
    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

inline

{ return points.begin(); }

References points.

cend()

auto Slic3r::MultiPoint::cend ( ) const

inline

{ return points.end();   }

References points.

clear()

void Slic3r::MultiPoint::clear ( )

inline

{ this->points.clear(); }

Referenced by Slic3r::Polyline::clear().

Here is the caller graph for this function:

closest_point()

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

inline

{ 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

inline

                                                       {
        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 )

static

{
    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

inline

                                                 {
        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

inline

{ 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 ( )

inline

{ 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

inline

{ return points.end();   }

References points.

find_point() [1/2]

int Slic3r::MultiPoint::find_point

(

const Point &

point

)

const

{
    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

{
    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

{
    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

inline

{ 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

inline

{ 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

{
    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

{
    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

{
    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

{
    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_valid()

bool Slic3r::MultiPoint::is_valid ( ) const

inline

{ 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()

virtual const Point & Slic3r::MultiPoint::last_point ( ) const

pure virtual

Implemented in Slic3r::Polygon, and Slic3r::Polyline.

length()

double Slic3r::MultiPoint::length

(

)

const

{
    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()

virtual Lines Slic3r::MultiPoint::lines ( ) const

pure virtual

Implemented in Slic3r::Polygon, and Slic3r::Polyline.

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

Here is the caller graph for this function:

minimumDistanceBetweenLinesDefinedByPoints()

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

static

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:

operator=() [1/2]

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

inline

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

References MultiPoint(), and points.

Here is the call graph for this function:

operator=() [2/2]

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

inlinenoexcept

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

References MultiPoint(), and points.

Here is the call graph for this function:

remove_duplicate_points()

bool Slic3r::MultiPoint::remove_duplicate_points

(

)

{
    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:

reverse()

void Slic3r::MultiPoint::reverse ( )

inline

{ std::reverse(this->points.begin(), this->points.end()); }

Referenced by Slic3r::Polyline::append_before(), Slic3r::TreeSupport3D::calculateMachineBorderCollision(), anonymous_namespace{EmbossJob.cpp}::cut_surface_to_its(), Slic3r::Polygon::make_clockwise(), Slic3r::Polygon::make_counter_clockwise(), Slic3r::arrangement::process_arrangeable(), Slic3r::Polyline::reverse(), and Slic3r::sweep_ex().

Here is the caller graph for this function:

rotate() [1/3]

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

inline

{ 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 )

{
    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 )

{
    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

)

{
    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 )

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

References points.

size()

size_t Slic3r::MultiPoint::size ( ) const

inline

{ 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().

squaredDistanceToLineSegment()

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

staticprivate

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

)

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

References points.

translate() [1/2]

void Slic3r::MultiPoint::translate

(

const Point &

vector

)

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

References points.

translate() [2/2]

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

inline

{ 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 )

static

{
    // 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

points

Points Slic3r::MultiPoint::points

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/MultiPoint.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/MultiPoint.cpp