Slic3r::TimelapsePosPicker Class Reference

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

Collaboration diagram for Slic3r::TimelapsePosPicker:

Public Member Functions
	TimelapsePosPicker ()=default
	~TimelapsePosPicker ()=default
Point	pick_pos (const PosPickCtx &ctx)
bool	get_is_clear_to_x0 (const PosPickCtx &ctx)
void	init (const Print *print, const Point &plate_offset)
void	reset ()

Private Member Functions
void	construct_printable_area_by_printer ()
	Constructs the printable area based on printer configuration.
Point	pick_pos_for_curr_layer (const PosPickCtx &ctx)
Point	pick_pos_for_all_layer (const PosPickCtx &ctx)
ExPolygons	collect_object_slices_data (const Layer *curr_layer, float height_range, const std::vector< const PrintObject * > &object_list, bool by_object)
	Collects object slice data within a specified height range for a given layer.
Polygons	collect_limit_areas_for_camera (const std::vector< const PrintObject * > &object_list)
Polygons	collect_limit_areas_for_rod (const std::vector< const PrintObject * > &object_list, const PosPickCtx &ctx)
Polygon	expand_object_projection (const Polygon &poly, bool by_object, bool higher_than_curr=true)
BoundingBoxf3	expand_object_bbox (const BoundingBoxf3 &bbox, bool by_object)
Point	pick_nearest_object_center (const Point &curr_pos, const std::vector< const PrintObject * > &object_list)
Point	get_objects_center (const std::vector< const PrintObject * > &object_list)
	Calculates the center of multiple objects.
Polygon	get_limit_area_for_camera (const PrintObject *obj)
std::vector< const PrintObject * >	get_object_list (const std::optional< std::vector< const PrintObject * > > &printed_objects)
	Retrieves a list of print objects based on the provided optional set of printed objects.
double	get_raft_height (const PrintObject *obj)
BoundingBoxf3	get_real_instance_bbox (const PrintInstance &instance)
Point	get_object_center (const PrintObject *obj)

Private Attributes
const Print *	print { nullptr }
std::vector< ExPolygons >	m_extruder_printable_area
Polygon	m_bed_polygon
Point	m_plate_offset
int	m_plate_height
int	m_plate_width
PrintSequence	m_print_seq
bool	m_based_on_all_layer
int	m_nozzle_height_to_rod
int	m_nozzle_clearance_radius
std::optional< int >	m_liftable_extruder_id
std::optional< int >	m_extruder_height_gap
std::unordered_map< const PrintInstance *, BoundingBoxf3 >	bbox_cache
std::optional< Point >	m_all_layer_pos

Detailed Description

Constructor & Destructor Documentation

TimelapsePosPicker()

Slic3r::TimelapsePosPicker::TimelapsePosPicker ( )

default

~TimelapsePosPicker()

Slic3r::TimelapsePosPicker::~TimelapsePosPicker ( )

default

References print.

Member Function Documentation

collect_limit_areas_for_camera()

Polygons Slic3r::TimelapsePosPicker::collect_limit_areas_for_camera ( const std::vector< const PrintObject * > & object_list )

private

    {
        Polygons ret;
        for (auto& obj : object_list)
            ret.emplace_back(get_limit_area_for_camera(obj));
        ret = union_(ret);
        return ret;
    }

References get_limit_area_for_camera(), and Slic3r::union_().

Referenced by pick_pos_for_all_layer(), and pick_pos_for_curr_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_limit_areas_for_rod()

Polygons Slic3r::TimelapsePosPicker::collect_limit_areas_for_rod ( const std::vector< const PrintObject * > & object_list, const PosPickCtx & ctx )

