Slic3r::ExtrusionLoopSloped Class Reference

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

Inheritance diagram for Slic3r::ExtrusionLoopSloped:

Collaboration diagram for Slic3r::ExtrusionLoopSloped:

Public Member Functions
	ExtrusionLoopSloped (ExtrusionPaths &original_paths, double seam_gap, double slope_min_length, double slope_max_segment_length, double start_slope_ratio, ExtrusionLoopRole role=elrDefault)
std::vector< const ExtrusionPath * >	get_all_paths () const
void	clip_slope (double distance, bool inter_perimeter=false)
void	clip_end (const double distance)
void	clip_front (const double distance)
double	slope_path_length ()
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 ()
bool	is_clockwise ()
bool	is_counter_clockwise ()
void	reverse () override
Point	first_point () const override
const Point3 &	first_point3 () const override
Point	last_point () const override
const Point3 &	last_point3 () 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	set_loop_role (ExtrusionLoopRole role)
void	polygons_covered_by_width (Polygons &out, const float scaled_epsilon) const override
Polygons	polygons_covered_by_width (const float scaled_epsilon=0.f) const
void	polygons_covered_by_spacing (Polygons &out, const float scaled_epsilon) const override
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	is_smooth (double angle_threshold=0.174, double min_arm_length=0.025) const
bool	validate () const
virtual bool	is_collection () const
virtual bool	can_sort () const
virtual void	set_reverse ()
virtual Polylines	as_polylines () const

Static Public Member Functions
static std::string	role_to_string (ExtrusionRole role)
static ExtrusionRole	string_to_role (const std::string_view role)

Public Attributes
std::vector< ExtrusionPathSloped >	starts
std::vector< ExtrusionPathSloped >	ends
ExtrusionPaths	paths
bool	print_after_infill = false
int	inset_idx = -1

Private Attributes
ExtrusionLoopRole	m_loop_role

Detailed Description

Constructor & Destructor Documentation

ExtrusionLoopSloped()

Slic3r::ExtrusionLoopSloped::ExtrusionLoopSloped	(	ExtrusionPaths &	original_paths,
		double	seam_gap,
		double	slope_min_length,
		double	slope_max_segment_length,
		double	start_slope_ratio,
		ExtrusionLoopRole	role = elrDefault )

    : ExtrusionLoop(role)
{
    // An eighth of a common line width: the path moves by less than that at the seam.
    trim_seam_ends(original_paths, scale_(0.05));
    // The caller measured the loop before the trim; a scarf that covers the whole loop must still end at 1.
    double trimmed_length = 0.;
    for (const ExtrusionPath &path : original_paths)
        trimmed_length += unscale_(path.length());
    slope_min_length = std::min(slope_min_length, trimmed_length);
 
    // create slopes
    const auto add_slop = [this, slope_max_segment_length, seam_gap](const ExtrusionPath &path, const Polyline3 &poly, double ratio_begin, double ratio_end) {
        if (poly.empty()) { return; }
 
        // Ensure `slope_max_segment_length`
        Polyline3 detailed_poly;
        {
            detailed_poly.append(poly.first_point());
 
            // Recursively split the line into half until no longer than `slope_max_segment_length`
            const std::function<void(const Line3 &)> handle_line = [slope_max_segment_length, &detailed_poly, &handle_line](const Line3 &line) {
                if (line.length() <= slope_max_segment_length) {
                    detailed_poly.append(line.b);
                } else {
                    // Then process left half
                    handle_line({line.a, line.midpoint()});
                    // Then process right half
                    handle_line({line.midpoint(), line.b});
                }
            };
 
            for (const auto &l : poly.lines()) { handle_line(l); }
        }
 
        starts.emplace_back(detailed_poly, path, ExtrusionPathSloped::Slope{ratio_begin, ratio_begin}, ExtrusionPathSloped::Slope{ratio_end, ratio_end});
 
        if (is_approx(ratio_end, 1.) && seam_gap > 0) {
            // Remove the segments that has no extrusion
            const auto seg_length = detailed_poly.length();
            if (seg_length > seam_gap) {
                // Split the segment and remove the last `seam_gap` bit
                const Polyline3 orig = detailed_poly;
                Polyline3       tmp;
                orig.split_at_length(seg_length - seam_gap, &detailed_poly, &tmp);
 
                ratio_end = lerp(ratio_begin, ratio_end, (seg_length - seam_gap) / seg_length);
                assert(1. - ratio_end > EPSILON);
            } else {
                // Remove the entire segment
                detailed_poly.clear();
            }
        }
        if (!detailed_poly.empty()) { ends.emplace_back(detailed_poly, path, ExtrusionPathSloped::Slope{1., 1. - ratio_begin}, ExtrusionPathSloped::Slope{1., 1. - ratio_end}); }
 
    };
 
    double remaining_length = slope_min_length;
 
    ExtrusionPaths::iterator path        = original_paths.begin();
    double                   start_ratio = start_slope_ratio;
    for (; path != original_paths.end() && remaining_length > 0; ++path) {
        const double path_len = unscale_(path->length());
        if (path_len > remaining_length) {
            // Split current path into slope and non-slope part
            Polyline3 slope_path;
            Polyline3 flat_path;
            split_at_slope_end(path->polyline, scale_(remaining_length), slope_max_segment_length, slope_path, flat_path);
 
            add_slop(*path, slope_path, start_ratio, 1);
            start_ratio = 1;
 
            if (flat_path.size() > 1)
                paths.emplace_back(std::move(flat_path), *path);
            remaining_length = 0;
        } else {
            remaining_length -= path_len;
            const double end_ratio = lerp(1.0, start_slope_ratio, remaining_length / slope_min_length);
            add_slop(*path, path->polyline, start_ratio, end_ratio);
            start_ratio = end_ratio;
        }
    }
    assert(remaining_length <= 0);
    assert(start_ratio == 1.);
 
    // Put remaining flat paths
    paths.insert(paths.end(), path, original_paths.end());
}

