Slic3r::Polyline3 Class Reference

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

Inheritance diagram for Slic3r::Polyline3:

Collaboration diagram for Slic3r::Polyline3:

Public Member Functions
	Polyline3 ()
	Polyline3 (const Points3 &points)
	Polyline3 (const Polyline &poly, coord_t z=0)
virtual Lines3	lines () const
Polyline	to_polyline () const
void	clip_end (double distance)
void	simplify (double tolerance)
void	simplify_by_fitting_arc (double tolerance)
void	reverse ()
bool	split_at_index (const size_t index, Polyline3 *p1, Polyline3 *p2) const
void	split_at (Point &point, Polyline3 *p1, Polyline3 *p2) const
void	split_at (Point3 &point, Polyline3 *p1, Polyline3 *p2) const
bool	split_at_length (const double length, Polyline3 *p1, Polyline3 *p2) const
void	append (const Point3 &point)
void	append (const Polyline3 &src)
void	append_before (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	rotate (double angle)
void	rotate (double cos_angle, double sin_angle)
void	rotate (double angle, const Point3 &center)
Point3 &	first_point ()
const Point3 &	first_point () const
Point3 &	last_point ()
const Point3 &	last_point () const
size_t	size () const
bool	empty () const
void	clear ()
auto	begin ()
auto	begin () const
auto	end ()
auto	end () const
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
std::vector< PathFittingData >	fitting_result
Points3	points

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

Detailed Description

Constructor & Destructor Documentation

Polyline3() [1/3]

Slic3r::Polyline3::Polyline3 ( )

inline

{}

Referenced by append(), append_fitting_result_after_append_polyline(), split_at(), split_at(), split_at_index(), and split_at_length().

Here is the caller graph for this function:

Polyline3() [2/3]

Slic3r::Polyline3::Polyline3 ( const Points3 & points )

inlineexplicit

{ this->points = points; }

References Slic3r::MultiPoint3::points.

Polyline3() [3/3]

Slic3r::Polyline3::Polyline3 ( const Polyline & poly, coord_t z = 0 )

inlineexplicit

                                                            {
        this->points.reserve(poly.points.size());
        for (const Point &pt : poly.points) {
            this->points.emplace_back(pt.x(), pt.y(), z);
        }
    }

References Slic3r::MultiPoint3::points.

Member Function Documentation

_douglas_peucker()

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

staticinherited

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

void Slic3r::MultiPoint3::append ( const Points3::const_iterator & begin, const Points3::const_iterator & end )

inlineinherited

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

References begin(), and end().

Here is the call graph for this function:

append() [2/4]

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

inlineinherited

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

append() [3/4]

void Slic3r::Polyline3::append

(

const Point3 &

point

)

{
    // // Don't append if same as last point
    // if (!this->empty() && this->last_point() == point)
    //     return;
 
    // this->points.push_back(point);
    // append_fitting_result_after_append_points();
 
    // BBS: don't need to append same point
    if (!this->empty() && this->last_point() == point)
        return;
    MultiPoint3::append(point);
    append_fitting_result_after_append_points();
}

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

Referenced by Slic3r::ExtrusionLoopSloped::ExtrusionLoopSloped(), append(), append_before(), Slic3r::contour_extrusion_path(), Slic3r::modulate_extrusion_by_overlapping_layers(), Slic3r::ExtrusionLoop::split_at(), split_at(), split_at_index(), split_at_length(), Slic3r::ExtrusionLoop::split_at_vertex(), Slic3r::thick_polyline_to_extrusion_paths_2(), and Slic3r::thick_polyline_to_multi_path().

Here is the call graph for this function:

Here is the caller graph for this function:

append() [4/4]

void Slic3r::Polyline3::append

(

const Polyline3 &

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
        MultiPoint3::append(src.points.begin() + 1, src.points.end());
        // BBS: finally append the fitting data
        append_fitting_result_after_append_polyline(src);
    }
}

References Polyline3(), Slic3r::MultiPoint3::append(), append(), append_fitting_result_after_append_polyline(), fitting_result, Slic3r::MultiPoint3::is_valid(), Slic3r::Linear_move, and Slic3r::MultiPoint3::points.

Here is the call graph for this function:

append_before()

void Slic3r::Polyline3::append_before

(

const Point3 &

point

)

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

References Slic3r::MultiPoint3::append(), append(), Slic3r::MultiPoint3::empty(), Slic3r::MultiPoint3::first_point(), fitting_result, Slic3r::MultiPoint3::reverse(), reverse(), and Slic3r::MultiPoint3::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::Polyline3::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::MultiPoint3::points.

Referenced by append().

Here is the caller graph for this function:

append_fitting_result_after_append_polyline()

