Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp} Namespace Reference

Classes
struct	SegmentIntersection

Functions
double	boundary_epsilon ()
bool	line_intersection_t (const Point &a, const Point &b, const Point &c, const Point &d, double &t, Point &intersection)
template<typename Fn>
void	for_each_expolygon_contour (const ExPolygon &expolygon, Fn &&fn)
void	add_unique_param (std::vector< double > &params, double t)
std::vector< SegmentIntersection >	contour_intersections (const Point &a, const Point &b, const Polygon &polygon)
bool	point_in_expolygons (const ExPolygons &expolygons, const Point &point, bool border_result)
bool	point_on_expolygon_boundary (const ExPolygon &expolygon, const Point &point)
bool	point_on_expolygons_boundary (const ExPolygons &expolygons, const Point &point)
bool	point_in_expolygons_interior (const ExPolygons &expolygons, const Point &point)
std::vector< double >	boundary_params_for_segment (const Point &a, const Point &b, const ExPolygons &expolygons)
Point	interpolate (const Point &a, const Point &b, double t)
bool	segment_enters_expolygons_interior (const Point &a, const Point &b, const ExPolygons &expolygons)
std::optional< double >	first_interior_param_for_segment (const Point &a, const Point &b, const ExPolygons &expolygons)
bool	segment_inside_bed (const Point &a, const Point &b, const ExPolygons &valid_bed)
double	polyline_length (const Polyline &polyline)
bool	points_near (const Point &lhs, const Point &rhs)
bool	replacement_matches_original_segment (const Polyline &replacement, const Point &a, const Point &b)
void	append_point (Points &points, const Point &point)
Polyline	make_forward_detour (const Point &a, const Point &b, const Polygon &contour, const SegmentIntersection &entry, const SegmentIntersection &exit)
Polyline	make_backward_detour (const Point &a, const Point &b, const Polygon &contour, const SegmentIntersection &entry, const SegmentIntersection &exit)
bool	routed_polyline_inside_bed (const Polyline &polyline, const ExPolygons &valid_bed, const bool allow_start_outside, const bool allow_end_outside)
bool	polyline_intersects_obstacles (const Polyline &polyline, const ExPolygons &obstacles)
std::optional< size_t >	first_intersected_obstacle (const Point &a, const Point &b, const ExPolygons &obstacles)
std::optional< Polyline >	detour_around_obstacle (const Point &a, const Point &b, const ExPolygon &obstacle, const ExPolygons &obstacles, const ExPolygons &valid_bed, const bool allow_start_outside, const bool allow_end_outside)
void	replace_segment (Polyline &path, size_t segment_idx, const Polyline &replacement)
Polyline	simplify_path (const Polyline &path, const ExPolygons &obstacles, const ExPolygons &valid_bed)

Variables
constexpr double	T_EPSILON = 1e-9
constexpr size_t	MAX_REROUTE_ITERATIONS = 16

---

Class Documentation

Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::SegmentIntersection

struct Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::SegmentIntersection

Collaboration diagram for Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::SegmentIntersection:

Class Members
size_t	edge_idx { 0 }
Point	point
double	t { 0.0 }

Function Documentation

add_unique_param()

void Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::add_unique_param	(	std::vector< double > &	params,
		double	t )

{
    const double clamped = std::clamp(t, 0.0, 1.0);
    if (std::none_of(params.begin(), params.end(), [clamped](double value) {
            return std::abs(value - clamped) < T_EPSILON;
        }))
        params.emplace_back(clamped);
}

References add_unique_param().

Referenced by add_unique_param(), and boundary_params_for_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

append_point()

void Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::append_point	(	Points &	points,
		const Point &	point )

{
    if (points.empty() || points.back() != point)
        points.emplace_back(point);
}

References append_point().

Referenced by append_point(), make_backward_detour(), make_forward_detour(), replace_segment(), and simplify_path().

Here is the call graph for this function:

Here is the caller graph for this function:

boundary_epsilon()

double Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::boundary_epsilon

(

)

{
    return std::max<double>(SCALED_EPSILON, scale_(0.005));
}