References Slic3r::ExtrusionLoop::ExtrusionLoop(), Slic3r::Polyline3::append(), Slic3r::MultiPoint3::clear(), Slic3r::MultiPoint3::empty(), ends, EPSILON, Slic3r::is_approx(), Slic3r::MultiPoint3::length(), Slic3r::lerp(), Slic3r::ExtrusionLoop::paths, Slic3r::ExtrusionLoop::role(), scale_, Slic3r::MultiPoint3::size(), Slic3r::Polyline3::split_at_length(), Slic3r::split_at_slope_end(), starts, Slic3r::trim_seam_ends(), and unscale_.

Here is the call graph for this function:

Member Function Documentation

as_polyline()

Polyline Slic3r::ExtrusionLoop::as_polyline ( ) const

inlineoverridevirtualinherited

Implements Slic3r::ExtrusionEntity.

                                          {
        if (this->paths.empty() || this->length() <= 0.)
            return Polyline();
        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 collect_polylines().

Referenced by Slic3r::SupportMaterialInternal::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

inlineoverridevirtualinherited

Reimplemented from Slic3r::ExtrusionEntity.

{ return false; }

can_sort()

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

inlinevirtualinherited

Reimplemented in Slic3r::ExtrusionEntityCollection.

{ return true; }//BBS: only used in ExtrusionEntityCollection

clip_end() [1/2]

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

inherited

{
    *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::Polyline3::clip_end(), Slic3r::ExtrusionPath::length(), paths, and Slic3r::ExtrusionPath::polyline.

Referenced by Slic3r::GCode::extrude_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

clip_end() [2/2]

void Slic3r::ExtrusionLoopSloped::clip_end

(

const double

distance

)

{
    double clip_dist = distance;
    std::vector<ExtrusionPathSloped> &ends_slope = this->ends;
    while (clip_dist > 0 && !ends_slope.empty()) {
        ExtrusionPathSloped &last_path = ends_slope.back();
        double len = last_path.length();
        if (len <= clip_dist) {
            ends_slope.pop_back();
            clip_dist -= len;
        } else {
            last_path.polyline.clip_end(clip_dist);
            break;
        }
    }
}

References Slic3r::Polyline3::clip_end(), ends, Slic3r::ExtrusionPath::length(), and Slic3r::ExtrusionPath::polyline.

Referenced by clip_slope().

Here is the call graph for this function:

Here is the caller graph for this function:

clip_front()

void Slic3r::ExtrusionLoopSloped::clip_front

(

const double

distance

)

{
    double clip_dist = distance;
    if (this->role() == erPerimeter)
        clip_dist = scale_(this->slope_path_length()) * slope_inner_outer_wall_gap;
 
    std::vector<ExtrusionPathSloped> &start_slope = this->starts;
 
    Polyline front_inward;
    while (distance > 0 && !start_slope.empty()) {
        ExtrusionPathSloped &first_path = start_slope.front();
        double len = first_path.length();
        if (len <= clip_dist) {
            start_slope.erase(start_slope.begin());
            clip_dist -= len;
        } else {
            first_path.polyline.reverse();
            first_path.polyline.clip_end(clip_dist);
            first_path.polyline.reverse();
            break;
        }
    }
}

References Slic3r::Polyline3::clip_end(), Slic3r::erPerimeter, Slic3r::ExtrusionPath::length(), Slic3r::ExtrusionPath::polyline, Slic3r::Polyline3::reverse(), Slic3r::ExtrusionLoop::role(), scale_, slope_path_length(), and starts.

Referenced by clip_slope().

Here is the call graph for this function:

Here is the caller graph for this function:

clip_slope()

void Slic3r::ExtrusionLoopSloped::clip_slope	(	double	distance,
		bool	inter_perimeter = false )

{
 
    this->clip_end(distance);
    this->clip_front(distance*2);
}

References clip_end(), and clip_front().

Referenced by Slic3r::GCode::extrude_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

clone()

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

inlineoverridevirtualinherited

Implements Slic3r::ExtrusionEntity.

{ return new ExtrusionLoop (*this); }

References ExtrusionLoop().

Here is the call graph for this function:

clone_move()

ExtrusionEntity * Slic3r::ExtrusionLoop::clone_move ( )

inlineoverridevirtualinherited

Implements Slic3r::ExtrusionEntity.

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

References ExtrusionLoop().

Here is the call graph for this function:

collect_points()

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

inlineoverridevirtualinherited

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, to_points(p.polyline.points));
    }

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

