Slic3r::ExtrusionLoop Class Reference

#include <src/libslic3r/ExtrusionEntity.hpp>

Inheritance diagram for Slic3r::ExtrusionLoop:

Collaboration diagram for Slic3r::ExtrusionLoop:

Classes
struct	ClosestPathPoint

Public Member Functions
	ExtrusionLoop (ExtrusionLoopRole role=elrDefault)
	ExtrusionLoop (const ExtrusionPaths &paths, ExtrusionLoopRole role=elrDefault)
	ExtrusionLoop (ExtrusionPaths &&paths, ExtrusionLoopRole role=elrDefault)
	ExtrusionLoop (const ExtrusionPath &path, ExtrusionLoopRole role=elrDefault)
	ExtrusionLoop (ExtrusionPath &&path, ExtrusionLoopRole role=elrDefault)
bool	is_loop () const override
bool	can_reverse () const override
ExtrusionEntity *	clone () const override
ExtrusionEntity *	clone_move () override
bool	make_clockwise ()
bool	make_counter_clockwise ()
void	reverse () override
const Point &	first_point () const override
const Point &	last_point () const override
const Point &	middle_point () const override
Polygon	polygon () const
double	length () const override
bool	split_at_vertex (const Point &point, const double scaled_epsilon=scaled< double >(0.001))
void	split_at (const Point &point, bool prefer_non_overhang, const double scaled_epsilon=scaled< double >(0.001))
ClosestPathPoint	get_closest_path_and_point (const Point &point, bool prefer_non_overhang) const
void	clip_end (double distance, ExtrusionPaths *paths) const
bool	has_overhang_point (const Point &point) const
ExtrusionRole	role () const override
ExtrusionLoopRole	loop_role () const
void	polygons_covered_by_width (Polygons &out, const float scaled_epsilon) const override
void	polygons_covered_by_spacing (Polygons &out, const float scaled_epsilon) const override
Polygons	polygons_covered_by_width (const float scaled_epsilon=0.f) const
Polygons	polygons_covered_by_spacing (const float scaled_epsilon=0.f) const
double	min_mm3_per_mm () const override
Polyline	as_polyline () const override
void	collect_polylines (Polylines &dst) const override
void	collect_points (Points &dst) const override
double	total_volume () const override
bool	validate () const
virtual bool	is_collection () const
virtual Polylines	as_polylines () const

Public Attributes
ExtrusionPaths	paths

Private Attributes
ExtrusionLoopRole	m_loop_role

Detailed Description

---

Class Documentation

Slic3r::ExtrusionLoop::ClosestPathPoint

struct Slic3r::ExtrusionLoop::ClosestPathPoint

Class Members
Point	foot_pt
size_t	path_idx
size_t	segment_idx

Constructor & Destructor Documentation

ExtrusionLoop() [1/5]

Slic3r::ExtrusionLoop::ExtrusionLoop ( ExtrusionLoopRole  role = elrDefault )

inline

: m_loop_role(role) {}

ExtrusionLoop() [2/5]

Slic3r::ExtrusionLoop::ExtrusionLoop ( const ExtrusionPaths &  paths, ExtrusionLoopRole  role = elrDefault  )

inline

: paths(paths), m_loop_role(role) {}

ExtrusionLoop() [3/5]

Slic3r::ExtrusionLoop::ExtrusionLoop ( ExtrusionPaths &&  paths, ExtrusionLoopRole  role = elrDefault  )

inline

: paths(std::move(paths)), m_loop_role(role) {}

ExtrusionLoop() [4/5]

Slic3r::ExtrusionLoop::ExtrusionLoop ( const ExtrusionPath &  path, ExtrusionLoopRole  role = elrDefault  )

inline

                                                                                  : m_loop_role(role) 
        { this->paths.push_back(path); }

ExtrusionLoop() [5/5]

Slic3r::ExtrusionLoop::ExtrusionLoop ( ExtrusionPath &&  path, ExtrusionLoopRole  role = elrDefault  )

inline

                                                                             : m_loop_role(role)
        { this->paths.emplace_back(std::move(path)); }

Member Function Documentation

as_polyline()

Polyline Slic3r::ExtrusionLoop::as_polyline ( ) const

inlineoverridevirtual

Implements Slic3r::ExtrusionEntity.

{ return this->polygon().split_at_first_point(); }

