Slic3r::GUI::FillBedJob Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/FillBedJob.hpp>

Inheritance diagram for Slic3r::GUI::FillBedJob:

Collaboration diagram for Slic3r::GUI::FillBedJob:

Public Types
enum	JobPrepareState { PREPARE_STATE_DEFAULT = 0 , PREPARE_STATE_MENU = 1 }

Public Member Functions
void	prepare ()
void	process (Ctl &ctl) override
	FillBedJob (bool instances=false)
int	status_range () const
void	finalize (bool canceled, std::exception_ptr &e) override

Private Types
using	ArrangePolygon = arrangement::ArrangePolygon
using	ArrangePolygons = arrangement::ArrangePolygons

Private Attributes
int	m_object_idx = -1
ArrangePolygons	m_selected
ArrangePolygons	m_unselected
ArrangePolygons	m_locked
Points	m_bedpts
arrangement::ArrangeParams	params
int	m_status_range = 0
Plater *	m_plater
bool	m_instances

Detailed Description

Member Typedef Documentation

ArrangePolygon

using Slic3r::GUI::FillBedJob::ArrangePolygon = arrangement::ArrangePolygon

private

ArrangePolygons

using Slic3r::GUI::FillBedJob::ArrangePolygons = arrangement::ArrangePolygons

private

Member Enumeration Documentation

JobPrepareState

enum Slic3r::GUI::Job::JobPrepareState

inherited

Enumerator
PREPARE_STATE_DEFAULT
PREPARE_STATE_MENU

                         {
        PREPARE_STATE_DEFAULT = 0,
        PREPARE_STATE_MENU = 1,
    };

Constructor & Destructor Documentation

FillBedJob()

Slic3r::GUI::FillBedJob::FillBedJob

(

bool

instances = false

)

: m_plater{wxGetApp().plater()}, m_instances{instances} {}

References m_instances, m_plater, and Slic3r::GUI::plater().

Here is the call graph for this function:

Member Function Documentation

finalize()

void Slic3r::GUI::FillBedJob::finalize ( bool canceled, std::exception_ptr & e )

overridevirtual

Reimplemented from Slic3r::GUI::Job.

{
    // Ignore the arrange result if aborted.
    if (canceled || eptr)
        return;
 
    if (m_object_idx == -1) return;
 
    ModelObject *model_object = m_plater->model().objects[m_object_idx];
    if (model_object->instances.empty()) return;
 
    //BBS: partplate
    PartPlateList& plate_list = m_plater->get_partplate_list();
    int plate_cols = plate_list.get_plate_cols();
    int cur_plate = plate_list.get_curr_plate_index();
 
    size_t inst_cnt = model_object->instances.size();
 
    int added_cnt = std::accumulate(m_selected.begin(), m_selected.end(), 0, [](int s, auto &ap) {
        return s + int(ap.priority == 0 && ap.bed_idx == 0);
    });
 
    int oldSize = m_plater->model().objects.size();
 
    if (added_cnt > 0) {
        //BBS: adjust the selected instances
        for (ArrangePolygon& ap : m_selected) {
            if (ap.bed_idx != 0) {
                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":skipped: bed_id %1%, trans {%2%,%3%}") % ap.bed_idx % unscale<double>(ap.translation(X)) % unscale<double>(ap.translation(Y));
                /*if (ap.itemid == -1)*/
                    continue;
                ap.bed_idx = plate_list.get_plate_count();
            }
            else
                ap.bed_idx = cur_plate;
 
            if (m_selected.size() <= 100) {
                ap.row = ap.bed_idx / plate_cols;
                ap.col = ap.bed_idx % plate_cols;
                ap.translation(X) += bed_stride_x(m_plater) * ap.col;
                ap.translation(Y) -= bed_stride_y(m_plater) * ap.row;
            }
 
            ap.apply();
 
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":selected: bed_id %1%, trans {%2%,%3%}") % ap.bed_idx % unscale<double>(ap.translation(X)) % unscale<double>(ap.translation(Y));
        }
 
        int   newSize = m_plater->model().objects.size();
        auto obj_list = m_plater->sidebar().obj_list();
        for (size_t i = oldSize; i < newSize; i++) {
            obj_list->add_object_to_list(i, true, true, false);
            obj_list->update_printable_state(i, 0);
        }
 
        if (m_instances && model_object->instances.size() > inst_cnt) {
            const size_t new_instance_count = model_object->instances.size() - inst_cnt;
            // Match the normal add-instance flow: update the scene before the
            // object tree starts referring to the newly created instances.
            m_plater->update();
            // A single-instance object has no instance children in the object
            // tree yet, so the first refresh must add the original as well.
            obj_list->increase_object_instances(
                m_object_idx, inst_cnt == 1 ? new_instance_count + 1 : new_instance_count);
        }
 
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << ": paste_objects_into_list";
 
        /*for (ArrangePolygon& ap : m_selected) {
            if (ap.bed_idx != arrangement::UNARRANGED && (ap.priority != 0 || ap.bed_idx == 0))
                ap.apply();
        }*/
 
        //model_object->ensure_on_bed();
        //BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << ": model_object->ensure_on_bed()";
 
        // FillBedJob has already computed and validated the final positions.
        // The instance tree is synchronized above, so rerunning the general
        // arranger here would only risk discarding a valid fill result.
        m_plater->update();
 
        {
            Slic3r::LifecycleEventContext ctx;
            ctx.code = Slic3r::LifecycleEvtCode::Ok;
            ctx.msg = "arranged";
            Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ObjectTransformed, ctx);
        }
    }
 
    m_plater->mark_plate_toolbar_image_dirty();
}