Referenced by Slic3r::Skirt::find_start_point().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_polylines()

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

inlineoverridevirtualinherited

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

Point Slic3r::ExtrusionLoop::first_point ( ) const

inlineoverridevirtualinherited

Implements Slic3r::ExtrusionEntity.

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

Referenced by last_point().

Here is the caller graph for this function:

first_point3()

const Point3 & Slic3r::ExtrusionLoop::first_point3 ( ) const

inlineoverridevirtualinherited

Implements Slic3r::ExtrusionEntity.

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

Referenced by last_point3(), and validate().

Here is the caller graph for this function:

get_all_paths()

std::vector< const ExtrusionPath * > Slic3r::ExtrusionLoopSloped::get_all_paths ( ) const

nodiscard

                                                                         {
    std::vector<const ExtrusionPath*> r;
    r.reserve(starts.size() + paths.size() + ends.size());
    for (const auto& p : starts) {
        r.push_back(&p);
    }
    for (const auto& p : paths) {
        r.push_back(&p);
    }
    for (const auto& p : ends) {
        r.push_back(&p);
    }
 
    return r;
}

References ends, Slic3r::ExtrusionLoop::paths, and starts.

Referenced by Slic3r::GCode::extrude_loop().

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

inherited

{
    // 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, Point3> foot_pt_ = foot_pt(path.polyline.points, Point3(point));
        Point                  foot_pt_2d = Point(foot_pt_.second.x(), foot_pt_.second.y());
        double                 d2       = (foot_pt_2d - point).cast<double>().squaredNorm();
        if (d2 < min2) {
            out.foot_pt     = foot_pt_2d;
            out.path_idx    = &path - &this->paths.front();
            out.segment_idx = foot_pt_.first;
            min2            = d2;
        }
        if (prefer_non_overhang && !is_bridge(path.role()) && d2 < min2_non_overhang) {
            best_non_overhang.foot_pt     = foot_pt_2d;
            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::cast(), Slic3r::ExtrusionLoop::ClosestPathPoint::foot_pt, Slic3r::Geometry::foot_pt(), Slic3r::is_bridge(), Slic3r::ExtrusionLoop::ClosestPathPoint::path_idx, paths, and Slic3r::ExtrusionLoop::ClosestPathPoint::segment_idx.

Referenced by Slic3r::SeamPlacer::place_seam(), and 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

inherited

{
    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 (is_bridge(path.role()) && pos > 0 && pos != (int)(path.polyline.points.size())-1);
        }
    }
    return false;
}