private

    {
        double rod_limit_height = m_nozzle_height_to_rod + ctx.curr_layer->print_z;
        std::vector<const PrintObject*> rod_collision_candidates;
        for(auto& obj : object_list){
            if(ctx.printed_objects && obj == ctx.printed_objects->back())
                continue;
            auto bbox = get_real_instance_bbox(obj->instances().front());
            if(bbox.max.z() >= rod_limit_height)
                rod_collision_candidates.push_back(obj);
        }
 
        if (rod_collision_candidates.empty())
            return {};
 
 
        std::vector<BoundingBoxf3> collision_obj_bboxs;
        for (auto obj : rod_collision_candidates) {
            collision_obj_bboxs.emplace_back(
                expand_object_bbox(
                    get_real_instance_bbox(obj->instances().front()),
                    m_print_seq == PrintSequence::ByObject
                )
            );
        }
 
        std::sort(collision_obj_bboxs.begin(), collision_obj_bboxs.end(), [&](const auto& lbbox, const auto& rbbox) {
            if (lbbox.min.y() == rbbox.min.y())
                return lbbox.max.y() < rbbox.max.y();
            return lbbox.min.y() < rbbox.min.y();
            });
 
        std::vector<std::pair<int,int>> object_y_ranges = {{0,0}};
        for(auto& bbox : collision_obj_bboxs){
            if( object_y_ranges.back().second >= bbox.min.y())
                object_y_ranges.back().second = bbox.max.y();
            else
                object_y_ranges.emplace_back(bbox.min.y(), bbox.max.y());
        }
 
        if (object_y_ranges.back().second < m_plate_height)
            object_y_ranges.emplace_back(m_plate_height, m_plate_height);
 
        int lower_y_pos = -1, upper_y_pos =-1;
        Point unscaled_curr_pos = {unscale_(ctx.curr_pos.x())-m_plate_offset.x(), unscale_(ctx.curr_pos.y()) - m_plate_offset.y()};
 
        for (size_t idx = 1; idx < object_y_ranges.size(); ++idx) {
            if (unscaled_curr_pos.y() >= object_y_ranges[idx - 1].second && unscaled_curr_pos.y() <= object_y_ranges[idx].first) {
                lower_y_pos = object_y_ranges[idx - 1].second;
                upper_y_pos = object_y_ranges[idx].first;
                break;
            }
        }
 
        if(lower_y_pos == -1 && upper_y_pos == -1)
            return { m_bed_polygon };
 
        Polygons ret;
 
        ret.emplace_back(
            Polygon{
                Point{scale_(0), scale_(0)},
                Point{scale_(m_plate_width), scale_(0)},
                Point{scale_(m_plate_width), scale_(lower_y_pos)},
                Point{scale_(0), scale_(lower_y_pos)}
            }
        );
 
        ret.emplace_back(
            Polygon{
                Point{scale_(0), scale_(upper_y_pos)},
                Point{scale_(m_plate_width), scale_(upper_y_pos)},
                Point{scale_(m_plate_width), scale_(m_plate_height)},
                Point{scale_(0), scale_(m_plate_height)}
            }
        );
        return ret;
    }

References Slic3r::ByObject, Slic3r::PosPickCtx::curr_layer, Slic3r::PosPickCtx::curr_pos, expand_object_bbox(), get_real_instance_bbox(), m_bed_polygon, m_nozzle_height_to_rod, m_plate_height, m_plate_offset, m_plate_width, m_print_seq, Slic3r::Layer::print_z, Slic3r::PosPickCtx::printed_objects, scale_, and unscale_.

Referenced by pick_pos_for_curr_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_object_slices_data()

ExPolygons Slic3r::TimelapsePosPicker::collect_object_slices_data ( const Layer * layer, float height_range, const std::vector< const PrintObject * > & object_list, bool by_object )

private

Collects object slice data within a specified height range for a given layer.

Parameters

layer	The layer for which slices are being collected.
height_range	The height range to consider for collecting slices.
object_list	List of print objects to process.
by_object	Decides the expand length of polygon

Returns

ExPolygons representing the collected slice data.

    {
        auto range_intersect = [](int left1, int right1, int left2, int right2) {
            if (left1 <= left2 && left2 <= right1)
                return true;
            if (left2 <= left1 && left1 <= right2)
                return true;
            return false;
            };
        ExPolygons ret;
        float z_target = layer->print_z;
        float z_low = height_range < 0 ? layer->print_z + height_range : layer->print_z;
        float z_high = height_range < 0 ? layer->print_z : layer->print_z + height_range;
        if (z_low <= 0)
            return to_expolygons({ m_bed_polygon });
 
        for (auto& obj : object_list) {
            for (auto& instance : obj->instances()) {
                auto instance_bbox = get_real_instance_bbox(instance);
                bool higher_than_curr_layer = (layer->object() == obj)  ?  false : instance_bbox.max.z() > z_target;
                if(range_intersect(instance_bbox.min.z(), instance_bbox.max.z(), z_low, z_high)){
                    ExPolygon expoly;
                    expoly.contour = {
                        {scale_(instance_bbox.min.x()), scale_(instance_bbox.min.y())},
                        {scale_(instance_bbox.max.x()), scale_(instance_bbox.min.y())},
                        {scale_(instance_bbox.max.x()), scale_(instance_bbox.max.y())},
                        {scale_(instance_bbox.min.x()), scale_(instance_bbox.max.y())}
                    };
                    expoly.contour = expand_object_projection(expoly.contour, by_object, higher_than_curr_layer);
                    ret.emplace_back(std::move(expoly));
                }
            }
        }
        ret = union_ex(ret);
        return ret;
    }