References polygon(), and Slic3r::Polygon::split_at_first_point().

Referenced by collect_polylines().

Here is the call graph for this function:

Here is the caller graph for this function:

as_polylines()

virtual Polylines Slic3r::ExtrusionEntity::as_polylines ( ) const

inlinevirtualinherited

{ Polylines dst; this->collect_polylines(dst); return dst; }

References Slic3r::ExtrusionEntity::collect_polylines().

Referenced by Slic3r::FFFSupport::remove_bridges_from_contacts().

Here is the call graph for this function:

Here is the caller graph for this function:

can_reverse()

bool Slic3r::ExtrusionLoop::can_reverse ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::ExtrusionEntity.

{ return false; }

clip_end()

void Slic3r::ExtrusionLoop::clip_end	(	double	distance,
		ExtrusionPaths *	paths
	)		const

{
    *paths = this->paths;
    
    while (distance > 0 && !paths->empty()) {
        ExtrusionPath &last = paths->back();
        double len = last.length();
        if (len <= distance) {
            paths->pop_back();
            distance -= len;
        } else {
            last.polyline.clip_end(distance);
            break;
        }
    }
}

References Slic3r::Polyline::clip_end(), Slic3r::ExtrusionPath::length(), paths, and Slic3r::ExtrusionPath::polyline.

Here is the call graph for this function:

clone()

ExtrusionEntity * Slic3r::ExtrusionLoop::clone ( ) const

inlineoverridevirtual

Implements Slic3r::ExtrusionEntity.

{ return new ExtrusionLoop (*this); }

clone_move()

ExtrusionEntity * Slic3r::ExtrusionLoop::clone_move ( )

inlineoverridevirtual

Implements Slic3r::ExtrusionEntity.

{ return new ExtrusionLoop(std::move(*this)); }

collect_points()

void Slic3r::ExtrusionLoop::collect_points ( Points &  dst ) const

inlineoverridevirtual

Implements Slic3r::ExtrusionEntity.

                                                      { 
        size_t n = std::accumulate(paths.begin(), paths.end(), 0, [](const size_t n, const ExtrusionPath &p){ return n + p.polyline.size(); });
        dst.reserve(dst.size() + n);
        for (const ExtrusionPath &p : this->paths)
            append(dst, p.polyline.points);
    }

References Slic3r::append(), paths, Slic3r::MultiPoint::points, and Slic3r::ExtrusionPath::polyline.

Here is the call graph for this function:

collect_polylines()

void Slic3r::ExtrusionLoop::collect_polylines ( Polylines &  dst ) const

inlineoverridevirtual

Implements Slic3r::ExtrusionEntity.

{ Polyline pl = this->as_polyline(); if (! pl.empty()) dst.emplace_back(std::move(pl)); }

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

Here is the call graph for this function:

first_point()

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

inlineoverridevirtual

Implements Slic3r::ExtrusionEntity.

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

Referenced by last_point(), and validate().

Here is the caller graph for this function:

get_closest_path_and_point()

ExtrusionLoop::ClosestPathPoint Slic3r::ExtrusionLoop::get_closest_path_and_point	(	const Point &	point,
		bool	prefer_non_overhang
	)		const

{
    // Find the closest path and closest point belonging to that path. Avoid overhangs, if asked for.
    ClosestPathPoint out { 0, 0 };
    double           min2 = std::numeric_limits<double>::max();
    ClosestPathPoint best_non_overhang { 0, 0 };
    double           min2_non_overhang = std::numeric_limits<double>::max();
    for (const ExtrusionPath &path : this->paths) {
        std::pair<int, Point> foot_pt_ = foot_pt(path.polyline.points, point);
        double d2 = (foot_pt_.second - point).cast<double>().squaredNorm();
        if (d2 < min2) {
            out.foot_pt     = foot_pt_.second;
            out.path_idx    = &path - &this->paths.front();
            out.segment_idx = foot_pt_.first;
            min2            = d2;
        }
        if (prefer_non_overhang && ! path.role().is_bridge() && d2 < min2_non_overhang) {
            best_non_overhang.foot_pt     = foot_pt_.second;
            best_non_overhang.path_idx    = &path - &this->paths.front();
            best_non_overhang.segment_idx = foot_pt_.first;
            min2_non_overhang             = d2;
        }
    }
    if (prefer_non_overhang && min2_non_overhang != std::numeric_limits<double>::max())
        // Only apply the non-overhang point if there is one.
        out = best_non_overhang;
    return out;
}