References Slic3r::is_bridge(), and paths.

Here is the call graph for this function:

is_clockwise()

bool Slic3r::ExtrusionLoop::is_clockwise ( )

inlineinherited

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

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

Here is the call graph for this function:

is_collection()

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

inlinevirtualinherited

Reimplemented in Slic3r::ExtrusionEntityCollection.

{ return false; }

Referenced by Slic3r::SupportMaterialInternal::collect_bridging_perimeter_areas(), Slic3r::GCode::compute_farthest_point(), Slic3r::SeamPlacerImpl::extract_perimeter_polygons(), Slic3r::ExtrusionEntityCollection::flatten(), Slic3r::SupportMaterialInternal::has_bridging_fills(), and Slic3r::SupportMaterialInternal::has_bridging_perimeters().

Here is the caller graph for this function:

is_counter_clockwise()

bool Slic3r::ExtrusionLoop::is_counter_clockwise ( )

inlineinherited

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

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

Referenced by Slic3r::GCode::extrude_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

is_loop()

bool Slic3r::ExtrusionLoop::is_loop ( ) const

inlineoverridevirtualinherited

Reimplemented from Slic3r::ExtrusionEntity.

{ return true; }

is_smooth()

bool Slic3r::ExtrusionLoop::is_smooth ( double angle_threshold = 0.174, double min_arm_length = 0.025 ) const

inherited

{
    // go through all the points in the loop and check if the angle between two segments(AB and BC) is less than the threshold
    size_t idx_prev = 0;
    size_t idx_curr = 0;
    size_t idx_next = 0;
 
    float distance_to_prev = 0;
    float distance_to_next = 0;
 
    const auto _polygon = polygon();
    const Points& points = _polygon.points;
 
    std::vector<float> lengths{};
    for (size_t point_idx = 0; point_idx < points.size() - 1; ++point_idx) {
        lengths.push_back((unscale(points[point_idx]) - unscale(points[point_idx + 1])).norm());
    }
    lengths.push_back(std::max((unscale(points[0]) - unscale(points[points.size() - 1])).norm(), 0.1));
 
    // push idx_prev far enough back as initialization
    while (distance_to_prev < min_arm_length) {
        idx_prev = Slic3r::prev_idx_modulo(idx_prev, points.size());
        distance_to_prev += lengths[idx_prev];
    }
 
    for (size_t _i = 0; _i < points.size(); ++_i) {
        // pull idx_prev to current as much as possible, while respecting the min_arm_length
        while (distance_to_prev - lengths[idx_prev] > min_arm_length) {
            distance_to_prev -= lengths[idx_prev];
            idx_prev = Slic3r::next_idx_modulo(idx_prev, points.size());
        }
 
        // push idx_next forward as far as needed
        while (distance_to_next < min_arm_length) {
            distance_to_next += lengths[idx_next];
            idx_next = Slic3r::next_idx_modulo(idx_next, points.size());
        }
 
        // Calculate angle between idx_prev, idx_curr, idx_next.
        const Point& p0 = points[idx_prev];
        const Point& p1 = points[idx_curr];
        const Point& p2 = points[idx_next];
        const auto a = angle(p0 - p1, p2 - p1);
        if (a > 0 ? a < angle_threshold : a > -angle_threshold) {
            return false;
        }
 
        // increase idx_curr by one
        float curr_distance = lengths[idx_curr];
        idx_curr++;
        distance_to_prev += curr_distance;
        distance_to_next -= curr_distance;
    }
 
    return true;
}

