#include <src/libslic3r/GCode/AvoidCrossingPerimeters.hpp>

Collaboration diagram for Slic3r::AvoidCrossingPerimeters:

Classes
struct	Boundary

Public Member Functions
void	use_external_mp (bool use=true)

void	use_external_mp_once ()

bool	used_external_mp_once ()

void	disable_once ()

bool	disabled_once () const

void	reset_once_modifiers ()

void	init_layer (const Layer &layer)

Polyline	travel_to (const GCode &gcodegen, const Point &point)

Polyline	travel_to (const GCode &gcodegen, const Point &point, bool *could_be_wipe_disabled)

Private Attributes
bool	m_use_external_mp { false }

bool	m_use_external_mp_once { false }

bool	m_disabled_once { true }

ExPolygons	m_lslices_offset

std::vector< BoundingBox >	m_lslices_offset_bboxes

EdgeGrid::Grid	m_grid_lslices_offset

Boundary	m_internal

Boundary	m_external

Detailed Description

Member Function Documentation

◆ disable_once()

void Slic3r::AvoidCrossingPerimeters::disable_once ( )

inline

22{ m_disabled_once = true; }

Slic3r::AvoidCrossingPerimeters::m_disabled_once

bool m_disabled_once

Definition AvoidCrossingPerimeters.hpp:59

References m_disabled_once.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::GCode::process_layer().

Here is the caller graph for this function:

◆ disabled_once()

bool Slic3r::AvoidCrossingPerimeters::disabled_once ( ) const

inline

23{ return m_disabled_once; }

References m_disabled_once.

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

Here is the caller graph for this function:

◆ init_layer()

void Slic3r::AvoidCrossingPerimeters::init_layer ( const Layer & layer )

{
    m_internal.clear();
    m_external.clear();
    m_lslices_offset.clear();
    m_lslices_offset_bboxes.clear();
 
    float perimeter_offset = -get_external_perimeter_width(layer) / float(2.);
    m_lslices_offset        = offset_ex(layer.lslices, perimeter_offset);
 
    m_lslices_offset_bboxes.reserve(m_lslices_offset.size());
    for (const ExPolygon &ex_poly : m_lslices_offset)
        m_lslices_offset_bboxes.emplace_back(get_extents(ex_poly));
 
    BoundingBox bbox_slice(get_extents(layer.lslices));
    bbox_slice.offset(SCALED_EPSILON);
 
    m_grid_lslices_offset.set_bbox(bbox_slice);
    m_grid_lslices_offset.create(m_lslices_offset, coord_t(scale_(1.)));
}

References Slic3r::MultiPoint::clear(), Slic3r::get_extents(), Slic3r::get_external_perimeter_width(), Slic3r::Layer::lslices, Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::offset_ex(), scale_, and SCALED_EPSILON.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_once_modifiers()

void Slic3r::AvoidCrossingPerimeters::reset_once_modifiers ( )

inline

24{ m_use_external_mp_once = false; m_disabled_once = false; }

Slic3r::AvoidCrossingPerimeters::m_use_external_mp_once

bool m_use_external_mp_once

Definition AvoidCrossingPerimeters.hpp:56

References m_disabled_once, and m_use_external_mp_once.

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

Here is the caller graph for this function:

◆ travel_to() [1/2]

Polyline Slic3r::AvoidCrossingPerimeters::travel_to	(	const GCode &	gcodegen,
		const Point &	point
	)

inline

    {
        bool could_be_wipe_disabled;
        return this->travel_to(gcodegen, point, &could_be_wipe_disabled);
    }

References travel_to().

Referenced by travel_to(), and Slic3r::GCode::travel_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ travel_to() [2/2]

Polyline Slic3r::AvoidCrossingPerimeters::travel_to	(	const GCode &	gcodegen,
		const Point &	point,
		bool *	could_be_wipe_disabled
	)

{
    // If use_external, then perform the path planning in the world coordinate system (correcting for the gcodegen offset).
    // Otherwise perform the path planning in the coordinate system of the active object.
    bool        use_external  = m_use_external_mp || m_use_external_mp_once;
    Point       scaled_origin = use_external ? Point::new_scale(gcodegen.origin()(0), gcodegen.origin()(1)) : Point(0, 0);
    const Point start         = gcodegen.last_pos() + scaled_origin;
    const Point end           = point + scaled_origin;
    const Line  travel(start, end);
 
    Polyline result_pl;
    size_t   travel_intersection_count = 0;
    Vec2d startf = start.cast<double>();
    Vec2d endf   = end  .cast<double>();
 
    bool is_support_layer = dynamic_cast<const SupportLayer *>(gcodegen.layer()) != nullptr;
    if (!use_external && (is_support_layer || (!m_lslices_offset.empty() && !any_expolygon_contains(m_lslices_offset, m_lslices_offset_bboxes, m_grid_lslices_offset, travel)))) {
        // Initialize m_internal only when it is necessary.
        if (m_internal.boundaries.empty())
            init_boundary(&m_internal, to_polygons(get_boundary(*gcodegen.layer())));
 
        // Trim the travel line by the bounding box.
        if (!m_internal.boundaries.empty() && Geometry::liang_barsky_line_clipping(startf, endf, m_internal.bbox)) {
            travel_intersection_count = avoid_perimeters(m_internal, startf.cast<coord_t>(), endf.cast<coord_t>(), *gcodegen.layer(), result_pl);
            result_pl.points.front()  = start;
            result_pl.points.back()   = end;
        }
    } else if(use_external) {
        // Initialize m_external only when exist any external travel for the current layer.
        if (m_external.boundaries.empty())
            init_boundary(&m_external, get_boundary_external(*gcodegen.layer()));
 
        // Trim the travel line by the bounding box.
        if (!m_external.boundaries.empty() && Geometry::liang_barsky_line_clipping(startf, endf, m_external.bbox)) {
            travel_intersection_count = avoid_perimeters(m_external, startf.cast<coord_t>(), endf.cast<coord_t>(), *gcodegen.layer(), result_pl);
            result_pl.points.front()  = start;
            result_pl.points.back()   = end;
        }
    }
 
    if(result_pl.empty()) {
        // Travel line is completely outside the bounding box.
        result_pl                 = {start, end};
        travel_intersection_count = 0;
    }
 
    const ConfigOptionFloatOrPercent &opt_max_detour             = gcodegen.config().avoid_crossing_perimeters_max_detour;
    bool                              max_detour_length_exceeded = false;
    if (opt_max_detour.value > 0) {
        double direct_length     = travel.length();
        double detour            = result_pl.length() - direct_length;
        double max_detour_length = opt_max_detour.percent ?
            direct_length * 0.01 * opt_max_detour.value :
            scale_(opt_max_detour.value);
        if (detour > max_detour_length) {
            result_pl = {start, end};
            max_detour_length_exceeded = true;
        }
    }
 
    if (use_external) {
        result_pl.translate(-scaled_origin);
        *could_be_wipe_disabled = false;
    } else if (max_detour_length_exceeded) {
        *could_be_wipe_disabled = false;
    } else
        *could_be_wipe_disabled = !need_wipe(gcodegen, m_lslices_offset, m_lslices_offset_bboxes, m_grid_lslices_offset, travel, result_pl, travel_intersection_count);
 
    return result_pl;
}