References boundary_epsilon(), scale_, and SCALED_EPSILON.

Referenced by boundary_epsilon(), point_on_expolygon_boundary(), and points_near().

Here is the call graph for this function:

Here is the caller graph for this function:

boundary_params_for_segment()

std::vector< double > Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::boundary_params_for_segment	(	const Point &	a,
		const Point &	b,
		const ExPolygons &	expolygons )

{
    std::vector<double> params { 0.0, 1.0 };
    for (const ExPolygon &expolygon : expolygons) {
        for_each_expolygon_contour(expolygon, [&](const Polygon &contour) {
            for (const SegmentIntersection &intersection : contour_intersections(a, b, contour))
                add_unique_param(params, intersection.t);
        });
    }
    std::sort(params.begin(), params.end());
    return params;
}

References add_unique_param(), boundary_params_for_segment(), Slic3r::contour(), contour_intersections(), for_each_expolygon_contour(), and Slic3r::intersection().

Referenced by boundary_params_for_segment(), first_interior_param_for_segment(), segment_enters_expolygons_interior(), and segment_inside_bed().

Here is the call graph for this function:

Here is the caller graph for this function:

contour_intersections()

std::vector< SegmentIntersection > Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::contour_intersections	(	const Point &	a,
		const Point &	b,
		const Polygon &	polygon )

{
    std::vector<SegmentIntersection> intersections;
    if (polygon.points.size() < 2)
        return intersections;
 
    intersections.reserve(4);
    for (size_t edge_idx = 0; edge_idx < polygon.points.size(); ++edge_idx) {
        const Point &c = polygon.points[edge_idx];
        const Point &d = polygon.points[(edge_idx + 1) % polygon.points.size()];
        double t = 0.0;
        Point point;
        if (line_intersection_t(a, b, c, d, t, point) &&
            std::none_of(intersections.begin(), intersections.end(), [t](const SegmentIntersection &other) {
                return std::abs(other.t - t) < T_EPSILON;
            }))
            intersections.push_back({ t, point, edge_idx });
    }
 
    std::sort(intersections.begin(), intersections.end(), [](const SegmentIntersection &lhs, const SegmentIntersection &rhs) {
        return lhs.t < rhs.t;
    });
    return intersections;
}

References contour_intersections(), line_intersection_t(), and Slic3r::MultiPoint::points.

Referenced by boundary_params_for_segment(), contour_intersections(), and detour_around_obstacle().

Here is the call graph for this function:

Here is the caller graph for this function:

detour_around_obstacle()

std::optional< Polyline > Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::detour_around_obstacle	(	const Point &	a,
		const Point &	b,
		const ExPolygon &	obstacle,
		const ExPolygons &	obstacles,
		const ExPolygons &	valid_bed,
		const bool	allow_start_outside,
		const bool	allow_end_outside )

{
    const std::vector<SegmentIntersection> intersections = contour_intersections(a, b, obstacle.contour);
    if (intersections.size() < 2)
        return std::nullopt;
 
    const SegmentIntersection &entry = intersections.front();
    const SegmentIntersection &exit = intersections.back();
    const Polyline forward = make_forward_detour(a, b, obstacle.contour, entry, exit);
    const Polyline backward = make_backward_detour(a, b, obstacle.contour, entry, exit);
 
    const bool forward_bed_valid = routed_polyline_inside_bed(
        forward, valid_bed, allow_start_outside, allow_end_outside);
    const bool backward_bed_valid = routed_polyline_inside_bed(
        backward, valid_bed, allow_start_outside, allow_end_outside);
    const bool forward_clear = forward_bed_valid && !polyline_intersects_obstacles(forward, obstacles);
    const bool backward_clear = backward_bed_valid && !polyline_intersects_obstacles(backward, obstacles);
 
    if (forward_clear || backward_clear) {
        if (forward_clear && !backward_clear)
            return forward;
        if (!forward_clear && backward_clear)
            return backward;
        return polyline_length(forward) <= polyline_length(backward) ? forward : backward;
    }
 
    // If another obstacle blocks both immediate choices, retain the valid local
    // detour and let the outer repair loop address the next crossing.
    if (!forward_bed_valid && !backward_bed_valid)
        return std::nullopt;
    if (forward_bed_valid && !backward_bed_valid)
        return forward;
    if (!forward_bed_valid && backward_bed_valid)
        return backward;
    return polyline_length(forward) <= polyline_length(backward) ? forward : backward;
}