References Slic3r::GUI::bed_stride_x(), Slic3r::GUI::bed_stride_y(), Slic3r::LifecycleEventContext::code, Slic3r::fire_lifecycle_event(), Slic3r::GUI::PartPlateList::get_curr_plate_index(), Slic3r::GUI::PartPlateList::get_plate_cols(), Slic3r::GUI::PartPlateList::get_plate_count(), Slic3r::ModelObject::instances, m_instances, m_object_idx, m_plater, m_selected, Slic3r::LifecycleEventContext::msg, Slic3r::GUI::obj_list(), Slic3r::ObjectTransformed, Slic3r::Ok, Slic3r::unscale(), Slic3r::X, and Slic3r::Y.

Here is the call graph for this function:

prepare()

void Slic3r::GUI::FillBedJob::prepare

(

)

{
    PartPlateList& plate_list = m_plater->get_partplate_list();
 
    m_locked.clear();
    m_selected.clear();
    m_unselected.clear();
    m_bedpts.clear();
 
    params = init_arrange_params(m_plater);
 
    m_object_idx = m_plater->get_selected_object_idx();
    if (m_object_idx == -1)
        return;
 
    //select current plate at first
    int sel_id = m_plater->get_selection().get_instance_idx();
    sel_id = std::max(sel_id, 0);
 
    int sel_ret = plate_list.select_plate_by_obj(m_object_idx, sel_id);
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":select plate obj_id %1%, ins_id %2%, ret %3%}") % m_object_idx % sel_id % sel_ret;
 
    PartPlate* plate = plate_list.get_curr_plate();
    Model& model = m_plater->model();
    BoundingBox plate_bb = plate->get_bounding_box_crd();
    int plate_cols = plate_list.get_plate_cols();
    int cur_plate_index = plate->get_index();
 
    ModelObject *model_object = m_plater->model().objects[m_object_idx];
    if (model_object->instances.empty()) return;
 
    const Slic3r::DynamicPrintConfig& global_config = wxGetApp().preset_bundle->full_config();
    m_selected.reserve(model_object->instances.size());
    for (size_t oidx = 0; oidx < model.objects.size(); ++oidx)
    {
        ModelObject* mo = model.objects[oidx];
        for (size_t inst_idx = 0; inst_idx < mo->instances.size(); ++inst_idx)
        {
            bool selected = (oidx == m_object_idx);
 
            ArrangePolygon ap = get_instance_arrange_poly(mo->instances[inst_idx], global_config);
            set_arrange_polygon_bed_exclusion_extruders(ap, *mo, *plate, global_config);
            BoundingBox ap_bb = ap.transformed_poly().contour.bounding_box();
            ap.name = mo->name;
 
            if (selected)
            {
                if (mo->instances[inst_idx]->printable)
                {
                    ++ap.priority;
                    ap.itemid = m_selected.size();
                    m_selected.emplace_back(ap);
                }
                else
                {
                    if (plate_bb.contains(ap_bb))
                    {
                        ap.bed_idx = 0;
                        ap.itemid = m_unselected.size();
                        ap.row = cur_plate_index / plate_cols;
                        ap.col = cur_plate_index % plate_cols;
                        ap.translation(X) -= bed_stride_x(m_plater) * ap.col;
                        ap.translation(Y) += bed_stride_y(m_plater) * ap.row;
                        m_unselected.emplace_back(ap);
                    }
                    else
                    {
                        ap.bed_idx = PartPlateList::MAX_PLATES_COUNT;
                        ap.itemid = m_locked.size();
                        m_locked.emplace_back(ap);
                    }
                }
            }
            else
            {
                if (plate_bb.contains(ap_bb))
                {
                    ap.bed_idx = 0;
                    ap.itemid = m_unselected.size();
                    ap.row = cur_plate_index / plate_cols;
                    ap.col = cur_plate_index % plate_cols;
                    ap.translation(X) -= bed_stride_x(m_plater) * ap.col;
                    ap.translation(Y) += bed_stride_y(m_plater) * ap.row;
                    m_unselected.emplace_back(ap);
                }
                else
                {
                    ap.bed_idx = PartPlateList::MAX_PLATES_COUNT;
                    ap.itemid = m_locked.size();
                    m_locked.emplace_back(ap);
                }
            }
        }
    }
    /*
    for (ModelInstance *inst : model_object->instances)
        if (inst->printable) {
            ArrangePolygon ap = get_arrange_poly(inst);
            // Existing objects need to be included in the result. Only
            // the needed amount of object will be added, no more.
            ++ap.priority;
            m_selected.emplace_back(ap);
        }*/
 
    if (m_selected.empty()) return;
 
    bool enable_wrapping = global_config.option<ConfigOptionBool>("enable_wrapping_detection")->value;
    //add the virtual object into unselect list if has
    double scaled_exclusion_gap = scale_(1);
    plate_list.preprocess_exclude_areas(params.excluded_regions, global_config, enable_wrapping, 1, scaled_exclusion_gap);
    plate_list.preprocess_exclude_areas(m_unselected, global_config, enable_wrapping);
 
    m_bedpts = get_bed_shape(*m_plater->config());
 
    auto &objects = m_plater->model().objects;
    /*BoundingBox bedbb = get_extents(m_bedpts);
 
    for (size_t idx = 0; idx < objects.size(); ++idx)
        if (int(idx) != m_object_idx)
            for (ModelInstance *mi : objects[idx]->instances) {
                ArrangePolygon ap = get_arrange_poly(mi);
                auto ap_bb = ap.transformed_poly().contour.bounding_box();
 
                if (ap.bed_idx == 0 && !bedbb.contains(ap_bb))
                    ap.bed_idx = arrangement::UNARRANGED;
 
                m_unselected.emplace_back(ap);
            }*/
    if (auto wt = get_wipe_tower_arrangepoly(*m_plater))
        m_unselected.emplace_back(std::move(*wt));
 
    double sc = scaled<double>(1.) * scaled(1.);
 
    auto polys = offset_ex(m_selected.front().poly, params.min_obj_distance / 2);
    ExPolygon poly = polys.empty() ? m_selected.front().poly : polys.front();
    double poly_area = poly.area() / sc;
    const ArrangePolygon &fill_template = m_selected.front();
    double unsel_area = std::accumulate(m_unselected.begin(),
                                        m_unselected.end(), 0.,
                                        [cur_plate_index, &fill_template](double s, const auto &ap) {
                                            //BBS: m_unselected instance is in the same partplate
                                            const bool exclusion_applies = !ap.is_bed_exclusion ||
                                                bed_exclusion_applies(fill_template, ap);
                                            return s + (ap.bed_idx == cur_plate_index && exclusion_applies) * ap.poly.area();
                                            //return s + (ap.bed_idx == 0) * ap.poly.area();
                                        }) / sc;
 
    double fixed_area = unsel_area + m_selected.size() * poly_area;
    double bed_area   = Polygon{m_bedpts}.area() / sc;
 
    // This is the maximum number of items, the real number will always be close but less.
    int needed_items = (bed_area - fixed_area) / poly_area;
 
    //int sel_id = m_plater->get_selection().get_instance_idx();
    // if the selection is not a single instance, choose the first as template
    //sel_id = std::max(sel_id, 0);
    ModelInstance *mi = model_object->instances[sel_id];
    ArrangePolygon template_ap = get_instance_arrange_poly(mi, global_config);
    set_arrange_polygon_bed_exclusion_extruders(template_ap, *model_object, *plate, global_config);
 
    for (int i = 0; i < needed_items; ++i) {
        ArrangePolygon ap = template_ap;
        ap.poly = m_selected.front().poly;
        ap.bed_idx = PartPlateList::MAX_PLATES_COUNT;
        ap.itemid = -1;
        ap.setter = [this, mi](const ArrangePolygon &p) {
            ModelObject *mo = m_plater->model().objects[m_object_idx];
            if (m_instances) {
                ModelInstance *new_instance = mo->add_instance(*mi);
                new_instance->apply_arrange_result(p.translation.cast<double>(), p.rotation);
            } else {
                ModelObject* newObj = m_plater->model().add_object(*mo);
                newObj->name = mo->name +" "+ std::to_string(p.itemid);
                for (ModelInstance *new_instance : newObj->instances)
                    new_instance->apply_arrange_result(p.translation.cast<double>(), p.rotation);
            }
            //m_plater->sidebar().obj_list()->paste_objects_into_list({m_plater->model().objects.size()-1});
        };
        m_selected.emplace_back(ap);
    }
 
    m_status_range = m_selected.size();
 
    // The strides have to be removed from the fixed items. For the
    // arrangeable (selected) items bed_idx is ignored and the
    // translation is irrelevant.
    //BBS: remove logic for unselected object
    /*double stride = bed_stride(m_plater);
    for (auto &p : m_unselected)
        if (p.bed_idx > 0)
            p.translation(X) -= p.bed_idx * stride;*/
}