References Slic3r::angle(), Slic3r::next_idx_modulo(), polygon(), Slic3r::prev_idx_modulo(), and Slic3r::unscale().

Referenced by Slic3r::GCode::extrude_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

last_point()

Point Slic3r::ExtrusionLoop::last_point ( ) const

inlineoverridevirtualinherited

Implements Slic3r::ExtrusionEntity.

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

References first_point().

Here is the call graph for this function:

last_point3()

const Point3 & Slic3r::ExtrusionLoop::last_point3 ( ) const

inlineoverridevirtualinherited

Implements Slic3r::ExtrusionEntity.

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

References first_point3().

Here is the call graph for this function:

length()

double Slic3r::ExtrusionLoop::length ( ) const

overridevirtualinherited

Implements Slic3r::ExtrusionEntity.

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

References paths.

Referenced by Slic3r::GCode::extrude_loop(), Slic3r::GCode::extrude_support(), and Slic3r::SeamPlacer::place_seam().

Here is the caller graph for this function:

loop_role()

ExtrusionLoopRole Slic3r::ExtrusionLoop::loop_role ( ) const

inlineinherited

{ return m_loop_role; }

References m_loop_role.

Referenced by Slic3r::convert_extrusion_to_json(), Slic3r::GCode::extrude_loop(), and Slic3r::reorient_perimeters().

Here is the caller graph for this function:

make_clockwise()

bool Slic3r::ExtrusionLoop::make_clockwise ( )

inherited