References Slic3r::ExPolygon::contour, contour_intersections(), detour_around_obstacle(), make_backward_detour(), make_forward_detour(), polyline_intersects_obstacles(), polyline_length(), and routed_polyline_inside_bed().

Referenced by detour_around_obstacle().

Here is the call graph for this function:

Here is the caller graph for this function:

first_interior_param_for_segment()

std::optional< double > Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::first_interior_param_for_segment	(	const Point &	a,
		const Point &	b,
		const ExPolygons &	expolygons )

{
    if (expolygons.empty())
        return std::nullopt;
    if (point_in_expolygons_interior(expolygons, a))
        return 0.0;
 
    const std::vector<double> params = boundary_params_for_segment(a, b, expolygons);
    for (size_t idx = 1; idx < params.size(); ++idx) {
        const double low = params[idx - 1];
        const double high = params[idx];
        if (high - low < T_EPSILON)
            continue;
        if (point_in_expolygons_interior(expolygons, interpolate(a, b, 0.5 * (low + high))))
            return low;
    }
 
    return point_in_expolygons_interior(expolygons, b) ? std::optional<double>(1.0) : std::nullopt;
}

References boundary_params_for_segment(), first_interior_param_for_segment(), interpolate(), point_in_expolygons_interior(), and T_EPSILON.

Referenced by first_interior_param_for_segment(), and first_intersected_obstacle().

Here is the call graph for this function:

Here is the caller graph for this function:

first_intersected_obstacle()

std::optional< size_t > Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::first_intersected_obstacle	(	const Point &	a,
		const Point &	b,
		const ExPolygons &	obstacles )

{
    std::optional<size_t> best_idx;
    double best_t = std::numeric_limits<double>::infinity();
    for (size_t idx = 0; idx < obstacles.size(); ++idx) {
        const ExPolygons single { obstacles[idx] };
        if (const std::optional<double> t = first_interior_param_for_segment(a, b, single); t && *t < best_t) {
            best_t = *t;
            best_idx = idx;
        }
    }
    return best_idx;
}

References first_interior_param_for_segment(), and first_intersected_obstacle().

Referenced by first_intersected_obstacle().

Here is the call graph for this function:

Here is the caller graph for this function:

for_each_expolygon_contour()

template<typename Fn>

void Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::for_each_expolygon_contour	(	const ExPolygon &	expolygon,
		Fn &&	fn )

{
    fn(expolygon.contour);
    for (const Polygon &hole : expolygon.holes)
        fn(hole);
}

References Slic3r::ExPolygon::contour, for_each_expolygon_contour(), and Slic3r::ExPolygon::holes.

Referenced by boundary_params_for_segment(), and for_each_expolygon_contour().

Here is the call graph for this function:

Here is the caller graph for this function:

interpolate()

Point Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::interpolate	(	const Point &	a,
		const Point &	b,
		double	t )

{
    return (a.cast<double>() + t * (b - a).cast<double>()).cast<coord_t>();
}

References interpolate().

Referenced by first_interior_param_for_segment(), interpolate(), segment_enters_expolygons_interior(), and segment_inside_bed().

Here is the call graph for this function:

Here is the caller graph for this function:

line_intersection_t()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::line_intersection_t	(	const Point &	a,
		const Point &	b,
		const Point &	c,
		const Point &	d,
		double &	t,
		Point &	intersection )