References Slic3r::ExPolygon::contour, expand_object_projection(), get_real_instance_bbox(), m_bed_polygon, Slic3r::Layer::object(), Slic3r::Layer::print_z, scale_, Slic3r::to_expolygons(), and Slic3r::union_ex().

Referenced by pick_pos_for_curr_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

construct_printable_area_by_printer()

void Slic3r::TimelapsePosPicker::construct_printable_area_by_printer ( )

private

Constructs the printable area based on printer configuration.

This function initializes the bed polygon, excludes specific areas, accounts for wipe towers, and calculates the printable area for each extruder.

    {
        auto config = print->config();
        size_t extruder_count = config.nozzle_diameter.size();
        m_extruder_printable_area.clear();
        m_extruder_printable_area.resize(extruder_count);
 
        for (size_t idx = 0; idx < config.printable_area.values.size(); ++idx)
            m_bed_polygon.points.emplace_back(coord_t(scale_(config.printable_area.values[idx].x())), coord_t(scale_(config.printable_area.values[idx].y())));
 
        auto bed_bbox = get_extents(m_bed_polygon);
        m_plate_height = unscale_(bed_bbox.max.y());
        m_plate_width = unscale_(bed_bbox.max.x());
 
        // Timelapse positions are selected in the bed plane. Use the resolved
        // bed-level footprints instead of the legacy flat point array, which
        // cannot represent multiple or per-nozzle exclusion polygons.
        const Polygons bed_exclude_areas = get_bed_excluded_area(config);
 
        Point base_wp_pt = print->get_fake_wipe_tower().pos.cast<coord_t>();
        base_wp_pt = Point{ scale_(base_wp_pt.x()),scale_(base_wp_pt.y()) };
 
        auto transform_wt_pt = [base_wp_pt](const Point& pt) -> Point {
            Point out =pt;
            out += base_wp_pt;
            return out;
            };
        auto wt_box = print->wipe_tower_data().bbx;
        Polygon wipe_tower_area{
            {transform_wt_pt({scale_(wt_box.min.x()),scale_(wt_box.min.y())})},
            {transform_wt_pt({scale_(wt_box.max.x()),scale_(wt_box.min.y())})},
            {transform_wt_pt({scale_(wt_box.max.x()),scale_(wt_box.max.y())})},
            {transform_wt_pt({scale_(wt_box.min.x()),scale_(wt_box.max.y())})}
        };
        wipe_tower_area = expand_object_projection(wipe_tower_area, m_print_seq == PrintSequence::ByObject);
 
        for (size_t idx = 0; idx < extruder_count; ++idx) {
            ExPolygons printable_area = diff_ex(diff(Polygons{ m_bed_polygon }, bed_exclude_areas), { wipe_tower_area });
            if (idx < config.extruder_printable_area.size()) {
                Polygon extruder_printable_area;
                for (size_t j = 0; j < config.extruder_printable_area.values[idx].size(); ++j)
                    extruder_printable_area.points.emplace_back(coord_t(scale_(config.extruder_printable_area.values[idx][j].x())), coord_t(scale_(config.extruder_printable_area.values[idx][j].y())));
                printable_area = intersection_ex(printable_area, Polygons{ extruder_printable_area });
            }
            m_extruder_printable_area[idx] = printable_area;
        }
    }

References Slic3r::ByObject, Slic3r::diff(), Slic3r::diff_ex(), expand_object_projection(), Slic3r::get_bed_excluded_area(), Slic3r::get_extents(), Slic3r::intersection_ex(), m_bed_polygon, m_extruder_printable_area, m_plate_height, m_plate_width, m_print_seq, Slic3r::MultiPoint::points, print, Slic3r::printable_area(), scale_, and unscale_.

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

expand_object_bbox()

BoundingBoxf3 Slic3r::TimelapsePosPicker::expand_object_bbox ( const BoundingBoxf3 & bbox, bool by_object )

private

    {
        float radius = 0;
        if (by_object)
            radius = print->config().extruder_clearance_radius.value;
        else
            radius = print->config().extruder_clearance_radius.value / 2;
 
        BoundingBoxf3 ret = bbox;
        ret.min.x() -= radius;
        ret.min.y() -= radius;
        ret.max.x() += radius;
        ret.max.y() += radius;
 
        return ret;
    }

References Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and print.

Referenced by collect_limit_areas_for_rod().

Here is the caller graph for this function:

expand_object_projection()