{
    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::GCode::extrude_loop(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

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

inherited

{
    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::GCode::extrude_loop(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

Here is the call graph for this function:

Here is the caller graph for this function:

min_mm3_per_mm()

double Slic3r::ExtrusionLoop::min_mm3_per_mm ( ) const

overridevirtualinherited

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

inherited

{
    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)
        for (auto it = path.polyline.points.begin(); it != path.polyline.points.end() - 1; ++it) {
            polygon.points.push_back(it->to_point());
        }
    }
    return polygon;
}

References paths, and polygon().

Referenced by as_polyline(), Slic3r::GCode::extrude_loop(), is_clockwise(), is_counter_clockwise(), is_smooth(), 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

inlineinherited

        { 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

overridevirtualinherited

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

inlineinherited

        { 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

overridevirtualinherited

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

overridevirtualinherited

Implements Slic3r::ExtrusionEntity.

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

References paths.

Referenced by make_clockwise(), make_counter_clockwise(), and Slic3r::reorient_perimeters().

Here is the caller graph for this function:

role()

ExtrusionRole Slic3r::ExtrusionLoop::role ( ) const

inlineoverridevirtualinherited

Implements Slic3r::ExtrusionEntity.

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

References Slic3r::erNone.

Referenced by ExtrusionLoop(), ExtrusionLoop(), ExtrusionLoop(), ExtrusionLoop(), ExtrusionLoop(), Slic3r::ExtrusionLoopSloped::ExtrusionLoopSloped(), Slic3r::ExtrusionLoopSloped::clip_front(), Slic3r::GCode::extrude_loop(), Slic3r::SeamPlacer::place_seam(), and set_loop_role().

Here is the caller graph for this function:

role_to_string()

std::string Slic3r::ExtrusionEntity::role_to_string ( ExtrusionRole role )

staticinherited

{
    switch (role) {
        case erNone                         : return L("Undefined");
        case erPerimeter                    : return L("Inner wall");
        case erExternalPerimeter            : return L("Outer wall");
        case erOverhangPerimeter            : return L("Overhang wall");
        case erInternalInfill               : return L("Sparse infill");
        case erSolidInfill                  : return L("Internal solid infill");
        case erTopSolidInfill               : return L("Top surface");
        case erBottomSurface                : return L("Bottom surface");
        case erIroning                      : return L("Ironing");
        case erBridgeInfill                 : return L("Bridge");
        case erInternalBridgeInfill         : return L("Internal Bridge");
        case erGapFill                      : return L("Gap infill");
        case erSkirt                        : return L("Skirt");
        case erBrim                         : return L("Brim");
        case erSupportMaterial              : return L("Support");
        case erSupportMaterialInterface     : return L("Support interface");
        case erSupportTransition            : return L("Support transition");
        case erWipeTower                    : return L("Prime tower");
        case erCustom                       : return L("Custom");
        case erMixed                        : return L("Multiple");
        default                             : assert(false);
    }
    return "";
}

References Slic3r::erBottomSurface, Slic3r::erBridgeInfill, Slic3r::erBrim, Slic3r::erCustom, Slic3r::erExternalPerimeter, Slic3r::erGapFill, Slic3r::erInternalBridgeInfill, Slic3r::erInternalInfill, Slic3r::erIroning, Slic3r::erMixed, Slic3r::erNone, Slic3r::erOverhangPerimeter, Slic3r::erPerimeter, Slic3r::erSkirt, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, Slic3r::erTopSolidInfill, Slic3r::erWipeTower, L, and role().

Referenced by Slic3r::WipeTowerWriter::WipeTowerWriter(), Slic3r::WipeTowerWriter2::WipeTowerWriter2(), Slic3r::GCode::_do_export(), Slic3r::GCode::_extrude(), and Slic3r::anonymous_namespace{GCodeStatistics.cpp}::features_json().

Here is the call graph for this function:

Here is the caller graph for this function:

set_loop_role()

void Slic3r::ExtrusionLoop::set_loop_role ( ExtrusionLoopRole role )

inlineinherited

{    m_loop_role = role; }

References m_loop_role, and role().

Referenced by Slic3r::convert_extrusion_from_json().

Here is the call graph for this function:

Here is the caller graph for this function:

set_reverse()

virtual void Slic3r::ExtrusionEntity::set_reverse ( )

inlinevirtualinherited

Reimplemented in Slic3r::ExtrusionEntityCollection, Slic3r::ExtrusionMultiPath, and Slic3r::ExtrusionPath.

{}

slope_path_length()

double Slic3r::ExtrusionLoopSloped::slope_path_length

(

)

                                              {
    double total_length = 0.0;
    for (ExtrusionPathSloped start_ep : this->starts) {
        total_length += unscale_(start_ep.length());
    }
    return total_length;
}

References starts, Slic3r::total_length(), and unscale_.

Referenced by clip_front().

Here is the call graph for this function:

Here is the caller graph for this function:

split_at()

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

inherited

{
    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 Point3 *p1 = this->paths[path_idx].polyline.points.data() + segment_idx;
        const Point3 *p2 = p1;
        ++p2;
        Point        p1_2d = Point(p1->x(), p1->y());
        Point        p2_2d = Point(p2->x(), p2->y());
        double       d2_1 = (point - p1_2d).cast<double>().squaredNorm();
        double       d2_2 = (point - p2_2d).cast<double>().squaredNorm();
        const double thr2 = scaled_epsilon * scaled_epsilon;
        if (d2_1 < d2_2) {
            if (d2_1 < thr2) p = p1_2d;
        } else {
            if (d2_2 < thr2) p = p2_2d;
        }
    }
    
    // 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);
    p1.z_contoured = p2.z_contoured = path.z_contoured;
    path.polyline.split_at(p, &p1.polyline, &p2.polyline);
 
    if (this->paths.size() == 1) {
        if (!p1.polyline.is_valid()) {
            std::swap(this->paths.front().polyline.points, p2.polyline.points);
            std::swap(this->paths.front().polyline.fitting_result, p2.polyline.fitting_result);
        }
        else if (!p2.polyline.is_valid()) {
            std::swap(this->paths.front().polyline.points, p1.polyline.points);
            std::swap(this->paths.front().polyline.fitting_result, p1.polyline.fitting_result);
        }
        else {
            p2.polyline.append(std::move(p1.polyline));
            std::swap(this->paths.front().polyline.points, p2.polyline.points);
            std::swap(this->paths.front().polyline.fitting_result, p2.polyline.fitting_result);
        }
    } 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);
}

References Slic3r::Polyline3::append(), Slic3r::cast(), Slic3r::Polyline3::fitting_result, get_closest_path_and_point(), Slic3r::ExtrusionPath::height, Slic3r::MultiPoint3::is_valid(), Slic3r::ExtrusionPath::mm3_per_mm, paths, Slic3r::MultiPoint3::points, Slic3r::ExtrusionPath::polyline, Slic3r::ExtrusionPath::role(), Slic3r::Polyline3::split_at(), split_at_vertex(), Slic3r::ExtrusionPath::width, and Slic3r::ExtrusionPath::z_contoured.

Referenced by Slic3r::GCode::extrude_loop(), and Slic3r::SeamPlacer::place_seam().

Here is the call graph for this function:

Here is the caller graph for this function:

split_at_vertex()

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

inherited

{
    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
                Polyline3 p1, p2;
                path->polyline.split_at_index(idx, &p1, &p2);
                if (p1.is_valid() && p2.is_valid()) {
                    p2.append(std::move(p1));
                    std::swap(path->polyline.points, p2.points);
                    std::swap(path->polyline.fitting_result, p2.fitting_result);
                }
            } else {
                // new paths list starts with the second half of current path
                ExtrusionPaths new_paths;
                Polyline3 p1, p2;
                path->polyline.split_at_index(idx, &p1, &p2);
                new_paths.reserve(this->paths.size() + 1);
                {
                    ExtrusionPath p = *path;
                    std::swap(p.polyline.points, p2.points);
                    std::swap(p.polyline.fitting_result, p2.fitting_result);
                    if (p.polyline.is_valid()) new_paths.push_back(p);
                }
            
                // then we add all paths until the end of current path list
                new_paths.insert(new_paths.end(), path+1, this->paths.end());  // not including this path
            
                // then we add all paths since the beginning of current list up to the previous one
                new_paths.insert(new_paths.end(), this->paths.begin(), path);  // not including this path
            
                // finally we add the first half of current path
                {
                    ExtrusionPath p = *path;
                    std::swap(p.polyline.points, p1.points);
                    std::swap(p.polyline.fitting_result, p1.fitting_result);
                    if (p.polyline.is_valid()) new_paths.push_back(p);
                }
                // we can now override the old path list with the new one and stop looping
                std::swap(this->paths, new_paths);
            }
            return true;
        }
    }
    return false;
}