{
    const Vec2d p = a.cast<double>();
    const Vec2d r = (b - a).cast<double>();
    const Vec2d q = c.cast<double>();
    const Vec2d s = (d - c).cast<double>();
    const double denominator = cross2(r, s);
    if (std::abs(denominator) < T_EPSILON)
        return false;
 
    const Vec2d qp = q - p;
    const double candidate_t = cross2(qp, s) / denominator;
    const double u = cross2(qp, r) / denominator;
    if (candidate_t < -T_EPSILON || candidate_t > 1.0 + T_EPSILON ||
        u < -T_EPSILON || u > 1.0 + T_EPSILON)
        return false;
 
    t = std::clamp(candidate_t, 0.0, 1.0);
    intersection = (p + t * r).cast<coord_t>();
    return true;
}

References Slic3r::cast(), Slic3r::cross2(), Slic3r::intersection(), line_intersection_t(), and T_EPSILON.

Referenced by contour_intersections(), and line_intersection_t().

Here is the call graph for this function:

Here is the caller graph for this function:

make_backward_detour()

Polyline Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::make_backward_detour	(	const Point &	a,
		const Point &	b,
		const Polygon &	contour,
		const SegmentIntersection &	entry,
		const SegmentIntersection &	exit )

{
    Points points;
    append_point(points, a);
    append_point(points, entry.point);
 
    const size_t count = contour.points.size();
    const size_t last_vertex = (exit.edge_idx + 1) % count;
    for (size_t idx = entry.edge_idx;; idx = idx == 0 ? count - 1 : idx - 1) {
        append_point(points, contour.points[idx]);
        if (idx == last_vertex)
            break;
    }
 
    append_point(points, exit.point);
    append_point(points, b);
    return Polyline(std::move(points));
}

References append_point(), Slic3r::contour(), count, Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::SegmentIntersection::edge_idx, make_backward_detour(), and Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::SegmentIntersection::point.

Referenced by detour_around_obstacle(), and make_backward_detour().

Here is the call graph for this function:

Here is the caller graph for this function:

make_forward_detour()

Polyline Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::make_forward_detour	(	const Point &	a,
		const Point &	b,
		const Polygon &	contour,
		const SegmentIntersection &	entry,
		const SegmentIntersection &	exit )

{
    Points points;
    append_point(points, a);
    append_point(points, entry.point);
 
    const size_t count = contour.points.size();
    for (size_t idx = (entry.edge_idx + 1) % count; idx != (exit.edge_idx + 1) % count; idx = (idx + 1) % count)
        append_point(points, contour.points[idx]);
 
    append_point(points, exit.point);
    append_point(points, b);
    return Polyline(std::move(points));
}

References append_point(), Slic3r::contour(), count, Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::SegmentIntersection::edge_idx, make_forward_detour(), and Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::SegmentIntersection::point.

Referenced by detour_around_obstacle(), and make_forward_detour().

Here is the call graph for this function:

Here is the caller graph for this function:

point_in_expolygons()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::point_in_expolygons	(	const ExPolygons &	expolygons,
		const Point &	point,
		bool	border_result )

{
    return std::any_of(expolygons.begin(), expolygons.end(), [&point, border_result](const ExPolygon &expolygon) {
        return expolygon.contains(point, border_result);
    });
}

References point_in_expolygons().

Referenced by point_in_expolygons(), point_in_expolygons_interior(), routed_polyline_inside_bed(), and segment_inside_bed().

Here is the call graph for this function:

Here is the caller graph for this function:

point_in_expolygons_interior()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::point_in_expolygons_interior	(	const ExPolygons &	expolygons,
		const Point &	point )

{
    return point_in_expolygons(expolygons, point, false) &&
           !point_on_expolygons_boundary(expolygons, point);
}

References point_in_expolygons(), point_in_expolygons_interior(), and point_on_expolygons_boundary().

Referenced by first_interior_param_for_segment(), point_in_expolygons_interior(), and segment_enters_expolygons_interior().

Here is the call graph for this function:

Here is the caller graph for this function:

point_on_expolygon_boundary()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::point_on_expolygon_boundary	(	const ExPolygon &	expolygon,
		const Point &	point )

{
    const double epsilon = boundary_epsilon();
    if (expolygon.contour.on_boundary(point, epsilon))
        return true;
    return std::any_of(expolygon.holes.begin(), expolygon.holes.end(), [&point, epsilon](const Polygon &hole) {
        return hole.on_boundary(point, epsilon);
    });
}