Polygon Slic3r::TimelapsePosPicker::expand_object_projection ( const Polygon & poly, bool by_object, bool higher_than_curr = true )

private

    {
        float radius = 0;
        if (by_object) {
            if (higher_than_curr) {
                radius = scale_(print->config().extruder_clearance_radius.value);
            }else{
                radius = scale_(print->config().extruder_clearance_radius.value / 2);
            }
        }
        else
            radius = scale_(print->config().extruder_clearance_radius.value / 2);
 
        // the input poly is bounding box, so we get the first offseted polygon is ok
        auto ret = offset(poly, radius);
        if (ret.empty())
            return {};
        return ret[0];
    }

References Slic3r::offset(), print, and scale_.

Referenced by collect_object_slices_data(), construct_printable_area_by_printer(), get_is_clear_to_x0(), and pick_pos_for_all_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_is_clear_to_x0()

bool Slic3r::TimelapsePosPicker::get_is_clear_to_x0

(

const PosPickCtx &

ctx

)

    {
        bool by_object = m_print_seq == PrintSequence::ByObject;
        std::vector<const PrintObject *> object_list    = get_object_list(ctx.printed_objects);
 
        auto range_intersect = [](int left1, int right1, int left2, int right2) {
            if (left1 <= left2 && left2 <= right1) return true;
            if (left2 <= left1 && left1 <= right2) return true;
            return false;
        };
 
        ExPolygons   unclear_area;
        const Layer *layer    = ctx.curr_layer;
        float        z_target = layer->print_z;
        float        z_low    = layer->print_z - 0.5;
        float        z_high   = layer->print_z + 0.5;
 
        for (auto &obj : object_list) {
            for (auto &instance : obj->instances()) {
                auto instance_bbox          = get_real_instance_bbox(instance);
                bool is_curr_obj = ( obj == object_list.back() ) || ( !by_object ),
                    higher_than_curr_pos = instance_bbox.max.z() > z_target;
                if (!is_curr_obj && range_intersect(instance_bbox.min.z(), instance_bbox.max.z(), z_low, z_high)) {
                    ExPolygon expoly;
                    expoly.contour = {{scale_(instance_bbox.min.x()), scale_(instance_bbox.min.y())},
                                      {scale_(instance_bbox.max.x()), scale_(instance_bbox.min.y())},
                                      {scale_(instance_bbox.max.x()), scale_(instance_bbox.max.y())},
                                      {scale_(instance_bbox.min.x()), scale_(instance_bbox.max.y())}};
                    expoly.contour = expand_object_projection(expoly.contour, by_object, higher_than_curr_pos);
                    unclear_area.emplace_back(std::move(expoly));
                }
            }
        }
 
        Point curr_pos_in_plate = {ctx.curr_pos.x() - scale_(m_plate_offset.x()), ctx.curr_pos.y() - scale_(m_plate_offset.y())};
        for (const ExPolygon &expoly : unclear_area) {
            BoundingBox bbox = expoly.contour.bounding_box();
            if (curr_pos_in_plate.y() < bbox.min.y() || curr_pos_in_plate.y() > bbox.max.y()) continue;
            if (bbox.min.x() <= curr_pos_in_plate.x()) return false;
        }
 
        return true;
    }

References Slic3r::ByObject, Slic3r::ExPolygon::contour, Slic3r::PosPickCtx::curr_layer, Slic3r::PosPickCtx::curr_pos, expand_object_projection(), get_object_list(), get_real_instance_bbox(), m_plate_offset, m_print_seq, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::Layer::print_z, Slic3r::PosPickCtx::printed_objects, and scale_.

Here is the call graph for this function:

get_limit_area_for_camera()

Polygon Slic3r::TimelapsePosPicker::get_limit_area_for_camera ( const PrintObject * obj )

private

    {
        if (!obj)
            return {};
        auto bbox = get_real_instance_bbox(obj->instances().front());
        float radius = m_nozzle_clearance_radius / 2;
 
        auto offset_bbox = bbox.inflated(sqrt(2) * radius);
        // Constrain the coordinates to the first quadrant.
        Polygon ret = {
            DefaultCameraPos,
            Point{std::max(scale_(offset_bbox.max.x()),0.),std::max(scale_(offset_bbox.min.y()),0.)},
            Point{std::max(scale_(offset_bbox.max.x()),0.),std::max(scale_(offset_bbox.max.y()),0.)},
            Point{std::max(scale_(offset_bbox.min.x()),0.),std::max(scale_(offset_bbox.max.y()),0.)}
        };
        return ret;
    }