References Slic3r::foot_pt(), and paths.

Referenced by split_at().

Here is the call graph for this function:

Here is the caller graph for this function:

has_overhang_point()

bool Slic3r::ExtrusionLoop::has_overhang_point

(

const Point &

point

)

const

{
    for (const ExtrusionPath &path : this->paths) {
        int pos = path.polyline.find_point(point);
        if (pos != -1) {
            // point belongs to this path
            // we consider it overhang only if it's not an endpoint
            return (path.role().is_bridge() && pos > 0 && pos != int(path.polyline.points.size())-1);
        }
    }
    return false;
}

References paths.

is_collection()

virtual bool Slic3r::ExtrusionEntity::is_collection ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::ExtrusionEntityCollection.

{ return false; }

Referenced by Slic3r::SupportSpotsGenerator::check_extrusion_entity_stability(), Slic3r::SupportSpotsGenerator::check_stability(), Slic3r::Layer::sort_perimeters_into_islands(), and Slic3r::SupportSpotsGenerator::to_short_lines().

Here is the caller graph for this function:

is_loop()

bool Slic3r::ExtrusionLoop::is_loop ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::ExtrusionEntity.

{ return true; }

last_point()

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

inlineoverridevirtual

Implements Slic3r::ExtrusionEntity.

{ assert(this->first_point() == this->paths.back().polyline.points.back()); return this->first_point(); }

References first_point().

Here is the call graph for this function:

length()

double Slic3r::ExtrusionLoop::length ( ) const

overridevirtual

Implements Slic3r::ExtrusionEntity.

{
    double len = 0;
    for (const ExtrusionPath &path : this->paths)
        len += path.polyline.length();
    return len;
}

References paths.

loop_role()

ExtrusionLoopRole Slic3r::ExtrusionLoop::loop_role ( ) const

inline

{ return m_loop_role; }

References m_loop_role.

make_clockwise()

bool Slic3r::ExtrusionLoop::make_clockwise

(

)

{
    bool was_ccw = this->polygon().is_counter_clockwise();
    if (was_ccw) this->reverse();
    return was_ccw;
}

References Slic3r::Polygon::is_counter_clockwise(), polygon(), and reverse().

Referenced by Slic3r::traverse_extrusions(), and Slic3r::traverse_loops_classic().

Here is the call graph for this function:

Here is the caller graph for this function:

make_counter_clockwise()

bool Slic3r::ExtrusionLoop::make_counter_clockwise

(

)

{
    bool was_cw = this->polygon().is_clockwise();
    if (was_cw) this->reverse();
    return was_cw;
}

References Slic3r::Polygon::is_clockwise(), polygon(), and reverse().

Referenced by Slic3r::traverse_extrusions(), and Slic3r::traverse_loops_classic().

Here is the call graph for this function:

Here is the caller graph for this function:

middle_point()

const Point & Slic3r::ExtrusionLoop::middle_point ( ) const

inlineoverridevirtual

Implements Slic3r::ExtrusionEntity.

{ auto& path = this->paths[this->paths.size() / 2]; return path.polyline.points[path.polyline.size() / 2]; }

min_mm3_per_mm()

double Slic3r::ExtrusionLoop::min_mm3_per_mm ( ) const

overridevirtual

Implements Slic3r::ExtrusionEntity.

{
    double min_mm3_per_mm = std::numeric_limits<double>::max();
    for (const ExtrusionPath &path : this->paths)
        min_mm3_per_mm = std::min(min_mm3_per_mm, path.mm3_per_mm);
    return min_mm3_per_mm;
}

References min_mm3_per_mm(), and paths.

Referenced by min_mm3_per_mm().

Here is the call graph for this function:

Here is the caller graph for this function:

polygon()

Polygon Slic3r::ExtrusionLoop::polygon

(

)

const

{
    Polygon polygon;
    for (const ExtrusionPath &path : this->paths) {
        // for each polyline, append all points except the last one (because it coincides with the first one of the next polyline)
        polygon.points.insert(polygon.points.end(), path.polyline.points.begin(), path.polyline.points.end()-1);
    }
    return polygon;
}

References paths, Slic3r::MultiPoint::points, and polygon().