References boundary_epsilon(), Slic3r::ExPolygon::contour, Slic3r::ExPolygon::holes, Slic3r::Polygon::on_boundary(), and point_on_expolygon_boundary().

Referenced by point_on_expolygon_boundary().

Here is the call graph for this function:

Here is the caller graph for this function:

point_on_expolygons_boundary()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::point_on_expolygons_boundary	(	const ExPolygons &	expolygons,
		const Point &	point )

{
    return std::any_of(expolygons.begin(), expolygons.end(), [&point](const ExPolygon &expolygon) {
        return point_on_expolygon_boundary(expolygon, point);
    });
}

References point_on_expolygons_boundary().

Referenced by point_in_expolygons_interior(), and point_on_expolygons_boundary().

Here is the call graph for this function:

Here is the caller graph for this function:

points_near()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::points_near	(	const Point &	lhs,
		const Point &	rhs )

{
    const double epsilon = boundary_epsilon();
    return (lhs - rhs).cast<double>().squaredNorm() <= epsilon * epsilon;
}

References boundary_epsilon(), and points_near().

Referenced by points_near(), and replacement_matches_original_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

polyline_intersects_obstacles()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::polyline_intersects_obstacles	(	const Polyline &	polyline,
		const ExPolygons &	obstacles )

{
    for (size_t idx = 1; idx < polyline.points.size(); ++idx)
        if (segment_enters_expolygons_interior(polyline.points[idx - 1], polyline.points[idx], obstacles))
            return true;
    return false;
}

References Slic3r::MultiPoint::points, polyline_intersects_obstacles(), and segment_enters_expolygons_interior().

Referenced by detour_around_obstacle(), and polyline_intersects_obstacles().

Here is the call graph for this function:

Here is the caller graph for this function:

polyline_length()

double Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::polyline_length

(

const Polyline &

polyline

)

{
    double length = 0.0;
    for (size_t idx = 1; idx < polyline.points.size(); ++idx)
        length += (polyline.points[idx] - polyline.points[idx - 1]).cast<double>().norm();
    return length;
}

References Slic3r::length(), Slic3r::MultiPoint::points, and polyline_length().

Referenced by detour_around_obstacle(), and polyline_length().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_segment()

void Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::replace_segment	(	Polyline &	path,
		size_t	segment_idx,
		const Polyline &	replacement )

{
    Points points;
    points.reserve(path.points.size() + replacement.points.size());
    for (size_t idx = 0; idx < segment_idx; ++idx)
        append_point(points, path.points[idx]);
    for (const Point &point : replacement.points)
        append_point(points, point);
    for (size_t idx = segment_idx + 2; idx < path.points.size(); ++idx)
        append_point(points, path.points[idx]);
    path.points = std::move(points);
}

References append_point(), Slic3r::MultiPoint::points, and replace_segment().

Referenced by replace_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

replacement_matches_original_segment()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::replacement_matches_original_segment	(	const Polyline &	replacement,
		const Point &	a,
		const Point &	b )

{
    return replacement.points.size() == 2 &&
           points_near(replacement.points.front(), a) && points_near(replacement.points.back(), b);
}

References Slic3r::MultiPoint::points, points_near(), and replacement_matches_original_segment().

Referenced by replacement_matches_original_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

routed_polyline_inside_bed()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::routed_polyline_inside_bed	(	const Polyline &	polyline,
		const ExPolygons &	valid_bed,
		const bool	allow_start_outside,
		const bool	allow_end_outside )

{
    if (valid_bed.empty())
        return true;
 
    const size_t last_idx = polyline.points.size() - 1;
    for (size_t idx = 0; idx < polyline.points.size(); ++idx) {
        if ((idx == 0 && allow_start_outside) || (idx == last_idx && allow_end_outside))
            continue;
        if (!point_in_expolygons(valid_bed, polyline.points[idx], true))
            return false;
    }
 
    for (size_t idx = 1; idx < polyline.points.size(); ++idx) {
        // A start or end produced by machine G-code may legitimately lie on
        // or beyond the printable boundary. Constrain only the route vertices
        // Orca adds; the firmware-defined transition to the bed remains intact.
        if ((idx == 1 && allow_start_outside) || (idx == last_idx && allow_end_outside))
            continue;
        if (!segment_inside_bed(polyline.points[idx - 1], polyline.points[idx], valid_bed))
            return false;
    }
    return true;
}