References Slic3r::DefaultCameraPos, get_real_instance_bbox(), Slic3r::PrintObject::instances(), m_nozzle_clearance_radius, and scale_.

Referenced by collect_limit_areas_for_camera().

Here is the call graph for this function:

Here is the caller graph for this function:

get_object_center()

Point Slic3r::TimelapsePosPicker::get_object_center ( const PrintObject * obj )

private

    {
        if (!obj)
            return {};
        // in bambu studio, each object only has one instance
        const auto& instance = obj->instances().front();
        auto instance_bbox = get_real_instance_bbox(instance);
        Point min_p{ instance_bbox.min.x(),instance_bbox.min.y() };
        Point max_p{ instance_bbox.max.x(),instance_bbox.max.y() };
 
        return { scale_((min_p.x() + max_p.x()) / 2),scale_((min_p.y() + max_p.y()) / 2) };
    }

References get_real_instance_bbox(), Slic3r::PrintObject::instances(), and scale_.

Referenced by pick_nearest_object_center(), and pick_pos_for_curr_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_object_list()

std::vector< const PrintObject * > Slic3r::TimelapsePosPicker::get_object_list ( const std::optional< std::vector< const PrintObject * > > & printed_objects )

private

Retrieves a list of print objects based on the provided optional set of printed objects.

If the optional set of printed objects is provided, it converts the set into a vector. Otherwise, it retrieves all objects from the print instance.

    {
        std::vector<const PrintObject*> object_list;
        if (printed_objects.has_value()) {
            object_list = std::vector<const PrintObject*>(printed_objects->begin(), printed_objects->end());
        }
        else {
            object_list = std::vector<const PrintObject*>(print->objects().begin(), print->objects().end());
        }
        return object_list;
    }

References print.

Referenced by get_is_clear_to_x0(), pick_pos_for_all_layer(), and pick_pos_for_curr_layer().

Here is the caller graph for this function:

get_objects_center()

Point Slic3r::TimelapsePosPicker::get_objects_center ( const std::vector< const PrintObject * > & object_list )

private

Calculates the center of multiple objects.

This function computes the average center of all instances of the provided objects.

Parameters

object_list

A vector of pointers to PrintObject instances.

Returns

Point The average center of all objects.Scaled data

    {
        if (object_list.empty())
            return Point(0,0);
        double sum_x = 0.0;
        double sum_y = 0.0;
        size_t total_instances = 0;
        for (auto& obj : object_list) {
            for (auto& instance : obj->instances()) {
                const auto& bbox = get_real_instance_bbox(instance);
                Point min_p{ bbox.min.x(),bbox.min.y() };
                Point max_p{ bbox.max.x(),bbox.max.y() };
                double center_x = (min_p.x() + max_p.x()) / 2.f;
                double center_y = (min_p.y() + max_p.y()) / 2.f;
                sum_x += center_x;
                sum_y += center_y;
                total_instances += 1;
            }
        }
        return Point{ coord_t(scale_(sum_x / total_instances)),coord_t(scale_(sum_y / total_instances)) };
    }

References get_real_instance_bbox(), and scale_.

Referenced by pick_pos_for_all_layer(), and pick_pos_for_curr_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_raft_height()

double Slic3r::TimelapsePosPicker::get_raft_height ( const PrintObject * obj )

private

    {
        if (!obj || !obj->has_raft())
            return 0;
        auto slice_params = obj->slicing_parameters();
        int base_raft_layers = slice_params.base_raft_layers;
        double base_raft_height = slice_params.base_raft_layer_height;
        int interface_raft_layers = slice_params.interface_raft_layers;
        double interface_raft_height = slice_params.interface_raft_layer_height;
        double contact_raft_layer_height = slice_params.contact_raft_layer_height;
 
        double ret = print->config().initial_layer_print_height;
        if (base_raft_layers - 1 > 0)
            ret += (base_raft_layers - 1) * base_raft_height;
        if (interface_raft_layers - 1 > 0)
            ret += (interface_raft_layers - 1) * interface_raft_height;
        if (obj->config().raft_layers > 1)
            ret += contact_raft_layer_height;
 
        return ret + slice_params.gap_raft_object;
    }

References Slic3r::SlicingParameters::base_raft_layers, Slic3r::PrintObject::config(), Slic3r::PrintObject::has_raft(), print, and Slic3r::PrintObject::slicing_parameters().

Referenced by get_real_instance_bbox().

Here is the call graph for this function:

Here is the caller graph for this function:

get_real_instance_bbox()

BoundingBoxf3 Slic3r::TimelapsePosPicker::get_real_instance_bbox ( const PrintInstance & instance )