void Slic3r::Polyline3::append_fitting_result_after_append_polyline ( const Polyline3 & 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 Polyline3(), fitting_result, Slic3r::Linear_move, and Slic3r::MultiPoint3::size().

Referenced by append().

Here is the call graph for this function:

Here is the caller graph for this function:

begin() [1/2]

auto Slic3r::MultiPoint3::begin ( )

inlineinherited

{ 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

inlineinherited

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

bounding_box()

BoundingBox3 Slic3r::MultiPoint3::bounding_box ( ) const

inherited

{ return BoundingBox3(this->points); }

References points.

clear()

void Slic3r::MultiPoint3::clear ( )

inlineinherited

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

clip_end()

void Slic3r::Polyline3::clip_end

(

double

distance

)

{
    bool   last_point_inserted = false;
    size_t remove_after_index  = MultiPoint3::size();
    while (distance > 0) {
        Vec3d last_point = this->last_point().cast<double>();
        this->points.pop_back();
        remove_after_index--;
        if (this->points.empty()) {
            this->fitting_result.clear();
            return;
        }
        Vec3d  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().to_point()))
                // BBS: succeed to clip arc, then update the last point
                // TODO: fix z parameter
                this->points.back() = Point3(fitting_result.back().arc_data.end_point, this->points.back().z());
            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, Slic3r::MultiPoint3::last_point(), Slic3r::Linear_move, Slic3r::MultiPoint3::points, and Slic3r::MultiPoint3::size().

Referenced by Slic3r::ExtrusionLoop::clip_end(), Slic3r::ExtrusionLoopSloped::clip_end(), and Slic3r::ExtrusionLoopSloped::clip_front().

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

bool Slic3r::MultiPoint3::empty ( ) const

inlineinherited

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

inlineinherited

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

Referenced by append().

Here is the caller graph for this function:

end() [2/2]

auto Slic3r::MultiPoint3::end ( ) const

inlineinherited

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

find_point() [1/4]

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

inherited

{
    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

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

inherited

{
    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

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

inlineinherited

{ 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

inlineinherited

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

is_valid()

bool Slic3r::MultiPoint3::is_valid ( ) const

inlineinherited

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

inlineinherited

{ 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

inlineinherited

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

length()

double Slic3r::MultiPoint3::length ( ) const

inherited

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

Lines3 Slic3r::Polyline3::lines ( ) const

virtual

Implements Slic3r::MultiPoint3.

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

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

Referenced by Slic3r::GCode::_extrude(), lines(), split_at(), split_at_length(), and Slic3r::split_at_slope_end().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_duplicate_points()

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

reverse()

void Slic3r::Polyline3::reverse

(

)

{
    // BBS: reverse points
    MultiPoint3::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 = MultiPoint3::size() - 1 - fitting_result[i].start_point_index;
            fitting_result[i].end_point_index   = MultiPoint3::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::MultiPoint3::reverse(), and Slic3r::MultiPoint3::size().

Referenced by append_before(), Slic3r::ExtrusionLoopSloped::clip_front(), and Slic3r::ExtrusionPath::reverse().

Here is the call graph for this function:

Here is the caller graph for this function:

rotate() [1/3]

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

inlineinherited

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

inherited

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

inherited

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

simplify()

void Slic3r::Polyline3::simplify

(

double

tolerance

)

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

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

Here is the call graph for this function:

simplify_by_fitting_arc()

void Slic3r::Polyline3::simplify_by_fitting_arc

(

double

tolerance

)

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

References Slic3r::ArcFitter::do_arc_fitting_and_simplify(), fitting_result, Slic3r::MultiPoint3::points, Slic3r::to_points(), and Slic3r::to_points3().

Here is the call graph for this function:

size()

size_t Slic3r::MultiPoint3::size ( ) const

inlineinherited

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

split_at() [1/2]

void Slic3r::Polyline3::split_at	(	Point &	point,
		Polyline3 *	p1,
		Polyline3 *	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().to_point() : p2->first_point().to_point();
        return;
    }
 
    // 1 find the line to split at
    size_t line_idx = 0;
    Point p = this->first_point().to_point();
    double min = (p - point).cast<double>().norm();
    Lines3 lines = this->lines();
    for (Lines3::const_iterator line = lines.begin(); line != lines.end(); ++line) {
        Point p_tmp = point.projection_onto(line->to_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(Point3(point, p1->last_point().z()));
        p2->append_before(Point3(point, p2->first_point().z()));
    } else {
        Polyline3 temp;
        this->split_at_index(line_idx, p1, &temp);
        p1->append(Point3(point, p1->last_point().z()));
        this->split_at_index(line_idx + 1, &temp, p2);
        p2->append_before(Point3(point, p2->first_point().z()));
    }
}

References Polyline3(), append(), append_before(), Slic3r::cast(), Slic3r::MultiPoint3::find_point(), Slic3r::MultiPoint3::first_point(), Slic3r::MultiPoint3::is_valid(), Slic3r::MultiPoint3::last_point(), lines(), Slic3r::MultiPoint3::points, Slic3r::Point::projection_onto(), split_at_index(), and Slic3r::Point3::to_point().

Referenced by Slic3r::ExtrusionLoop::split_at(), and split_at().

Here is the call graph for this function:

Here is the caller graph for this function:

split_at() [2/2]

void Slic3r::Polyline3::split_at	(	Point3 &	point,
		Polyline3 *	p1,
		Polyline3 *	p2 ) const

                                                                          {
    Point p = point.to_point();
    this->split_at(p, p1, p2);
    point = Point3(p, point.z());
}

References Polyline3(), split_at(), and Slic3r::Point3::to_point().

Here is the call graph for this function:

split_at_index()

bool Slic3r::Polyline3::split_at_index	(	const size_t	index,
		Polyline3 *	p1,
		Polyline3 *	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);
        Point3 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());
        Point3 new_startpoint;
        if (this->split_fitting_result_after_index(index, new_startpoint, p2->fitting_result))
            p2->points.front() = new_startpoint;
    }
    return true;
}

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

Referenced by split_at(), split_at_length(), Slic3r::split_at_slope_end(), and Slic3r::ExtrusionLoop::split_at_vertex().

Here is the call graph for this function:

Here is the caller graph for this function:

split_at_length()

bool Slic3r::Polyline3::split_at_length	(	const double	length,
		Polyline3 *	p1,
		Polyline3 *	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;
        Point3 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 {
            Polyline3 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 Polyline3(), append(), append_before(), Slic3r::MultiPoint3::clear(), Slic3r::MultiPoint3::find_point(), Slic3r::MultiPoint3::first_point(), Slic3r::is_approx(), Slic3r::MultiPoint3::last_point(), Slic3r::MultiPoint3::length(), Slic3r::lerp(), lines(), Slic3r::MultiPoint3::points, SCALED_EPSILON, and split_at_index().

Referenced by Slic3r::ExtrusionLoopSloped::ExtrusionLoopSloped(), and Slic3r::split_at_slope_end().

Here is the call graph for this function:

Here is the caller graph for this function:

split_fitting_result_after_index()

bool Slic3r::Polyline3::split_fitting_result_after_index ( size_t index, Point3 & new_startpoint, std::vector< PathFittingData > & result ) 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].to_point()))
                            // 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 = Point3(data.front().arc_data.start_point, 0);
                    }
                    data[i].start_point_index = 0;
                }
            }
        }
        data.shrink_to_fit();
        return true;
    }
    return false;
}

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

