Slic3r::ExclusionVolumeTravelAvoidance Class Reference

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

Collaboration diagram for Slic3r::ExclusionVolumeTravelAvoidance:

Classes
struct	Result
struct	RoutingSpace

Public Types
enum class	Status : unsigned char { Unchanged , Rerouted , EndpointInside , Failed }
enum class	Detail : unsigned char {   None , UnknownExtruder , NoActiveObstacles , NoIntersection ,   EndpointInside , SegmentOutsideBed , DetourFailed , FinalPathInvalid ,   IterationLimit }

Public Member Functions
void	init (const PrintConfig &config, const Vec3d &plate_origin)
void	clear ()
bool	empty () const
Result	route (const Polyline &travel, double start_z, double end_z, int extruder_id)

Private Member Functions
const ExPolygons *	active_obstacles (RoutingSpace &space, double z_min, double z_max)

Private Attributes
std::vector< RoutingSpace >	m_spaces
coord_t	m_clearance { 0 }

Detailed Description

---

Class Documentation

Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace

struct Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace

Collaboration diagram for Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace:

Class Members
map< vector< size_t >, ExPolygons >	obstacle_cache
vector< BoundingBox >	region_bboxes
vector< BedExcludeRegion >	regions
ExPolygons	valid_bed

Member Enumeration Documentation

Detail

enum class Slic3r::ExclusionVolumeTravelAvoidance::Detail : unsigned char

strong

Enumerator
None
UnknownExtruder
NoActiveObstacles
NoIntersection
EndpointInside
SegmentOutsideBed
DetourFailed
FinalPathInvalid
IterationLimit

    {
        None,
        UnknownExtruder,
        NoActiveObstacles,
        NoIntersection,
        EndpointInside,
        SegmentOutsideBed,
        DetourFailed,
        FinalPathInvalid,
        IterationLimit
    };

Status

enum class Slic3r::ExclusionVolumeTravelAvoidance::Status : unsigned char

strong

Enumerator
Unchanged
Rerouted
EndpointInside
Failed

    {
        Unchanged,
        Rerouted,
        EndpointInside,
        Failed
    };

Member Function Documentation

active_obstacles()

const ExPolygons * Slic3r::ExclusionVolumeTravelAvoidance::active_obstacles ( RoutingSpace & space, double z_min, double z_max )

private

{
    std::vector<size_t> active_region_ids;
    active_region_ids.reserve(space.regions.size());
    for (size_t region_id = 0; region_id < space.regions.size(); ++region_id) {
        const BedExcludeRegion &region = space.regions[region_id];
        if (bed_exclusion_z_ranges_overlap(z_min, z_max, region.z_min, region.z_max))
            active_region_ids.emplace_back(region_id);
    }
    if (active_region_ids.empty())
        return nullptr;
 
    const auto cached = space.obstacle_cache.find(active_region_ids);
    if (cached != space.obstacle_cache.end())
        return cached->second.empty() ? nullptr : &cached->second;
 
    std::vector<BedExcludeRegion> active_regions;
    active_regions.reserve(active_region_ids.size());
    for (const size_t region_id : active_region_ids)
        active_regions.emplace_back(space.regions[region_id]);
 
    ExPolygons obstacles = active_bed_exclusion_footprints(
        active_regions, z_min, z_max, Point(0, 0), m_clearance);
    const auto cache_result = space.obstacle_cache.emplace(
        std::move(active_region_ids), std::move(obstacles));
    return cache_result.first->second.empty() ? nullptr : &cache_result.first->second;
}

References Slic3r::active_bed_exclusion_footprints(), Slic3r::bed_exclusion_z_ranges_overlap(), m_clearance, Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace::obstacle_cache, Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace::regions, Slic3r::BedExcludeRegion::z_max, and Slic3r::BedExcludeRegion::z_min.

Referenced by route().

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

void Slic3r::ExclusionVolumeTravelAvoidance::clear

(

)

{
    m_spaces.clear();
    m_clearance = static_cast<coord_t>(SCALED_EPSILON);
}

References m_clearance, m_spaces, and SCALED_EPSILON.

Referenced by init().

Here is the caller graph for this function:

empty()

bool Slic3r::ExclusionVolumeTravelAvoidance::empty

(

)

const

{
    return std::all_of(m_spaces.begin(), m_spaces.end(), [](const RoutingSpace &space) {
        return space.regions.empty();
    });
}

References m_spaces.

init()

void Slic3r::ExclusionVolumeTravelAvoidance::init	(	const PrintConfig &	config,
		const Vec3d &	plate_origin )