Referenced by as_polyline(), make_clockwise(), make_counter_clockwise(), and polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

polygons_covered_by_spacing() [1/2]

Polygons Slic3r::ExtrusionLoop::polygons_covered_by_spacing ( const float  scaled_epsilon = 0.f ) const

inline

        { Polygons out; this->polygons_covered_by_spacing(out, scaled_epsilon); return out; }

References polygons_covered_by_spacing().

Here is the call graph for this function:

polygons_covered_by_spacing() [2/2]

void Slic3r::ExtrusionLoop::polygons_covered_by_spacing ( Polygons &  out, const float  scaled_epsilon  ) const

overridevirtual

Implements Slic3r::ExtrusionEntity.

{
    for (const ExtrusionPath &path : this->paths)
        path.polygons_covered_by_spacing(out, scaled_epsilon);
}

References paths.

Referenced by polygons_covered_by_spacing().

Here is the caller graph for this function:

polygons_covered_by_width() [1/2]

Polygons Slic3r::ExtrusionLoop::polygons_covered_by_width ( const float  scaled_epsilon = 0.f ) const

inline

        { Polygons out; this->polygons_covered_by_width(out, scaled_epsilon); return out; }

References polygons_covered_by_width().

Here is the call graph for this function:

polygons_covered_by_width() [2/2]

void Slic3r::ExtrusionLoop::polygons_covered_by_width ( Polygons &  out, const float  scaled_epsilon  ) const

overridevirtual

Implements Slic3r::ExtrusionEntity.

{
    for (const ExtrusionPath &path : this->paths)
        path.polygons_covered_by_width(out, scaled_epsilon);
}

References paths.

Referenced by polygons_covered_by_width().

Here is the caller graph for this function:

reverse()

void Slic3r::ExtrusionLoop::reverse ( )

overridevirtual

Implements Slic3r::ExtrusionEntity.

{
    for (ExtrusionPath &path : this->paths)
        path.reverse();
    std::reverse(this->paths.begin(), this->paths.end());
}

References paths.

Referenced by make_clockwise(), and make_counter_clockwise().

Here is the caller graph for this function:

role()

ExtrusionRole Slic3r::ExtrusionLoop::role ( ) const

inlineoverridevirtual

Implements Slic3r::ExtrusionEntity.

{ return this->paths.empty() ? ExtrusionRole::None : this->paths.front().role(); }

References Slic3r::ExtrusionRole::None.

split_at()

void Slic3r::ExtrusionLoop::split_at	(	const Point &	point,
		bool	prefer_non_overhang,
		const double	scaled_epsilon = scaled<double>(0.001)
	)

{
    if (this->paths.empty())
        return;
    
    auto [path_idx, segment_idx, p] = get_closest_path_and_point(point, prefer_non_overhang);
 
    // Snap p to start or end of segment_idx if closer than scaled_epsilon.
    {
        const Point *p1 = this->paths[path_idx].polyline.points.data() + segment_idx;
        const Point *p2 = p1;
        ++ p2;
        double d2_1 = (point - *p1).cast<double>().squaredNorm();
        double d2_2 = (point - *p2).cast<double>().squaredNorm();
        const double thr2 = scaled_epsilon * scaled_epsilon;
        if (d2_1 < d2_2) {
            if (d2_1 < thr2)
                p = *p1;
        } else {
            if (d2_2 < thr2) 
                p = *p2;
        }
    }
    
    // now split path_idx in two parts
    const ExtrusionPath &path = this->paths[path_idx];
    ExtrusionPath p1(path.role(), path.mm3_per_mm, path.width, path.height);
    ExtrusionPath p2(path.role(), path.mm3_per_mm, path.width, path.height);
    path.polyline.split_at(p, &p1.polyline, &p2.polyline);
    
    if (this->paths.size() == 1) {
        if (p2.polyline.is_valid()) {
            if (p1.polyline.is_valid())
                p2.polyline.points.insert(p2.polyline.points.end(), p1.polyline.points.begin() + 1, p1.polyline.points.end());
            this->paths.front().polyline.points = std::move(p2.polyline.points);
        } else
            this->paths.front().polyline.points = std::move(p1.polyline.points);
    } else {
        // install the two paths
        this->paths.erase(this->paths.begin() + path_idx);
        if (p2.polyline.is_valid()) this->paths.insert(this->paths.begin() + path_idx, p2);
        if (p1.polyline.is_valid()) this->paths.insert(this->paths.begin() + path_idx, p1);
    }
    
    // split at the new vertex
    this->split_at_vertex(p, 0.);
}