private

    {
        auto iter = bbox_cache.find(&instance);
        if (iter != bbox_cache.end())
            return iter->second;
 
        auto bbox = instance.get_bounding_box();
        double raft_height =get_raft_height(instance.print_object);
        bbox.max.z() += raft_height;
        // remove plate offset
        bbox.min.x() -= m_plate_offset.x();
        bbox.max.x() -= m_plate_offset.x();
        bbox.min.y() -= m_plate_offset.y();
        bbox.max.y() -= m_plate_offset.y();
 
        bbox_cache[&instance] = bbox;
 
        return bbox;
    }

References bbox_cache, Slic3r::PrintInstance::get_bounding_box(), get_raft_height(), m_plate_offset, and Slic3r::PrintInstance::print_object.

Referenced by collect_limit_areas_for_rod(), collect_object_slices_data(), get_is_clear_to_x0(), get_limit_area_for_camera(), get_object_center(), get_objects_center(), and pick_pos_for_all_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void Slic3r::TimelapsePosPicker::init	(	const Print *	print,
		const Point &	plate_offset )

    {
        reset();
        m_plate_offset = plate_offset;
        print = print_;
 
        m_nozzle_height_to_rod = print_->config().extruder_clearance_height_to_rod;
        m_nozzle_clearance_radius = print_->config().extruder_clearance_radius;
        if (print_->config().nozzle_diameter.size() > 1 && print_->config().extruder_printable_height.size() > 1) {
            m_extruder_height_gap = std::abs(print_->config().extruder_printable_height.values[0] - print_->config().extruder_printable_height.values[1]);
            m_liftable_extruder_id = print_->config().extruder_printable_height.values[0] < print_->config().extruder_printable_height.values[1] ? 0 : 1;
        }
        m_print_seq = print_->config().print_sequence.value;
        m_based_on_all_layer = print_->config().timelapse_type == TimelapseType::tlSmooth;
 
        construct_printable_area_by_printer();
    }

References Slic3r::Print::config(), construct_printable_area_by_printer(), m_based_on_all_layer, m_extruder_height_gap, m_liftable_extruder_id, m_nozzle_clearance_radius, m_nozzle_height_to_rod, m_plate_offset, m_print_seq, print, reset(), and Slic3r::tlSmooth.

Here is the call graph for this function:

pick_nearest_object_center()

Point Slic3r::TimelapsePosPicker::pick_nearest_object_center ( const Point & curr_pos, const std::vector< const PrintObject * > & object_list )

private

    {
        if (object_list.empty())
            return {};
        const PrintObject* ptr = object_list.front();
        double distance = std::numeric_limits<double>::max();
        for (auto& obj : object_list) {
            Point obj_center = get_object_center(obj);
            double dist = (obj_center - curr_pos).cast<double>().norm();
            if (distance > dist) {
                distance = dist;
                ptr = obj;
            }
        }
        return get_object_center(ptr);
    }

References Slic3r::cast(), Slic3r::Geometry::dist(), and get_object_center().

Here is the call graph for this function:

pick_pos()

Point Slic3r::TimelapsePosPicker::pick_pos

(

const PosPickCtx &

ctx

)

    {
        Point res;
        if (m_based_on_all_layer)
            res = pick_pos_for_all_layer(ctx);
        else
            res = pick_pos_for_curr_layer(ctx);
 
        return { unscale_(res.x()), unscale_(res.y()) };
    }

References m_based_on_all_layer, pick_pos_for_all_layer(), pick_pos_for_curr_layer(), and unscale_.

Here is the call graph for this function:

pick_pos_for_all_layer()

Point Slic3r::TimelapsePosPicker::pick_pos_for_all_layer ( const PosPickCtx & ctx )

