Slic3r::MultiPoint3 Class Reference

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

Inheritance diagram for Slic3r::MultiPoint3:

Collaboration diagram for Slic3r::MultiPoint3:

Public Member Functions
void	append (const Point3 &point)
void	append (const Vec3crd &point)
void	append (const Points3::const_iterator &begin, const Points3::const_iterator &end)
void	translate (double x, double y, double z=0)
void	translate (const Point3 &vector)
void	reverse ()
void	rotate (double angle)
void	rotate (double cos_angle, double sin_angle)
void	rotate (double angle, const Point3 &center)
Point3 &	first_point ()
Point3 &	last_point ()
const Point3 &	first_point () const
const Point3 &	last_point () const
size_t	size () const
bool	empty () const
void	clear ()
auto	begin ()
auto	end ()
auto	begin () const
auto	end () const
virtual Lines3	lines () const =0
double	length () const
bool	is_valid () const
BoundingBox3	bounding_box () const
int	find_point (const Point &point) const
int	find_point (const Point &point, const double scaled_epsilon) const
int	find_point (const Point3 &point) const
int	find_point (const Point3 &point, const double scaled_epsilon) const
bool	remove_duplicate_points ()

Static Public Member Functions
static Points3	_douglas_peucker (const Points3 &points, double tolerance)

Public Attributes
Points3	points

Detailed Description

Member Function Documentation

_douglas_peucker()

Points3 Slic3r::MultiPoint3::_douglas_peucker ( const Points3 & points, double tolerance )

static