{
    clear();
 
    double max_nozzle_diameter = 0.0;
    for (double diameter : config.nozzle_diameter.values)
        max_nozzle_diameter = std::max(max_nozzle_diameter, diameter);
 
    // This is a numerical/perimeter-walk clearance, not a hidden toolhead
    // footprint. The exact configured volume remains Stage 2's source of truth.
    const coord_t minimum_clearance = static_cast<coord_t>(SCALED_EPSILON);
    const coord_t configured_clearance =
        static_cast<coord_t>(scale_(std::max(0.05, 0.1 * max_nozzle_diameter)));
    m_clearance = std::max(minimum_clearance, configured_clearance);
 
    std::vector<std::vector<BedExcludeRegion>> regions_by_extruder =
        get_bed_excluded_regions_by_extruder(config);
    m_spaces.resize(regions_by_extruder.size());
 
    const Polygon base_bed_shape(get_bed_shape(config));
    const Vec2d plate_xy = plate_origin.head<2>();
    for (size_t extruder_id = 0; extruder_id < regions_by_extruder.size(); ++extruder_id) {
        RoutingSpace &space = m_spaces[extruder_id];
        space.regions = std::move(regions_by_extruder[extruder_id]);
        space.regions.erase(std::remove_if(space.regions.begin(), space.regions.end(),
            [](const BedExcludeRegion &region) { return !region.is_collision_volume(); }), space.regions.end());
 
        const Vec2d extruder_offset = extruder_id < config.extruder_offset.values.size() ?
            config.extruder_offset.values[extruder_id] : Vec2d::Zero();
        // Resolved regions are in nozzle/model space. The generator routes in
        // emitted G-code space (model - active nozzle offset), before the writer
        // subtracts the plate origin, so transform both obstacles and bed alike.
        const Vec2d translation_mm = plate_xy - extruder_offset;
        const Point translation = scaled<coord_t>(translation_mm);
        for (BedExcludeRegion &region : space.regions) {
            region.polygon.translate(translation);
            BoundingBox bbox(region.polygon.points);
            bbox.offset(m_clearance);
            space.region_bboxes.emplace_back(std::move(bbox));
        }
 
        Polygon bed_shape = base_bed_shape;
        bed_shape.translate(translation);
        bed_shape.make_counter_clockwise();
        if (bed_shape.points.size() >= 3) {
            space.valid_bed = offset_ex(bed_shape, -float(m_clearance));
            if (space.valid_bed.empty())
                space.valid_bed = union_ex(Polygons { std::move(bed_shape) });
        }
    }
}

References clear(), Slic3r::extruder_offset(), Slic3r::get_bed_excluded_regions_by_extruder(), Slic3r::get_bed_shape(), m_clearance, m_spaces, Slic3r::Polygon::make_counter_clockwise(), Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::offset_ex(), Slic3r::MultiPoint::points, Slic3r::BedExcludeRegion::polygon, Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace::region_bboxes, Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace::regions, scale_, Slic3r::scaled(), SCALED_EPSILON, Slic3r::MultiPoint::translate(), Slic3r::union_ex(), and Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace::valid_bed.

Here is the call graph for this function:

route()

ExclusionVolumeTravelAvoidance::Result Slic3r::ExclusionVolumeTravelAvoidance::route	(	const Polyline &	travel,
		double	start_z,
		double	end_z,
		int	extruder_id )