private

    {
        bool by_object = m_print_seq == PrintSequence::ByObject;
        if (by_object)
            return DefaultTimelapsePos;
 
        float height_gap = 0;
        if (ctx.curr_extruder_id != ctx.picture_extruder_id) {
            if (m_liftable_extruder_id.has_value() && ctx.picture_extruder_id != m_liftable_extruder_id && m_extruder_height_gap.has_value())
                height_gap = *m_extruder_height_gap;
        }
        if (ctx.curr_layer->print_z < height_gap)
            return DefaultTimelapsePos;
        if (m_all_layer_pos)
            return *m_all_layer_pos;
 
        Polygons object_projections;
 
        auto object_list = get_object_list(std::nullopt);
 
        for (auto& obj : object_list) {
            for (auto& instance : obj->instances()) {
                const auto& bbox = get_real_instance_bbox(instance);
                Point min_p{ scale_(bbox.min.x()),scale_(bbox.min.y()) };
                Point max_p{ scale_(bbox.max.x()),scale_(bbox.max.y()) };
                Polygon obj_proj{ { min_p.x(),min_p.y() },
                    { max_p.x(),min_p.y() },
                    { max_p.x(),max_p.y() },
                    { min_p.x(),max_p.y() }
                };
                object_projections.emplace_back(expand_object_projection(obj_proj, by_object));
            }
        };
 
 
        object_projections = union_(object_projections);
        Polygons camera_limit_areas = collect_limit_areas_for_camera(object_list);
        Polygons unplacable_area = union_(object_projections, camera_limit_areas);
 
        ExPolygons extruder_printable_area;
        if (m_extruder_printable_area.size() > 1)
            extruder_printable_area = intersection_ex(m_extruder_printable_area[0], m_extruder_printable_area[1]);
        else if (m_extruder_printable_area.size() == 1)
            extruder_printable_area = m_extruder_printable_area.front();
 
        ExPolygons safe_area = diff_ex(extruder_printable_area, unplacable_area);
        safe_area = opening_ex(safe_area, scale_(FILTER_THRESHOLD));
 
        Point starting_pos = get_objects_center(object_list);
 
        m_all_layer_pos = pick_pos_internal(starting_pos, safe_area, {}, by_object);
        return *m_all_layer_pos;
    }

References Slic3r::ByObject, collect_limit_areas_for_camera(), Slic3r::PosPickCtx::curr_extruder_id, Slic3r::PosPickCtx::curr_layer, Slic3r::DefaultTimelapsePos, Slic3r::diff_ex(), expand_object_projection(), FILTER_THRESHOLD, get_object_list(), get_objects_center(), get_real_instance_bbox(), Slic3r::intersection_ex(), m_all_layer_pos, m_extruder_height_gap, m_extruder_printable_area, m_liftable_extruder_id, m_print_seq, Slic3r::opening_ex(), Slic3r::pick_pos_internal(), Slic3r::PosPickCtx::picture_extruder_id, Slic3r::Layer::print_z, scale_, and Slic3r::union_().

Referenced by pick_pos().

Here is the call graph for this function:

Here is the caller graph for this function:

pick_pos_for_curr_layer()

Point Slic3r::TimelapsePosPicker::pick_pos_for_curr_layer ( const PosPickCtx & ctx )

private

    {
        float height_gap = 0;
        if (ctx.curr_extruder_id != ctx.picture_extruder_id) {
            if (m_liftable_extruder_id.has_value() && ctx.picture_extruder_id != m_liftable_extruder_id && m_extruder_height_gap.has_value())
                height_gap = -*m_extruder_height_gap;
        }
 
        bool by_object = m_print_seq == PrintSequence::ByObject;
        std::vector<const PrintObject*> object_list = get_object_list(ctx.printed_objects);
 
        ExPolygons layer_slices = collect_object_slices_data(ctx.curr_layer, height_gap, object_list, by_object);
        Polygons camera_limit_areas = collect_limit_areas_for_camera(object_list);
        Polygons rod_limit_areas;
        if (by_object) {
            rod_limit_areas = collect_limit_areas_for_rod(object_list, ctx);
        }
        ExPolygons unplacable_area = union_ex(union_ex(layer_slices, camera_limit_areas), rod_limit_areas);
        ExPolygons extruder_printable_area = m_extruder_printable_area[ctx.picture_extruder_id];
 
        ExPolygons safe_area = diff_ex(extruder_printable_area, unplacable_area);
        safe_area = opening_ex(safe_area, scale_(FILTER_THRESHOLD));
 
        Point center_p;
        if (by_object && ctx.printed_objects && !ctx.printed_objects->empty())
            center_p = get_object_center(ctx.printed_objects->back());
        else
            center_p = get_objects_center(object_list);
 
        ExPolygons path_collision_area;
        if (by_object) {
            auto object_without_curr = ctx.printed_objects;
            if (object_without_curr && !object_without_curr->empty())
                object_without_curr->pop_back();
 
            ExPolygons layer_slices_without_curr = collect_object_slices_data(ctx.curr_layer, height_gap, get_object_list(object_without_curr), by_object);
            path_collision_area = union_ex(layer_slices_without_curr, rod_limit_areas);
        }
 
        return pick_pos_internal(center_p, safe_area,path_collision_area, by_object, ctx.farthest_point);
    }