References Slic3r::ModelObject::add_instance(), Slic3r::ModelInstance::apply_arrange_result(), Slic3r::Polygon::area(), Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::GUI::bed_stride_x(), Slic3r::GUI::bed_stride_y(), Slic3r::MultiPoint::bounding_box(), Slic3r::arrangement::ArrangePolygon::col, Slic3r::BoundingBoxBase< PointType, APointsType >::contains(), Slic3r::ExPolygon::contour, Slic3r::get_bed_shape(), Slic3r::GUI::PartPlate::get_bounding_box_crd(), Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::GUI::PartPlate::get_index(), Slic3r::get_instance_arrange_poly(), Slic3r::GUI::PartPlateList::get_plate_cols(), Slic3r::GUI::get_wipe_tower_arrangepoly(), Slic3r::GUI::init_arrange_params(), Slic3r::ModelObject::instances, Slic3r::arrangement::ArrangePolygon::itemid, m_bedpts, m_instances, m_locked, m_object_idx, m_plater, m_selected, m_status_range, m_unselected, Slic3r::GUI::PartPlateList::MAX_PLATES_COUNT, Slic3r::arrangement::ArrangePolygon::name, Slic3r::ModelObject::name, Slic3r::Model::objects, Slic3r::offset_ex(), Slic3r::ConfigBase::option(), params, Slic3r::arrangement::ArrangePolygon::poly, Slic3r::GUI::PartPlateList::preprocess_exclude_areas(), Slic3r::arrangement::ArrangePolygon::priority, Slic3r::arrangement::ArrangePolygon::row, scale_, Slic3r::scaled(), Slic3r::GUI::PartPlateList::select_plate_by_obj(), Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders(), Slic3r::arrangement::ArrangePolygon::setter, Slic3r::arrangement::ArrangePolygon::transformed_poly(), Slic3r::arrangement::ArrangePolygon::translation, Slic3r::X, and Slic3r::Y.

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