References get_closest_path_and_point(), Slic3r::ExtrusionPath::height, Slic3r::MultiPoint::is_valid(), Slic3r::ExtrusionPath::mm3_per_mm, paths, Slic3r::MultiPoint::points, Slic3r::ExtrusionPath::polyline, Slic3r::ExtrusionPath::role(), Slic3r::Polyline::split_at(), split_at_vertex(), and Slic3r::ExtrusionPath::width.

Here is the call graph for this function:

split_at_vertex()

bool Slic3r::ExtrusionLoop::split_at_vertex	(	const Point &	point,
		const double	scaled_epsilon = scaled<double>(0.001)
	)

{
    for (ExtrusionPaths::iterator path = this->paths.begin(); path != this->paths.end(); ++path)
        if (int idx = path->polyline.find_point(point, scaled_epsilon); idx != -1) {
            if (this->paths.size() == 1) {
                // just change the order of points
                path->polyline.points.insert(path->polyline.points.end(), path->polyline.points.begin() + 1, path->polyline.points.begin() + idx + 1);
                path->polyline.points.erase(path->polyline.points.begin(), path->polyline.points.begin() + idx);
            } else {
                // new paths list starts with the second half of current path
                ExtrusionPaths new_paths;
                new_paths.reserve(this->paths.size() + 1);
                {
                    ExtrusionPath p = *path;
                    p.polyline.points.erase(p.polyline.points.begin(), p.polyline.points.begin() + idx);
                    if (p.polyline.is_valid())
                        new_paths.emplace_back(std::move(p));
                }
            
                // then we add all paths until the end of current path list
                std::move(path + 1, this->paths.end(), std::back_inserter(new_paths)); // not including this path
 
                // then we add all paths since the beginning of current list up to the previous one
                std::move(this->paths.begin(), path, std::back_inserter(new_paths)); // not including this path
            
                // finally we add the first half of current path
                {
                    ExtrusionPath &p = *path;
                    p.polyline.points.erase(p.polyline.points.begin() + idx + 1, p.polyline.points.end());
                    if (p.polyline.is_valid())
                        new_paths.emplace_back(std::move(p));
                }
                // we can now override the old path list with the new one and stop looping
                this->paths = std::move(new_paths);
            }
            return true;
        }
    // The point was not found.
    return false;
}

References Slic3r::MultiPoint::is_valid(), paths, Slic3r::MultiPoint::points, and Slic3r::ExtrusionPath::polyline.

Referenced by split_at().

Here is the call graph for this function:

Here is the caller graph for this function:

total_volume()

double Slic3r::ExtrusionLoop::total_volume ( ) const

inlineoverridevirtual

Implements Slic3r::ExtrusionEntity.

{ double volume =0.; for (const auto& path : paths) volume += path.total_volume(); return volume; }

References paths.

validate()

bool Slic3r::ExtrusionLoop::validate ( ) const

inline

                        {
    assert(this->first_point() == this->paths.back().polyline.points.back());
    for (size_t i = 1; i < paths.size(); ++ i)
      assert(this->paths[i - 1].polyline.points.back() == this->paths[i].polyline.points.front());
    return true;
  }

References first_point(), and paths.

Here is the call graph for this function:

Member Data Documentation

m_loop_role

ExtrusionLoopRole Slic3r::ExtrusionLoop::m_loop_role

private

Referenced by loop_role().

paths

ExtrusionPaths Slic3r::ExtrusionLoop::paths

Referenced by Slic3r::Print::_make_skirt(), clip_end(), collect_points(), Slic3r::extrusionentity_extents(), Slic3r::_3DScene::extrusionentity_to_verts(), get_closest_path_and_point(), has_overhang_point(), length(), min_mm3_per_mm(), polygon(), polygons_covered_by_spacing(), polygons_covered_by_width(), reverse(), split_at(), split_at_vertex(), total_volume(), Slic3r::traverse_extrusions(), and validate().

---

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

• src/libslic3r/ExtrusionEntity.hpp
• src/libslic3r/ExtrusionEntity.cpp