References point_in_expolygons(), Slic3r::MultiPoint::points, routed_polyline_inside_bed(), and segment_inside_bed().

Referenced by detour_around_obstacle(), and routed_polyline_inside_bed().

Here is the call graph for this function:

Here is the caller graph for this function:

segment_enters_expolygons_interior()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::segment_enters_expolygons_interior	(	const Point &	a,
		const Point &	b,
		const ExPolygons &	expolygons )

{
    if (expolygons.empty())
        return false;
    if (point_in_expolygons_interior(expolygons, a) || point_in_expolygons_interior(expolygons, b))
        return true;
 
    const std::vector<double> params = boundary_params_for_segment(a, b, expolygons);
    for (size_t idx = 1; idx < params.size(); ++idx) {
        const double low = params[idx - 1];
        const double high = params[idx];
        if (high - low < T_EPSILON)
            continue;
        if (point_in_expolygons_interior(expolygons, interpolate(a, b, 0.5 * (low + high))))
            return true;
    }
    return false;
}

References boundary_params_for_segment(), interpolate(), point_in_expolygons_interior(), segment_enters_expolygons_interior(), and T_EPSILON.

Referenced by polyline_intersects_obstacles(), segment_enters_expolygons_interior(), and simplify_path().

Here is the call graph for this function:

Here is the caller graph for this function:

segment_inside_bed()

bool Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::segment_inside_bed	(	const Point &	a,
		const Point &	b,
		const ExPolygons &	valid_bed )

{
    if (valid_bed.empty())
        return true;
    if (!point_in_expolygons(valid_bed, a, true) || !point_in_expolygons(valid_bed, b, true))
        return false;
 
    const std::vector<double> params = boundary_params_for_segment(a, b, valid_bed);
    for (size_t idx = 1; idx < params.size(); ++idx) {
        const double low = params[idx - 1];
        const double high = params[idx];
        if (high - low < T_EPSILON)
            continue;
        if (!point_in_expolygons(valid_bed, interpolate(a, b, 0.5 * (low + high)), false))
            return false;
    }
    return true;
}

References boundary_params_for_segment(), interpolate(), point_in_expolygons(), segment_inside_bed(), and T_EPSILON.

Referenced by routed_polyline_inside_bed(), segment_inside_bed(), and simplify_path().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_path()

Polyline Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::simplify_path	(	const Polyline &	path,
		const ExPolygons &	obstacles,
		const ExPolygons &	valid_bed )

{
    if (path.points.size() <= 2)
        return path;
 
    Points simplified;
    simplified.reserve(path.points.size());
    size_t current = 0;
    append_point(simplified, path.points.front());
    while (current + 1 < path.points.size()) {
        size_t next = path.points.size() - 1;
        for (; next > current + 1; --next) {
            if (segment_inside_bed(path.points[current], path.points[next], valid_bed) &&
                !segment_enters_expolygons_interior(path.points[current], path.points[next], obstacles))
                break;
        }
        append_point(simplified, path.points[next]);
        current = next;
    }
    return Polyline(std::move(simplified));
}

References append_point(), Slic3r::MultiPoint::points, segment_enters_expolygons_interior(), segment_inside_bed(), and simplify_path().

Referenced by simplify_path().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

MAX_REROUTE_ITERATIONS

size_t Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::MAX_REROUTE_ITERATIONS = 16

constexpr

T_EPSILON

double Slic3r::anonymous_namespace{ExclusionVolumeTravelAvoidance.cpp}::T_EPSILON = 1e-9

constexpr

Referenced by first_interior_param_for_segment(), line_intersection_t(), segment_enters_expolygons_interior(), and segment_inside_bed().