References Slic3r::Polyline3::append(), Slic3r::Polyline3::fitting_result, Slic3r::MultiPoint3::is_valid(), paths, Slic3r::MultiPoint3::points, Slic3r::ExtrusionPath::polyline, and Slic3r::Polyline3::split_at_index().

Referenced by Slic3r::SeamPlacer::place_seam(), and split_at().

Here is the call graph for this function:

Here is the caller graph for this function:

string_to_role()

ExtrusionRole Slic3r::ExtrusionEntity::string_to_role ( const std::string_view role )

staticinherited

{
    if (role == L("Inner wall"))
        return erPerimeter;
    else if (role == L("Outer wall"))
        return erExternalPerimeter;
    else if (role == L("Overhang wall"))
        return erOverhangPerimeter;
    else if (role == L("Sparse infill"))
        return erInternalInfill;
    else if (role == L("Internal solid infill"))
        return erSolidInfill;
    else if (role == L("Top surface"))
        return erTopSolidInfill;
    else if (role == L("Bottom surface"))
        return erBottomSurface;
    else if (role == L("Ironing"))
        return erIroning;
    else if (role == L("Bridge"))
        return erBridgeInfill;
    else if (role == L("Internal Bridge"))
        return erInternalBridgeInfill;
    else if (role == L("Gap infill"))
        return erGapFill;
    else if (role == ("Skirt"))
        return erSkirt;
    else if (role == ("Brim"))
        return erBrim;
    else if (role == L("Support"))
        return erSupportMaterial;
    else if (role == L("Support interface"))
        return erSupportMaterialInterface;
    else if (role == L("Support transition"))
        return erSupportTransition;
    else if (role == L("Prime tower"))
        return erWipeTower;
    else if (role == L("Custom"))
        return erCustom;
    else if (role == L("Multiple"))
        return erMixed;
    else
        return erNone;
}