{
    Result result;
    result.path = travel;
    if (travel.points.size() < 2)
        return result;
    if (extruder_id < 0 || size_t(extruder_id) >= m_spaces.size()) {
        result.status = Status::Failed;
        result.detail = Detail::UnknownExtruder;
        return result;
    }
 
    RoutingSpace &space = m_spaces[size_t(extruder_id)];
    if (space.regions.empty()) {
        result.detail = Detail::NoActiveObstacles;
        return result;
    }
 
    const double z_min = std::min(start_z, end_z);
    const double z_max = std::max(start_z, end_z);
 
    // Most travels are nowhere near an exclusion. Reject them using the cheap
    // precomputed boxes before unioning and inflating obstacle polygons.
    const BoundingBox travel_bbox(travel.points);
    bool has_active_z = false;
    bool may_intersect = false;
    for (size_t region_id = 0; region_id < space.regions.size(); ++region_id) {
        const BedExcludeRegion &region = space.regions[region_id];
        if (!bed_exclusion_z_ranges_overlap(z_min, z_max, region.z_min, region.z_max))
            continue;
        has_active_z = true;
        if (region_id < space.region_bboxes.size() && space.region_bboxes[region_id].overlap(travel_bbox)) {
            may_intersect = true;
            break;
        }
    }
    if (!has_active_z) {
        result.detail = Detail::NoActiveObstacles;
        return result;
    }
    if (!may_intersect) {
        result.detail = Detail::NoIntersection;
        return result;
    }
 
    const ExPolygons *active = active_obstacles(space, z_min, z_max);
    if (active == nullptr || active->empty()) {
        result.detail = Detail::NoActiveObstacles;
        return result;
    }
    result.active_obstacles = active->size();
 
    const Point &start = travel.points.front();
    const Point &end = travel.points.back();
    const bool start_outside_bed = !space.valid_bed.empty() &&
        !point_in_expolygons(space.valid_bed, start, true);
    const bool end_outside_bed = !space.valid_bed.empty() &&
        !point_in_expolygons(space.valid_bed, end, true);
    const ExPolygons *start_obstacles = active_obstacles(space, start_z, start_z);
    const ExPolygons *end_obstacles = active_obstacles(space, end_z, end_z);
    if ((start_obstacles != nullptr && point_in_expolygons_interior(*start_obstacles, start)) ||
        (end_obstacles != nullptr && point_in_expolygons_interior(*end_obstacles, end))) {
        result.status = Status::EndpointInside;
        result.detail = Detail::EndpointInside;
        return result;
    }
 
    bool needs_reroute = false;
    for (size_t idx = 1; idx < travel.points.size(); ++idx) {
        if (segment_enters_expolygons_interior(travel.points[idx - 1], travel.points[idx], *active)) {
            needs_reroute = true;
            break;
        }
    }
    if (!needs_reroute) {
        result.detail = Detail::NoIntersection;
        return result;
    }
 
    Polyline path = travel;
    bool rerouted = false;
    for (size_t iteration = 0; iteration < MAX_REROUTE_ITERATIONS; ++iteration) {
        result.iterations = iteration + 1;
        bool changed = false;
        for (size_t segment_idx = 0; segment_idx + 1 < path.points.size(); ++segment_idx) {
            const Point &a = path.points[segment_idx];
            const Point &b = path.points[segment_idx + 1];
            const bool allow_a_outside = start_outside_bed && segment_idx == 0;
            const bool allow_b_outside = end_outside_bed && segment_idx + 2 == path.points.size();
            const Polyline segment({a, b});
            if (!routed_polyline_inside_bed(
                    segment, space.valid_bed, allow_a_outside, allow_b_outside)) {
                result.status = Status::Failed;
                result.detail = Detail::SegmentOutsideBed;
                return result;
            }
 
            const std::optional<size_t> obstacle_idx = first_intersected_obstacle(a, b, *active);
            if (!obstacle_idx)
                continue;
 
            const std::optional<Polyline> detour = detour_around_obstacle(
                a, b, (*active)[*obstacle_idx], *active, space.valid_bed,
                allow_a_outside, allow_b_outside);
            if (!detour) {
                result.status = Status::Failed;
                result.detail = Detail::DetourFailed;
                return result;
            }
            if (replacement_matches_original_segment(*detour, a, b))
                continue;
 
            replace_segment(path, segment_idx, *detour);
            changed = true;
            rerouted = true;
            break;
        }
 
        if (!changed) {
            path = simplify_path(path, *active, space.valid_bed);
            if (!routed_polyline_inside_bed(
                    path, space.valid_bed, start_outside_bed, end_outside_bed) ||
                polyline_intersects_obstacles(path, *active)) {
                result.status = Status::Failed;
                result.detail = Detail::FinalPathInvalid;
                return result;
            }
            result.path = std::move(path);
            result.status = rerouted ? Status::Rerouted : Status::Unchanged;
            result.detail = rerouted ? Detail::None : Detail::NoIntersection;
            return result;
        }
    }
 
    result.status = Status::Failed;
    result.detail = Detail::IterationLimit;
    return result;
}

References active_obstacles(), Slic3r::ExclusionVolumeTravelAvoidance::Result::active_obstacles, Slic3r::bed_exclusion_z_ranges_overlap(), Slic3r::ExclusionVolumeTravelAvoidance::Result::detail, DetourFailed, EndpointInside, Failed, FinalPathInvalid, IterationLimit, Slic3r::ExclusionVolumeTravelAvoidance::Result::iterations, m_spaces, NoActiveObstacles, NoIntersection, None, Slic3r::ExclusionVolumeTravelAvoidance::Result::path, Slic3r::MultiPoint::points, Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace::region_bboxes, Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace::regions, Rerouted, SegmentOutsideBed, Slic3r::ExclusionVolumeTravelAvoidance::Result::status, Unchanged, UnknownExtruder, Slic3r::ExclusionVolumeTravelAvoidance::RoutingSpace::valid_bed, Slic3r::BedExcludeRegion::z_max, and Slic3r::BedExcludeRegion::z_min.

Here is the call graph for this function:

Member Data Documentation

m_clearance

coord_t Slic3r::ExclusionVolumeTravelAvoidance::m_clearance { 0 }

private

{ 0 };

Referenced by active_obstacles(), clear(), and init().

m_spaces

std::vector<RoutingSpace> Slic3r::ExclusionVolumeTravelAvoidance::m_spaces

private

Referenced by clear(), empty(), init(), and route().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/ExclusionVolumeTravelAvoidance.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/ExclusionVolumeTravelAvoidance.cpp