{
    Points3 result_pts;
    double  tolerance_sq = tolerance * tolerance;
    if (!pts.empty()) {
        const Point3* anchor      = &pts.front();
        size_t        anchor_idx  = 0;
        const Point3* 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 = Line3::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::Line3::distance_to_squared(), Slic3r::SVG::draw(), Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), and scale_.

Referenced by Slic3r::Polyline3::simplify().

Here is the call graph for this function:

Here is the caller graph for this function:

append() [1/3]

void Slic3r::MultiPoint3::append ( const Point3 & point )

inline

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

Referenced by Slic3r::Polyline3::append(), Slic3r::Polyline3::append(), and Slic3r::Polyline3::append_before().

Here is the caller graph for this function:

append() [2/3]

void Slic3r::MultiPoint3::append ( const Points3::const_iterator & begin, const Points3::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() [3/3]

void Slic3r::MultiPoint3::append ( const Vec3crd & point )

inline

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

begin() [1/2]

auto Slic3r::MultiPoint3::begin ( )

inline

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

Referenced by append(), and Slic3r::Polyline3::split_at_index().

Here is the caller graph for this function:

begin() [2/2]

auto Slic3r::MultiPoint3::begin ( ) const

inline

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

bounding_box()

BoundingBox3 Slic3r::MultiPoint3::bounding_box

(

)

const

{ return BoundingBox3(this->points); }

References points.

clear()

void Slic3r::MultiPoint3::clear ( )

inline

{ this->points.clear(); }

Referenced by Slic3r::ExtrusionLoopSloped::ExtrusionLoopSloped(), Slic3r::FakeWipeTower::getFakeExtrusionPathsFromWipeTower2(), Slic3r::Polyline3::split_at_index(), and Slic3r::Polyline3::split_at_length().

Here is the caller graph for this function:

empty()

bool Slic3r::MultiPoint3::empty ( ) const

inline

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

Referenced by Slic3r::ExtrusionLoopSloped::ExtrusionLoopSloped(), Slic3r::Polyline3::append(), Slic3r::Polyline3::append_before(), Slic3r::SupportMaterialInternal::collect_bridging_perimeter_areas(), Slic3r::ExtrusionPath::collect_polylines(), Slic3r::ExtrusionPath::empty(), and Slic3r::SupportMaterialInternal::has_bridging_perimeters().

Here is the caller graph for this function:

end() [1/2]

auto Slic3r::MultiPoint3::end ( )

inline

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

Referenced by append().

Here is the caller graph for this function:

end() [2/2]

auto Slic3r::MultiPoint3::end ( ) const

inline

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

find_point() [1/4]

int Slic3r::MultiPoint3::find_point

(

const Point &

point

)

const

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

References points.

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

Here is the caller graph for this function:

find_point() [2/4]

int Slic3r::MultiPoint3::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 Point3 &pt : this->points) {
        double d2 = (pt.to_point() - 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 find_point(), and points.

Here is the call graph for this function:

find_point() [3/4]

int Slic3r::MultiPoint3::find_point

(

const Point3 &

point

)

const

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

References points.

find_point() [4/4]

int Slic3r::MultiPoint3::find_point	(	const Point3 &	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 Point3 &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_point() [1/2]

Point3 & Slic3r::MultiPoint3::first_point ( )

inline

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

Referenced by Slic3r::Polyline3::append_before(), Slic3r::Polyline3::split_at(), Slic3r::Polyline3::split_at_index(), and Slic3r::Polyline3::split_at_length().

Here is the caller graph for this function:

first_point() [2/2]

const Point3 & Slic3r::MultiPoint3::first_point ( ) const

inline

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

is_valid()

bool Slic3r::MultiPoint3::is_valid ( ) const

inline

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

Referenced by Slic3r::Polyline3::append(), Slic3r::ExtrusionLoop::split_at(), Slic3r::Polyline3::split_at(), Slic3r::ExtrusionLoop::split_at_vertex(), and Slic3r::thick_polyline_to_multi_path().

Here is the caller graph for this function:

last_point() [1/2]

Point3 & Slic3r::MultiPoint3::last_point ( )

inline

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

Referenced by Slic3r::Polyline3::append(), Slic3r::Polyline3::clip_end(), Slic3r::Polyline3::split_at(), Slic3r::Polyline3::split_at_index(), and Slic3r::Polyline3::split_at_length().

Here is the caller graph for this function:

last_point() [2/2]

const Point3 & Slic3r::MultiPoint3::last_point ( ) const

inline

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

length()

double Slic3r::MultiPoint3::length

(

)

const

{
    const Lines3& 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::ExtrusionLoopSloped::ExtrusionLoopSloped(), Slic3r::GCode::_extrude(), and Slic3r::Polyline3::split_at_length().

Here is the call graph for this function:

Here is the caller graph for this function:

lines()

virtual Lines3 Slic3r::MultiPoint3::lines ( ) const

pure virtual

Implemented in Slic3r::Polyline3.

Referenced by length().

Here is the caller graph for this function:

remove_duplicate_points()

bool Slic3r::MultiPoint3::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.

reverse()

void Slic3r::MultiPoint3::reverse ( )

inline

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

Referenced by Slic3r::Polyline3::append_before(), and Slic3r::Polyline3::reverse().

Here is the caller graph for this function:

rotate() [1/3]

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

inline

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

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

Referenced by rotate().

Here is the call graph for this function:

Here is the caller graph for this function:

rotate() [2/3]

void Slic3r::MultiPoint3::rotate	(	double	angle,
		const Point3 &	center )

{
    double s = sin(angle);
    double c = cos(angle);
    for (Point3 &pt : points) {
        Vec3crd 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]);
        // Keep Z unchanged from original point
    }
}

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

Here is the call graph for this function:

rotate() [3/3]

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

{
    for (Point3 &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));
        // Keep Z unchanged
    }
}

References points.

size()

size_t Slic3r::MultiPoint3::size ( ) const

inline

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

Referenced by Slic3r::ExtrusionLoopSloped::ExtrusionLoopSloped(), Slic3r::Polyline3::append_before(), Slic3r::Polyline3::append_fitting_result_after_append_polyline(), Slic3r::Polyline3::clip_end(), Slic3r::paths_touch(), Slic3r::Polyline3::reverse(), Slic3r::ExtrusionPath::size(), and Slic3r::Polyline3::split_at_index().

Here is the caller graph for this function:

translate() [1/2]

void Slic3r::MultiPoint3::translate

(

const Point3 &

vector

)

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

References points.

translate() [2/2]

void Slic3r::MultiPoint3::translate ( double x, double y, double z = 0 )

inline

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

References translate().

Referenced by translate().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

points

Points3 Slic3r::MultiPoint3::points

Referenced by Slic3r::Polyline3::Polyline3(), Slic3r::Polyline3::Polyline3(), Slic3r::GCode::_extrude(), Slic3r::Polyline3::append(), Slic3r::Polyline3::append_fitting_result_after_append_points(), bounding_box(), Slic3r::Polyline3::clip_end(), Slic3r::SupportMaterialInternal::collect_bridging_perimeter_areas(), Slic3r::ExtrusionLoop::collect_points(), Slic3r::ExtrusionMultiPath::collect_points(), Slic3r::ExtrusionPath::collect_points3(), Slic3r::contour_extrusion_path(), Slic3r::GCode::extrude_path(), Slic3r::ExtrusionSimulator::extrude_to_accumulator(), Slic3r::extrusion_entities_append_loops(), find_point(), find_point(), find_point(), find_point(), Slic3r::ExtrusionPath::first_point(), Slic3r::ExtrusionPath::first_point3(), Slic3r::FakeWipeTower::getFakeExtrusionPathsFromWipeTower2(), Slic3r::FakeWipeTower::getTrueExtrusionLayersFromWipeTower(), Slic3r::ExtrusionPath::is_closed(), Slic3r::ExtrusionPath::last_point(), Slic3r::ExtrusionPath::last_point3(), Slic3r::Polyline3::lines(), Slic3r::modulate_extrusion_by_overlapping_layers(), Slic3r::paths_touch(), remove_duplicate_points(), rotate(), rotate(), Slic3r::Polyline3::simplify(), Slic3r::Polyline3::simplify_by_fitting_arc(), Slic3r::ExtrusionLoop::split_at(), Slic3r::Polyline3::split_at(), Slic3r::Polyline3::split_at_index(), Slic3r::Polyline3::split_at_length(), Slic3r::ExtrusionLoop::split_at_vertex(), Slic3r::Polyline3::split_fitting_result_after_index(), Slic3r::Polyline3::split_fitting_result_before_index(), Slic3r::thick_polyline_to_multi_path(), Slic3r::Polyline3::to_polyline(), and translate().

---

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