process()

void Slic3r::GUI::FillBedJob::process ( Ctl & ctl )

overridevirtual

Implements Slic3r::GUI::Job.

{
    auto statustxt = _u8L("Filling");
    ctl.call_on_main_thread([this] { prepare(); }).wait();
    ctl.update_status(0, statustxt);
 
    if (m_object_idx == -1 || m_selected.empty()) return;
 
    update_arrange_params(params, m_plater->config(), m_selected);
 
    auto &partplate_list               = m_plater->get_partplate_list();
    auto &print                        = wxGetApp().plater()->get_partplate_list().get_current_fff_print();
    const Slic3r::DynamicPrintConfig& global_config = wxGetApp().preset_bundle->full_config();
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    const bool is_bbl = wxGetApp().preset_bundle->is_bbl_vendor();
    if (is_bbl && params.avoid_extrusion_cali_region && global_config.opt_bool("scan_first_layer"))
        partplate_list.preprocess_nonprefered_areas(m_unselected, MAX_NUM_PLATES);
 
    update_selected_items_inflation(m_selected, m_plater->config(), params);
    update_unselected_items_inflation(m_unselected, m_plater->config(), params);
    // After the inflation, which may give back part of the bed margin.
    m_bedpts = get_shrink_bedpts(m_plater->config(), params);
 
    bool do_stop = false;
    params.stopcondition = [&ctl, &do_stop]() {
        return ctl.was_canceled() || do_stop;
    };
 
    params.progressind = [this, &ctl](unsigned st,std::string str="") {
         if (st > 0)
             // TRN Progress status of Fill bed. %1% is the name of the object being copied.
             ctl.update_status(st * 100 / status_range(), GUI::format(_u8L("Filling %1%"), str));
    };
 
    params.on_packed = [&do_stop] (const ArrangePolygon &ap) {
        do_stop = ap.bed_idx > 0 && ap.priority == 0;
    };
    // final align用的是凸包，在有fixed item的情况下可能找到的参考点位置是错的，这里就不做了。见STUDIO-3265
    params.do_final_align = !is_bbl;
 
    if (m_selected.size() > 100) {
        // too many items, just find grid empty cells to put them
        std::vector<BoundingBoxf> occupied_boxes;
        for (const ArrangePolygon &fixed : m_unselected) {
            if (fixed.bed_idx != 0 || fixed.is_extrusion_cali_object)
                continue;
 
            if (fixed.is_bed_exclusion) {
                const bool relevant = std::any_of(
                    m_selected.begin(), m_selected.end(), [&fixed](const ArrangePolygon &item) {
                        return bed_exclusion_applies(item, fixed);
                    });
                if (!relevant)
                    continue;
            }
 
            BoundingBox bbox = get_extents(fixed.transformed_poly());
            bbox.offset(std::max<coord_t>(0, fixed.inflation));
            occupied_boxes.emplace_back(unscale(bbox.min), unscale(bbox.max));
        }
 
        // Fill the remaining space without disturbing instances which are
        // already placed. Besides matching the meaning of "Fill bed", this
        // also prevents candidates rejected by the grid from remaining under
        // newly placed copies at their old positions.
        const Vec3d plate_origin = partplate_list.get_curr_plate()->get_origin();
        for (const ArrangePolygon &existing : m_selected) {
            if (existing.priority == 0 || existing.bed_idx != 0)
                continue;
 
            BoundingBox bbox = get_extents(existing.transformed_poly());
            bbox.offset(std::max<coord_t>(0, existing.inflation));
            BoundingBoxf local_box(unscale(bbox.min), unscale(bbox.max));
            local_box.translate(Vec2d(-plate_origin.x(), -plate_origin.y()));
            occupied_boxes.emplace_back(std::move(local_box));
        }
 
        const Vec2f step = unscaled<float>(get_extents(m_selected.front().poly).size()) +
                           Vec2f(m_selected.front().brim_width, m_selected.front().brim_width);
        const bool has_conditional_exclusions = has_bed_exclusion_regions(m_unselected);
        const std::vector<Vec2f> empty_cells =
            Plater::get_empty_cells(step, occupied_boxes, !has_conditional_exclusions);
 
        size_t cell_index = 0;
        for (ArrangePolygon &item : m_selected) {
            if (item.priority != 0)
                continue;
 
            if (cell_index < empty_cells.size()) {
                item.translation = scaled<coord_t>(empty_cells[cell_index++]);
                item.bed_idx = 0;
            } else {
                item.bed_idx = arrangement::UNARRANGED;
            }
        }
 
    } else {
        arrangement::arrange(m_selected, m_unselected, m_bedpts, params);
    }
 
    // finalize just here.
    ctl.update_status(100, ctl.was_canceled() ?
                                       _u8L("Bed filling canceled.") :
                                       _u8L("Bed filling done."));
}