References Slic3r::ByObject, collect_limit_areas_for_camera(), collect_limit_areas_for_rod(), collect_object_slices_data(), Slic3r::PosPickCtx::curr_extruder_id, Slic3r::PosPickCtx::curr_layer, Slic3r::diff_ex(), Slic3r::PosPickCtx::farthest_point, FILTER_THRESHOLD, get_object_center(), get_object_list(), get_objects_center(), m_extruder_height_gap, m_extruder_printable_area, m_liftable_extruder_id, m_print_seq, Slic3r::opening_ex(), Slic3r::pick_pos_internal(), Slic3r::PosPickCtx::picture_extruder_id, Slic3r::PosPickCtx::printed_objects, scale_, and Slic3r::union_ex().

Referenced by pick_pos().

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

void Slic3r::TimelapsePosPicker::reset

(

)

    {
        print = nullptr;
        m_bed_polygon.clear();
        m_extruder_printable_area.clear();
        m_all_layer_pos = std::nullopt;
        bbox_cache.clear();
 
        m_print_seq = PrintSequence::ByObject;
        m_nozzle_height_to_rod = 0;
        m_nozzle_clearance_radius = 0;
        m_liftable_extruder_id = std::nullopt;
        m_extruder_height_gap = std::nullopt;
        m_based_on_all_layer = false;
    }

References bbox_cache, Slic3r::ByObject, m_all_layer_pos, m_based_on_all_layer, m_bed_polygon, m_extruder_height_gap, m_extruder_printable_area, m_liftable_extruder_id, m_nozzle_clearance_radius, m_nozzle_height_to_rod, m_print_seq, and print.

Referenced by init().

Here is the caller graph for this function:

Member Data Documentation

bbox_cache

std::unordered_map<const PrintInstance*, BoundingBoxf3> Slic3r::TimelapsePosPicker::bbox_cache

private

Referenced by get_real_instance_bbox(), and reset().

m_all_layer_pos

std::optional<Point> Slic3r::TimelapsePosPicker::m_all_layer_pos

private

Referenced by pick_pos_for_all_layer(), and reset().

m_based_on_all_layer

bool Slic3r::TimelapsePosPicker::m_based_on_all_layer

private

Referenced by init(), pick_pos(), and reset().

m_bed_polygon

Polygon Slic3r::TimelapsePosPicker::m_bed_polygon

private

Referenced by collect_limit_areas_for_rod(), collect_object_slices_data(), construct_printable_area_by_printer(), and reset().

m_extruder_height_gap

std::optional<int> Slic3r::TimelapsePosPicker::m_extruder_height_gap

private

Referenced by init(), pick_pos_for_all_layer(), pick_pos_for_curr_layer(), and reset().

m_extruder_printable_area

std::vector<ExPolygons> Slic3r::TimelapsePosPicker::m_extruder_printable_area

private

Referenced by construct_printable_area_by_printer(), pick_pos_for_all_layer(), pick_pos_for_curr_layer(), and reset().

m_liftable_extruder_id

std::optional<int> Slic3r::TimelapsePosPicker::m_liftable_extruder_id

private

Referenced by init(), pick_pos_for_all_layer(), pick_pos_for_curr_layer(), and reset().

m_nozzle_clearance_radius

int Slic3r::TimelapsePosPicker::m_nozzle_clearance_radius

private

Referenced by get_limit_area_for_camera(), init(), and reset().

m_nozzle_height_to_rod

int Slic3r::TimelapsePosPicker::m_nozzle_height_to_rod

private

Referenced by collect_limit_areas_for_rod(), init(), and reset().

m_plate_height

int Slic3r::TimelapsePosPicker::m_plate_height

private

Referenced by collect_limit_areas_for_rod(), and construct_printable_area_by_printer().

m_plate_offset

Point Slic3r::TimelapsePosPicker::m_plate_offset

private

Referenced by collect_limit_areas_for_rod(), get_is_clear_to_x0(), get_real_instance_bbox(), and init().

m_plate_width

int Slic3r::TimelapsePosPicker::m_plate_width

private

Referenced by collect_limit_areas_for_rod(), and construct_printable_area_by_printer().

m_print_seq

PrintSequence Slic3r::TimelapsePosPicker::m_print_seq

private

Referenced by collect_limit_areas_for_rod(), construct_printable_area_by_printer(), get_is_clear_to_x0(), init(), pick_pos_for_all_layer(), pick_pos_for_curr_layer(), and reset().

print

const Print* Slic3r::TimelapsePosPicker::print { nullptr }

private

{ nullptr };

Referenced by ~TimelapsePosPicker(), construct_printable_area_by_printer(), expand_object_bbox(), expand_object_projection(), get_object_list(), get_raft_height(), init(), and reset().

---

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

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