References Slic3r::erBottomSurface, Slic3r::erBridgeInfill, Slic3r::erBrim, Slic3r::erCustom, Slic3r::erExternalPerimeter, Slic3r::erGapFill, Slic3r::erInternalBridgeInfill, Slic3r::erInternalInfill, Slic3r::erIroning, Slic3r::erMixed, Slic3r::erNone, Slic3r::erOverhangPerimeter, Slic3r::erPerimeter, Slic3r::erSkirt, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, Slic3r::erTopSolidInfill, Slic3r::erWipeTower, L, and role().

Referenced by Slic3r::FanMover::_process_gcode_line(), and Slic3r::GCodeProcessor::process_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

total_volume()

double Slic3r::ExtrusionLoop::total_volume ( ) const

inlineoverridevirtualinherited

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

inlineinherited

                        {
    assert(this->first_point3() == 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_point3(), and paths.

Here is the call graph for this function:

Member Data Documentation

ends

std::vector<ExtrusionPathSloped> Slic3r::ExtrusionLoopSloped::ends

Referenced by ExtrusionLoopSloped(), clip_end(), Slic3r::GCode::extrude_loop(), and get_all_paths().

inset_idx

int Slic3r::ExtrusionEntity::inset_idx = -1

inherited

Referenced by Slic3r::is_inner_wall(), Slic3r::ExtrusionMultiPath::operator=(), Slic3r::ExtrusionMultiPath::operator=(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

m_loop_role

ExtrusionLoopRole Slic3r::ExtrusionLoop::m_loop_role

privateinherited

Referenced by ExtrusionLoop(), ExtrusionLoop(), ExtrusionLoop(), ExtrusionLoop(), ExtrusionLoop(), loop_role(), and set_loop_role().

paths

ExtrusionPaths Slic3r::ExtrusionLoop::paths

inherited

Referenced by ExtrusionLoop(), ExtrusionLoop(), Slic3r::ExtrusionLoopSloped::ExtrusionLoopSloped(), Slic3r::Print::_make_skirt(), clip_end(), Slic3r::SupportMaterialInternal::collect_bridging_perimeter_areas(), collect_points(), Slic3r::contour_extrusion_loop(), Slic3r::convert_extrusion_from_json(), Slic3r::convert_extrusion_to_json(), libvgcode::convert_to_vertices(), Slic3r::GCode::extrude_loop(), Slic3r::extrusionentity_extents(), Slic3r::_3DScene::extrusionentity_to_verts(), Slic3r::GCode::generate_skirt(), Slic3r::ExtrusionLoopSloped::get_all_paths(), get_closest_path_and_point(), Slic3r::SupportMaterialInternal::has_bridging_perimeters(), has_overhang_point(), length(), min_mm3_per_mm(), Slic3r::SeamPlacer::place_seam(), polygon(), polygons_covered_by_spacing(), polygons_covered_by_width(), Slic3r::reorient_perimeters(), reverse(), Slic3r::LayerRegion::simplify_loop(), Slic3r::Layer::simplify_support_loop(), split_at(), split_at_vertex(), total_volume(), Slic3r::traverse_extrusions(), and validate().

print_after_infill

bool Slic3r::ExtrusionLoop::print_after_infill = false

inherited

starts

std::vector<ExtrusionPathSloped> Slic3r::ExtrusionLoopSloped::starts

Referenced by ExtrusionLoopSloped(), clip_front(), get_all_paths(), and slope_path_length().

---

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

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