Referenced by split_at_index().

Here is the caller graph for this function:

split_fitting_result_before_index()

bool Slic3r::Polyline3::split_fitting_result_before_index ( size_t index, Point3 & new_endpoint, std::vector< PathFittingData > & result ) 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].to_point()))
                    // 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 = Point3(data.back().arc_data.end_point, 0);
            }
            data.back().end_point_index = index;
        }
        data.shrink_to_fit();
        return true;
    }
    return false;
}

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

Referenced by split_at_index().

Here is the caller graph for this function:

to_polyline()

Polyline Slic3r::Polyline3::to_polyline

(

)

const

{
    Polyline out;
    out.points.reserve(this->points.size());
    for (const Point3 &point : this->points) {
        out.points.emplace_back(point.x(), point.y());
    }
    return out;
}

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

Referenced by Slic3r::ExtrusionPath::as_polyline(), Slic3r::ExtrusionPath::collect_polylines(), libvgcode::convert_to_vertices(), libvgcode::convert_to_vertices(), libvgcode::convert_to_vertices(), Slic3r::GCode::extrude_path(), Slic3r::extrusionentity_extents(), Slic3r::extrusionentity_extents(), Slic3r::extrusionentity_extents(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::modulate_extrusion_by_overlapping_layers(), Slic3r::offset(), and Slic3r::traverse_extrusions().

Here is the caller graph for this function:

translate() [1/2]

void Slic3r::MultiPoint3::translate ( const Point3 & vector )

inherited

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

References points.

translate() [2/2]

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

inlineinherited

{ 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

fitting_result

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

Referenced by Slic3r::GCode::_extrude(), append(), append_before(), append_fitting_result_after_append_points(), append_fitting_result_after_append_polyline(), clip_end(), reverse(), simplify(), simplify_by_fitting_arc(), Slic3r::ExtrusionLoop::split_at(), split_at_index(), Slic3r::ExtrusionLoop::split_at_vertex(), split_fitting_result_after_index(), and split_fitting_result_before_index().

points

Points3 Slic3r::MultiPoint3::points

inherited

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