References _u8L, Slic3r::arrangement::arrange(), Slic3r::GUI::Job::Ctl::call_on_main_thread(), Slic3r::GUI::format(), Slic3r::GUI::Plater::get_empty_cells(), Slic3r::get_extents(), Slic3r::PresetBundle::is_bbl_vendor(), m_bedpts, m_object_idx, m_plater, m_selected, m_unselected, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::DynamicConfig::opt_bool(), params, prepare(), Slic3r::scaled(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), status_range(), Slic3r::BoundingBoxBase< PointType, APointsType >::translate(), Slic3r::arrangement::UNARRANGED, Slic3r::unscale(), Slic3r::unscaled(), Slic3r::GUI::Job::Ctl::update_status(), and Slic3r::GUI::Job::Ctl::was_canceled().

Here is the call graph for this function:

status_range()

int Slic3r::GUI::FillBedJob::status_range ( ) const

inline

    {
        return m_status_range;
    }

References m_status_range.

Referenced by process().

Here is the caller graph for this function:

Member Data Documentation

m_bedpts

Points Slic3r::GUI::FillBedJob::m_bedpts

private

Referenced by prepare(), and process().

m_instances

bool Slic3r::GUI::FillBedJob::m_instances

private

Referenced by FillBedJob(), finalize(), and prepare().

m_locked

ArrangePolygons Slic3r::GUI::FillBedJob::m_locked

private

Referenced by prepare().

m_object_idx

int Slic3r::GUI::FillBedJob::m_object_idx = -1

private

Referenced by finalize(), prepare(), and process().

m_plater

Plater* Slic3r::GUI::FillBedJob::m_plater

private

Referenced by FillBedJob(), finalize(), prepare(), and process().

m_selected

ArrangePolygons Slic3r::GUI::FillBedJob::m_selected

private

Referenced by finalize(), prepare(), and process().

m_status_range

int Slic3r::GUI::FillBedJob::m_status_range = 0

private

Referenced by prepare(), and status_range().

m_unselected

ArrangePolygons Slic3r::GUI::FillBedJob::m_unselected

private

Referenced by prepare(), and process().

params

arrangement::ArrangeParams Slic3r::GUI::FillBedJob::params

private

Referenced by prepare(), and process().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/FillBedJob.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/FillBedJob.cpp