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

Inheritance diagram for Slic3r::GUI::ArrangeJob:

Collaboration diagram for Slic3r::GUI::ArrangeJob:

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

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

Protected Member Functions
void	check_unprintable ()

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

Private Member Functions
void	clear_input ()
void	prepare_selected ()
void	prepare_all ()
void	prepare_partplate ()
void	prepare_wipe_tower ()
void	prepare_belt_regions (int num_plates)
void	prepare_imex_zones ()
ArrangePolygon	prepare_arrange_polygon (void instance, const PartPlate mapping_plate=nullptr)

Private Attributes
ArrangePolygons	m_selected
ArrangePolygons	m_unselected
ArrangePolygons	m_unprintable
ArrangePolygons	m_locked
std::vector< ModelInstance * >	m_unarranged
std::map< int, ArrangePolygons >	m_selected_groups
std::vector< int >	m_uncompatible_plates
ImexArrangeInput	m_imex
arrangement::ArrangeParams	params
int	current_plate_index = 0
Polygon	bed_poly
Plater *	m_plater
bool	only_on_partplate {false}

Detailed Description

Member Typedef Documentation

◆ ArrangePolygon

using Slic3r::GUI::ArrangeJob::ArrangePolygon = arrangement::ArrangePolygon

private

◆ ArrangePolygons

using Slic3r::GUI::ArrangeJob::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

◆ ArrangeJob()

Slic3r::GUI::ArrangeJob::ArrangeJob ( )

807: m_plater{wxGetApp().plater()} { }

Slic3r::GUI::ArrangeJob::m_plater

Plater * m_plater

Definition ArrangeJob.hpp:61

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

Here is the call graph for this function:

Member Function Documentation

◆ check_unprintable()

void Slic3r::GUI::ArrangeJob::check_unprintable ( )

protected

{
    for (auto it = m_selected.begin(); it != m_selected.end();) {
        if (it->poly.area() < 0.001 || it->height>params.printable_height)
        {
#if SAVE_ARRANGE_POLY
            SVG svg(data_dir() + "/SVG/arrange_unprintable_"+it->name+".svg", get_extents(it->poly));
            if (svg.is_opened())
                svg.draw_outline(it->poly);
#endif
            if (it->poly.area() < 0.001) {
                auto msg = (boost::format(
                    _u8L("Object %s has zero size and can't be arranged."))
                    % it->name).str();
                m_plater->get_notification_manager()->push_notification(NotificationType::BBLPlateInfo,
                    NotificationManager::NotificationLevel::WarningNotificationLevel, msg);
            }
            m_unprintable.push_back(*it);
            it = m_selected.erase(it);
        }
        else
            it++;
    }
}

References _u8L, Slic3r::GUI::BBLPlateInfo, Slic3r::data_dir(), Slic3r::SVG::draw_outline(), Slic3r::get_extents(), Slic3r::SVG::is_opened(), m_plater, m_selected, m_unprintable, params, and Slic3r::GUI::NotificationManager::WarningNotificationLevel.

Referenced by prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_input()

void Slic3r::GUI::ArrangeJob::clear_input ( )

private

{
    const Model &model = m_plater->model();
 
    size_t count = 0, cunprint = 0; // To know how much space to reserve
    for (auto obj : model.objects)
        for (auto mi : obj->instances)
            mi->printable ? count++ : cunprint++;
 
    params.nonprefered_regions.clear();
    m_selected.clear();
    m_unselected.clear();
    m_unprintable.clear();
    m_locked.clear();
    m_unarranged.clear();
    m_uncompatible_plates.clear();
    m_selected.reserve(count + 1 /* for optional wti */);
    m_unselected.reserve(count + 1 /* for optional wti */);
    m_unprintable.reserve(cunprint /* for optional wti */);
    m_locked.reserve(count + 1 /* for optional wti */);
    current_plate_index = 0;
}

References count, current_plate_index, m_locked, m_plater, m_selected, m_unarranged, m_uncompatible_plates, m_unprintable, m_unselected, Slic3r::Model::objects, and params.

Referenced by prepare_all(), prepare_partplate(), and prepare_selected().

Here is the caller graph for this function:

◆ finalize()

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

overridevirtual

Reimplemented from Slic3r::GUI::Job.

                                                               {
    try {
        if (eptr)
            std::rethrow_exception(eptr);
    } catch (libnest2d::GeometryException &) {
        show_error(m_plater, _(L("Arrange failed. "
                                 "Found some exceptions when processing object geometries.")));
        eptr = nullptr;
    } catch (...) {
        eptr = std::current_exception();
    }
 
    if (canceled || eptr)
        return;
 
    // Nothing could be placed: leave the plates and the instances exactly as they were.
    // Rebuilding the plates would only re-home the instances by their bounds, which moves
    // a too large item to whichever plate it happens to reach over.
    const bool nothing_arranged = !m_selected.empty() &&
        std::all_of(m_selected.begin(), m_selected.end(), [](const ArrangePolygon &ap) { return !ap.is_arranged(); });
    if (nothing_arranged) {
        m_plater->get_notification_manager()->close_notification_of_type(NotificationType::ArrangeOngoing);
        m_plater->m_arrange_running.store(false);
        return;
    }
 
    // Unprintable items go to the last virtual bed
    int beds = 0;
 
    //BBS: partplate
    PartPlateList& plate_list = m_plater->get_partplate_list();
    //clear all the relations before apply the arrangement results
    if (only_on_partplate) {
        plate_list.clear(false, false, true, current_plate_index);
    }
    else
        plate_list.clear(false, false, true, -1);
    //BBS: adjust the bed_index, create new plates, get the max bed_index
    for (ArrangePolygon& ap : m_selected) {
        //if (ap.bed_idx < 0) continue;  // bed_idx<0 means unarrangable
        //BBS: partplate postprocess
        if (only_on_partplate)
            plate_list.postprocess_bed_index_for_current_plate(ap);
        else
            plate_list.postprocess_bed_index_for_selected(ap);
 
        beds = std::max(ap.bed_idx, beds);
 
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": arrange selected %4%: bed_id %1%, trans {%2%,%3%}") % ap.bed_idx % unscale<double>(ap.translation(X)) % unscale<double>(ap.translation(Y)) % ap.name;
    }
 
    //BBS: adjust the bed_index, create new plates, get the max bed_index
    for (ArrangePolygon& ap : m_unselected)
    {
        if (ap.is_virt_object)
            continue;
 
        //BBS: partplate postprocess
        if (!only_on_partplate)
            plate_list.postprocess_bed_index_for_unselected(ap);
 
        beds = std::max(ap.bed_idx, beds);
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":arrange unselected %4%: bed_id %1%, trans {%2%,%3%}") % ap.bed_idx % unscale<double>(ap.translation(X)) % unscale<double>(ap.translation(Y)) % ap.name;
    }
 
    for (ArrangePolygon& ap : m_locked) {
        beds = std::max(ap.bed_idx, beds);
 
        plate_list.postprocess_arrange_polygon(ap, false);
 
        ap.apply();
    }
 
    // Apply the arrange result to all selected objects
    for (ArrangePolygon& ap : m_selected) {
        //BBS: partplate postprocess
        plate_list.postprocess_arrange_polygon(ap, true);
 
        ap.apply();
    }
 
    // Apply the arrange result to unselected objects(due to the sukodu-style column changes, the position of unselected may also be modified)
    for (ArrangePolygon& ap : m_unselected)
    {
        if (ap.is_virt_object)
            continue;
 
        //BBS: partplate postprocess
        plate_list.postprocess_arrange_polygon(ap, false);
 
        ap.apply();
    }
 
    // Move the unprintable items to the last virtual bed.
    // Note ap.apply() moves relatively according to bed_idx, so we need to subtract the orignal bed_idx
    for (ArrangePolygon& ap : m_unprintable) {
        ap.bed_idx = beds + 1;
        plate_list.postprocess_arrange_polygon(ap, true);
 
        ap.apply();
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":arrange m_unprintable: name: %4%, bed_id %1%, trans {%2%,%3%}") % ap.bed_idx % unscale<double>(ap.translation(X)) % unscale<double>(ap.translation(Y)) % ap.name;
    }
 
    {
        Slic3r::LifecycleEventContext ctx;
        ctx.code = Slic3r::LifecycleEvtCode::Ok;
        ctx.msg = "arranged";
        Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ObjectTransformed, ctx);
    }
 
    m_plater->update();
    // BBS
    //wxGetApp().obj_manipul()->set_dirty();
 
    if (!m_unarranged.empty()) {
        std::set<std::string> names;
        for (ModelInstance *mi : m_unarranged)
            names.insert(mi->get_object()->name);
 
        m_plater->get_notification_manager()->push_notification(GUI::format(
            _L("Arrangement ignored the following objects which can't fit into a single bed:\n%s"),
            concat_strings(names, "\n")));
    }
    m_plater->get_notification_manager()->close_notification_of_type(NotificationType::ArrangeOngoing);
 
    //BBS: reload all objects due to arrange. Plates are never recycled here: arranging
    // must not remove a plate the user created, even when the arrange left it empty.
    if (only_on_partplate) {
        plate_list.rebuild_plates_after_arrangement(false, true, current_plate_index);
    }
    else {
        plate_list.rebuild_plates_after_arrangement(false, true);
    }
 
    // unlock the plates we just locked
    for (int i : m_uncompatible_plates)
        plate_list.get_plate(i)->lock(false);
 
    // BBS: update slice context and gcode result.
    m_plater->update_slicing_context_to_current_partplate();
 
    wxGetApp().obj_list()->reload_all_plates();
 
    m_plater->update();
 
    m_plater->m_arrange_running.store(false);
}

References _, _L, Slic3r::arrangement::ArrangePolygon::apply(), Slic3r::GUI::ArrangeOngoing, Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::GUI::PartPlateList::clear(), Slic3r::LifecycleEventContext::code, Slic3r::GUI::concat_strings(), current_plate_index, Slic3r::fire_lifecycle_event(), Slic3r::GUI::format(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::arrangement::ArrangePolygon::is_virt_object, L, Slic3r::GUI::PartPlate::lock(), m_locked, m_plater, m_selected, m_unarranged, m_uncompatible_plates, m_unprintable, m_unselected, Slic3r::LifecycleEventContext::msg, Slic3r::arrangement::ArrangePolygon::name, Slic3r::ObjectTransformed, Slic3r::Ok, only_on_partplate, Slic3r::GUI::PartPlateList::postprocess_arrange_polygon(), Slic3r::GUI::PartPlateList::postprocess_bed_index_for_current_plate(), Slic3r::GUI::PartPlateList::postprocess_bed_index_for_selected(), Slic3r::GUI::PartPlateList::postprocess_bed_index_for_unselected(), Slic3r::GUI::PartPlateList::rebuild_plates_after_arrangement(), Slic3r::GUI::show_error(), Slic3r::arrangement::ArrangePolygon::translation, Slic3r::unscale(), Slic3r::X, and Slic3r::Y.

Here is the call graph for this function:

◆ prepare()

void Slic3r::GUI::ArrangeJob::prepare ( )

{
    m_plater->get_notification_manager()->push_notification(NotificationType::ArrangeOngoing,
        NotificationManager::NotificationLevel::RegularNotificationLevel, _u8L("Arranging..."));
    m_plater->get_notification_manager()->bbl_close_plateinfo_notification();
 
    params = init_arrange_params(m_plater);
 
    //BBS update extruder params and speed table before arranging
    const Slic3r::DynamicPrintConfig& config = wxGetApp().preset_bundle->full_config();
    auto& print = wxGetApp().plater()->get_partplate_list().get_current_fff_print();
    auto print_config = print.config();
    int numExtruders = wxGetApp().preset_bundle->filament_presets.size();
 
    Model::setExtruderParams(config, numExtruders);
    Model::setPrintSpeedTable(config, print_config);
 
    int state = m_plater->get_prepare_state();
    if (state == Job::JobPrepareState::PREPARE_STATE_DEFAULT) {
        only_on_partplate = false;
        prepare_all();
    }
    else if (state == Job::JobPrepareState::PREPARE_STATE_MENU) {
        only_on_partplate = true;   // only arrange items on current plate
        prepare_partplate();
    }
 
    // After prepare_all(), which locks the plates it must leave alone.
    prepare_imex_zones();
 
 
#if SAVE_ARRANGE_POLY
    if (1)
    { // subtract excluded region and get a polygon bed
        auto& print = wxGetApp().plater()->get_partplate_list().get_current_fff_print();
        auto print_config = print.config();
        bed_poly.points = get_bed_shape(*m_plater->config());
        Polygons exclude_polys = get_bed_excluded_area(print_config);
        bed_poly = diff({ bed_poly }, exclude_polys)[0];
    }
 
    BoundingBox bbox = bed_poly.bounding_box();
    Point center = bbox.center();
    auto polys_to_draw = m_selected;
    for (auto it = polys_to_draw.begin(); it != polys_to_draw.end(); it++) {
        it->poly.translate(center);
        bbox.merge(it->poly);
    }
    SVG svg("SVG/arrange_poly.svg", bbox);
    if (svg.is_opened()) {
        svg.draw_outline(bed_poly);
        //svg.draw_grid(bbox, "gray", scale_(0.05));
        std::vector<std::string> color_array = { "red","black","yellow","gree","blue" };
        for (auto it = polys_to_draw.begin(); it != polys_to_draw.end(); it++) {
            std::string color = color_array[(it - polys_to_draw.begin()) % color_array.size()];
            svg.add_comment(it->name);
            svg.draw_text(get_extents(it->poly).min, it->name.c_str(), color.c_str());
            svg.draw_outline(it->poly, color);
        }
    }
#endif
 
    check_unprintable();
}

References _u8L, Slic3r::SVG::add_comment(), Slic3r::GUI::ArrangeOngoing, bed_poly, Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::center(), check_unprintable(), Slic3r::diff(), Slic3r::SVG::draw_outline(), Slic3r::SVG::draw_text(), Slic3r::get_bed_excluded_area(), Slic3r::get_bed_shape(), Slic3r::get_extents(), Slic3r::GUI::init_arrange_params(), Slic3r::SVG::is_opened(), m_plater, m_selected, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, only_on_partplate, params, prepare_all(), prepare_imex_zones(), prepare_partplate(), Slic3r::GUI::Job::PREPARE_STATE_DEFAULT, Slic3r::GUI::Job::PREPARE_STATE_MENU, Slic3r::GUI::NotificationManager::RegularNotificationLevel, Slic3r::Model::setExtruderParams(), Slic3r::Model::setPrintSpeedTable(), and Slic3r::DynamicConfig::size().

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepare_all()

void Slic3r::GUI::ArrangeJob::prepare_all ( )

private

                             {
    clear_input();
 
    PartPlateList& plate_list = m_plater->get_partplate_list();    
    for (size_t i = 0; i < plate_list.get_plate_count(); i++) {
        PartPlate* plate = plate_list.get_plate(i);
        bool same_as_global_print_seq = true;
        plate->get_real_print_seq(&same_as_global_print_seq);
        if (plate->is_locked() == false && !same_as_global_print_seq) {
            plate->lock(true);
            m_uncompatible_plates.push_back(i);
        }
    }
 
 
    Model &model = m_plater->model();
    bool selected_is_locked = false;
 
    // Go through the objects and check if inside the selection
    for (size_t oidx = 0; oidx < model.objects.size(); ++oidx) {
        ModelObject *mo = model.objects[oidx];
        if (is_belt_purge_prism(mo))
            continue;
 
        for (size_t i = 0; i < mo->instances.size(); ++i) {
            ModelInstance * mi = mo->instances[i];
            ArrangePolygon&& ap = prepare_arrange_polygon(mo->instances[i]);
            set_arrange_polygon_bed_exclusion_extruders_for_all_plates(
                ap, *mo, plate_list, wxGetApp().preset_bundle->full_config());
            //BBS: partplate_list preprocess
            //remove the locked plate's instances, neither in selected, nor in un-selected
            bool locked = plate_list.preprocess_arrange_polygon(oidx, i, ap, true);
            if (!locked)
            {
                ArrangePolygons& cont = mo->instances[i]->printable ? m_selected :m_unprintable;
 
                ap.itemid = cont.size();
                cont.emplace_back(std::move(ap));
            }
            else
            {
                //skip this object due to be locked in plate
                ap.itemid = m_locked.size();
                m_locked.emplace_back(std::move(ap));
                selected_is_locked = true;
                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": skip locked instance, obj_id %1%, instance_id %2%") % oidx % i;
            }
        }
    }
 
 
    // If the selection was empty arrange everything
    //if (m_selected.empty()) m_selected.swap(m_unselected);
    if (m_selected.empty()) {
        if (!selected_is_locked) {
            m_plater->get_notification_manager()->push_notification(NotificationType::BBLPlateInfo,
                NotificationManager::NotificationLevel::WarningNotificationLevel, into_u8(_L("No arrangeable objects are selected.")));
        }
        else {
            m_plater->get_notification_manager()->push_notification(NotificationType::BBLPlateInfo,
                NotificationManager::NotificationLevel::WarningNotificationLevel, into_u8(_L("All the selected objects are on a locked plate.\nCannot auto-arrange these objects.")));
        }
    }
 
    prepare_wipe_tower();
 
    const DynamicPrintConfig& current_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    bool   enable_wrapping = current_config.option<ConfigOptionBool>("enable_wrapping_detection")->value;
 
    // add the virtual object into unselect list if has
    plate_list.preprocess_exclude_areas(m_unselected, wxGetApp().preset_bundle->full_config(), enable_wrapping, MAX_NUM_PLATES);
    prepare_belt_regions(MAX_NUM_PLATES);
}

References _L, Slic3r::GUI::BBLPlateInfo, clear_input(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), Slic3r::GUI::PartPlate::get_real_print_seq(), Slic3r::ModelObject::instances, Slic3r::GUI::into_u8(), Slic3r::GUI::is_belt_purge_prism(), Slic3r::GUI::PartPlate::is_locked(), Slic3r::arrangement::ArrangePolygon::itemid, Slic3r::GUI::PartPlate::lock(), m_locked, m_plater, m_selected, m_uncompatible_plates, m_unprintable, m_unselected, Slic3r::Model::objects, Slic3r::ConfigBase::option(), prepare_arrange_polygon(), prepare_belt_regions(), prepare_wipe_tower(), Slic3r::GUI::PartPlateList::preprocess_arrange_polygon(), Slic3r::GUI::PartPlateList::preprocess_exclude_areas(), Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders_for_all_plates(), and Slic3r::GUI::NotificationManager::WarningNotificationLevel.

Referenced by prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepare_arrange_polygon()

ArrangePolygon Slic3r::GUI::ArrangeJob::prepare_arrange_polygon	(	void *	instance,
		const PartPlate *	mapping_plate = nullptr )

private

{
    ModelInstance* instance = (ModelInstance*)model_instance;
    const Slic3r::DynamicPrintConfig& config = wxGetApp().preset_bundle->full_config();
    ArrangePolygon polygon = get_instance_arrange_poly(instance, config);
    if (mapping_plate != nullptr)
        set_arrange_polygon_bed_exclusion_extruders(polygon, *instance->get_object(), *mapping_plate, config);
    return polygon;
}

References Slic3r::get_instance_arrange_poly(), Slic3r::ModelInstance::get_object(), and Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders().

Referenced by prepare_all(), prepare_partplate(), and prepare_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepare_belt_regions()

void Slic3r::GUI::ArrangeJob::prepare_belt_regions ( int num_plates )

private

{
    if (!params.is_belt || params.is_seq_print)
        return;
    const DynamicPrintConfig &config    = wxGetApp().preset_bundle->full_config();
    const BoundingBoxf        bed       = get_extents(config.opt<ConfigOptionPoints>("printable_area")->values);
    const bool                belt_is_y = params.belt_axis == 1;
    std::vector<BoundingBoxf> regions;
 
    std::set<int> filaments;
    for (const ArrangePolygons *items : { &m_selected, &m_unselected })
        for (const ArrangePolygon &ap : *items)
            if (!ap.is_virt_object)
                filaments.insert(ap.extrude_ids.begin(), ap.extrude_ids.end());
    if (config.opt_bool("enable_belt_purge_tower") && filaments.size() > 1) {
        // The prism is at least one millimetre per island plus the gaps between them.
        const int    islands = int(filaments.size()) - 1;
        const double width   = std::max(config.opt_float("belt_purge_tower_width"), 2. * islands - 1.) + 1.; // + the prism's edge inset
        BoundingBoxf strip   = bed;
        if (belt_is_y)
            strip.min.x() = std::max(bed.min.x(), bed.max.x() - width);
        else
            strip.min.y() = std::max(bed.min.y(), bed.max.y() - width);
        regions.push_back(strip);
    }
 
    // Virtual items are inflated by the one millimetre exclusion gap already.
    const double brim = config.opt_enum<BrimType>("brim_type") == btNoBrim ? 0. :
        config.opt_float("brim_width") + config.opt_float("brim_object_gap") + config.opt_float("extra_brim_width") - 1.;
    if (brim > 0.) {
        regions.emplace_back(bed.min, Vec2d(bed.min.x() + brim, bed.max.y()));
        regions.emplace_back(Vec2d(bed.max.x() - brim, bed.min.y()), bed.max);
        regions.emplace_back(bed.min, Vec2d(bed.max.x(), bed.min.y() + brim));
        regions.emplace_back(Vec2d(bed.min.x(), bed.max.y() - brim), bed.max);
    }
 
    for (int j = 0; j < num_plates; ++j)
        for (size_t i = 0; i < regions.size(); ++i) {
            ArrangePolygon ap;
            ap.poly.contour   = scaled(regions[i]).polygon();
            ap.translation    = Vec2crd(0, 0);
            ap.rotation       = 0.f;
            ap.is_virt_object = true;
            ap.bed_idx        = j;
            ap.height         = 1;
            ap.name           = "BeltRegion" + std::to_string(i);
            m_unselected.emplace_back(std::move(ap));
        }
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::btNoBrim, Slic3r::ExPolygon::contour, Slic3r::get_extents(), Slic3r::arrangement::ArrangePolygon::height, Slic3r::arrangement::ArrangePolygon::is_virt_object, m_selected, m_unselected, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::arrangement::ArrangePolygon::name, Slic3r::DynamicConfig::opt(), Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_enum(), Slic3r::DynamicConfig::opt_float(), params, Slic3r::arrangement::ArrangePolygon::poly, Slic3r::BoundingBox::polygon(), Slic3r::arrangement::ArrangePolygon::rotation, Slic3r::scaled(), Slic3r::arrangement::ArrangePolygon::translation, and Slic3r::ConfigOptionVector< T >::values.

Referenced by prepare_all(), prepare_partplate(), and prepare_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepare_imex_zones()

void Slic3r::GUI::ArrangeJob::prepare_imex_zones ( )

private

{
    m_imex = {};
    PartPlateList& plate_list = m_plater->get_partplate_list();
    std::vector<PartPlate*> plates;
    if (only_on_partplate)
        plates.push_back(plate_list.get_curr_plate());
    else
        for (int i = 0; i < plate_list.get_plate_count(); ++i)
            if (!plate_list.get_plate(i)->is_locked())
                plates.push_back(plate_list.get_plate(i));
 
    for (PartPlate* plate : plates) {
        std::optional<ImexArrangeZones> zones;
        if (const std::optional<BoundingBoxf> pz = plate ? plate->imex_primary_zone() : std::nullopt) {
            const Vec2d o = plate->get_origin().head<2>();
            zones = ImexArrangeZones{BoundingBoxf(Vec2d(pz->min - o), Vec2d(pz->max - o)), {}};
            for (const BoundingBoxf3& strip : plate->imex_collision_zones())
                zones->collision_zones.emplace_back(Vec2d(strip.min.head<2>() - o), Vec2d(strip.max.head<2>() - o));
        }
        m_imex.beds.push_back(std::move(zones));
    }
    m_imex.adds_plates = !only_on_partplate;
    m_imex.read_config(wxGetApp().preset_bundle->full_config());
}

References Slic3r::ImexArrangeZones::collision_zones, Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), Slic3r::GUI::PartPlate::is_locked(), m_imex, m_plater, and only_on_partplate.

Referenced by prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepare_partplate()

void Slic3r::GUI::ArrangeJob::prepare_partplate ( )

private

                                   {
    clear_input();
 
    PartPlateList& plate_list = m_plater->get_partplate_list();
    PartPlate* plate = plate_list.get_curr_plate();
    current_plate_index = plate_list.get_curr_plate_index();
    assert(plate != nullptr);
 
    if (plate->empty())
    {
        //no instances on this plate
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": no instances in current plate!");
 
        return;
    }
 
    if (plate->is_locked()) {
        m_plater->get_notification_manager()->push_notification(NotificationType::BBLPlateInfo,
            NotificationManager::NotificationLevel::WarningNotificationLevel, into_u8(_L("This plate is locked.\nCannot auto-arrange on this plate.")));
        return;
    }
 
    Model& model = m_plater->model();
 
    // Go through the objects and check if inside the selection
    for (size_t oidx = 0; oidx < model.objects.size(); ++oidx)
    {
        ModelObject* mo = model.objects[oidx];
        if (is_belt_purge_prism(mo))
            continue;
        for (size_t inst_idx = 0; inst_idx < mo->instances.size(); ++inst_idx)
        {
            bool             in_plate = plate->contain_instance(oidx, inst_idx) || plate->intersect_instance(oidx, inst_idx);
            ArrangePolygon&& ap = prepare_arrange_polygon(mo->instances[inst_idx], plate);
 
            ArrangePolygons& cont = mo->instances[inst_idx]->printable ?
                (in_plate ? m_selected : m_unselected) :
                m_unprintable;
            bool locked = plate_list.preprocess_arrange_polygon_other_locked(oidx, inst_idx, ap, in_plate);
            if (!locked)
            {
                ap.itemid = cont.size();
                cont.emplace_back(std::move(ap));
            }
            else
            {
                //skip this object due to be not in current plate, treated as locked
                ap.itemid = m_locked.size();
                m_locked.emplace_back(std::move(ap));
                //BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": skip locked instance, obj_id %1%, name %2%") % oidx % mo->name;
            }
        }
    }
 
    // BBS
    if (auto wti = get_wipe_tower(*m_plater, current_plate_index)) {
        ArrangePolygon&& ap = get_wipetower_arrange_poly(&wti);
        m_unselected.emplace_back(std::move(ap));
    }
 
    const DynamicPrintConfig &current_config  = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    bool   enable_wrapping = current_config.option<ConfigOptionBool>("enable_wrapping_detection")->value;
 
    // add the virtual object into unselect list if has
    plate_list.preprocess_exclude_areas(
        m_unselected, wxGetApp().preset_bundle->full_config(), enable_wrapping, current_plate_index + 1);
    prepare_belt_regions(current_plate_index + 1);
}

Referenced by prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepare_selected()

void Slic3r::GUI::ArrangeJob::prepare_selected ( )

private

                                  {
    PartPlateList& plate_list = m_plater->get_partplate_list();
 
    clear_input();
 
    Model& model = m_plater->model();
    bool selected_is_locked = false;
    //BBS: remove logic for unselected object
    //double stride = bed_stride_x(m_plater);
 
    std::vector<const Selection::InstanceIdxsList*>
        obj_sel(model.objects.size(), nullptr);
 
    for (auto& s : m_plater->get_selection().get_content())
        if (s.first < int(obj_sel.size()))
            obj_sel[size_t(s.first)] = &s.second;
 
    // Go through the objects and check if inside the selection
    for (size_t oidx = 0; oidx < model.objects.size(); ++oidx) {
        const Selection::InstanceIdxsList* instlist = obj_sel[oidx];
        ModelObject* mo = model.objects[oidx];
        if (is_belt_purge_prism(mo))
            continue;
 
        std::vector<bool> inst_sel(mo->instances.size(), false);
 
        if (instlist)
            for (auto inst_id : *instlist)
                inst_sel[size_t(inst_id)] = true;
 
        for (size_t i = 0; i < inst_sel.size(); ++i) {
            ModelInstance* mi = mo->instances[i];
            ArrangePolygon&& ap = prepare_arrange_polygon(mo->instances[i]);
            set_arrange_polygon_bed_exclusion_extruders_for_all_plates(
                ap, *mo, plate_list, wxGetApp().preset_bundle->full_config());
            //BBS: partplate_list preprocess
            //remove the locked plate's instances, neither in selected, nor in un-selected
            bool locked = plate_list.preprocess_arrange_polygon(oidx, i, ap, inst_sel[i]);
            if (!locked)
                {
                ArrangePolygons& cont = mo->instances[i]->printable ?
                    (inst_sel[i] ? m_selected :
                        m_unselected) :
                    m_unprintable;
 
                ap.itemid = cont.size();
                cont.emplace_back(std::move(ap));
                }
            else
                {
                //skip this object due to be locked in plate
                ap.itemid = m_locked.size();
                m_locked.emplace_back(std::move(ap));
                if (inst_sel[i])
                    selected_is_locked = true;
                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": skip locked instance, obj_id %1%, instance_id %2%, name %3%") % oidx % i % mo->name;
                }
            }
        }
 
 
    // If the selection was empty arrange everything
    //if (m_selected.empty()) m_selected.swap(m_unselected);
    if (m_selected.empty()) {
        if (!selected_is_locked)
            m_selected.swap(m_unselected);
        else {
            m_plater->get_notification_manager()->push_notification(NotificationType::BBLPlateInfo,
                NotificationManager::NotificationLevel::WarningNotificationLevel, into_u8(_L("All the selected objects are on a locked plate.\nCannot auto-arrange these objects.")));
            }
        }
 
    prepare_wipe_tower();
    prepare_belt_regions(MAX_NUM_PLATES);
 
 
    // 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
    //for (auto &p : m_unselected) p.translation(X) -= p.bed_idx * stride;
}

References _L, Slic3r::GUI::BBLPlateInfo, clear_input(), Slic3r::ModelObject::instances, Slic3r::GUI::into_u8(), Slic3r::GUI::is_belt_purge_prism(), Slic3r::arrangement::ArrangePolygon::itemid, m_locked, m_plater, m_selected, m_unprintable, m_unselected, Slic3r::ModelObject::name, Slic3r::Model::objects, prepare_arrange_polygon(), prepare_belt_regions(), prepare_wipe_tower(), Slic3r::GUI::PartPlateList::preprocess_arrange_polygon(), Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders_for_all_plates(), and Slic3r::GUI::NotificationManager::WarningNotificationLevel.

Here is the call graph for this function:

◆ prepare_wipe_tower()

void Slic3r::GUI::ArrangeJob::prepare_wipe_tower ( )

private

{
    bool need_wipe_tower = false;
 
    // if wipe tower is explicitly disabled, no need to estimate
    DynamicPrintConfig& current_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    auto                op = current_config.option("enable_prime_tower");
    bool enable_prime_tower = op && op->getBool();
    if (!enable_prime_tower || params.is_seq_print) return;
 
    // Belt printers have no classic wipe tower; purging goes into the belt purge
    // prism, whose strip prepare_belt_regions() reserves.
    if (params.is_belt)
        return;
 
    bool smooth_timelapse = false;
    auto sop = current_config.option("timelapse_type");
    if (sop) { smooth_timelapse = sop->getInt() == TimelapseType::tlSmooth; }
    if (smooth_timelapse) { need_wipe_tower = true; }
 
    // estimate if we need wipe tower for all plates:
    // need wipe tower if some object has multiple extruders (has paint-on colors or support material)
    for (const auto& item : m_selected) {
        std::set<int> obj_extruders;
        obj_extruders.insert(item.extrude_ids.begin(), item.extrude_ids.end());
        if (obj_extruders.size() > 1) {
            need_wipe_tower = true;
            BOOST_LOG_TRIVIAL(info) << "arrange: need wipe tower because object " << item.name << " has multiple extruders (has paint-on colors)";
            break;
        }
    }
 
    // if multile extruders have same bed temp, we need wipe tower
    // 允许不同材料落在相同盘，且所有选定对象中使用了多种热床温度相同的材料
    if (params.allow_multi_materials_on_same_plate) {
        std::map<int, std::set<int>> bedTemp2extruderIds;
        for (const auto& item : m_selected)
            for (auto id : item.extrude_ids) { bedTemp2extruderIds[item.bed_temp].insert(id); }
        for (const auto& be : bedTemp2extruderIds) {
            if (be.second.size() > 1) {
                need_wipe_tower = true;
                BOOST_LOG_TRIVIAL(info) << "arrange: need wipe tower because allow_multi_materials_on_same_plate=true and we have multiple extruders of same type";
                break;
            }
        }
    }
    BOOST_LOG_TRIVIAL(info) << "arrange: need_wipe_tower=" << need_wipe_tower;
 
 
    ArrangePolygon    wipe_tower_ap;
    wipe_tower_ap.name = "WipeTower";
    wipe_tower_ap.is_virt_object = true;
    wipe_tower_ap.is_wipe_tower = true;
    const GLCanvas3D* canvas3D = static_cast<const GLCanvas3D*>(m_plater->canvas3D());
 
    std::set<int> extruder_ids;
    PartPlateList& ppl = wxGetApp().plater()->get_partplate_list();
    int plate_count = ppl.get_plate_count();
    if (!only_on_partplate) {
        extruder_ids = ppl.get_extruders(true);
    }
 
    int bedid_unlocked = 0;
    for (int bedid = 0; bedid < MAX_NUM_PLATES; bedid++) {
        int plate_index_valid = std::min(bedid, plate_count - 1);
        PartPlate* pl = ppl.get_plate(plate_index_valid);
        if(bedid<plate_count && pl->is_locked())
            continue;
        if (auto wti = get_wipe_tower(*m_plater, bedid)) {
            // wipe tower is already there
            wipe_tower_ap = get_wipetower_arrange_poly(&wti);
            wipe_tower_ap.bed_idx = bedid_unlocked;
            m_unselected.emplace_back(wipe_tower_ap);
        }
        else if (need_wipe_tower) {
            if (only_on_partplate) {
                auto plate_extruders = pl->get_extruders(true);
                extruder_ids.clear();
                extruder_ids.insert(plate_extruders.begin(), plate_extruders.end());
            }
            wipe_tower_ap = estimate_wipe_tower_info(bedid, extruder_ids);
            wipe_tower_ap.bed_idx = bedid_unlocked;
            m_unselected.emplace_back(wipe_tower_ap);
        }
        bedid_unlocked++;
    }
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::GUI::estimate_wipe_tower_info(), Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::PartPlateList::get_extruders(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), Slic3r::GUI::get_wipe_tower(), Slic3r::GUI::get_wipetower_arrange_poly(), Slic3r::ConfigOption::getBool(), Slic3r::arrangement::ArrangePolygon::is_virt_object, Slic3r::arrangement::ArrangePolygon::is_wipe_tower, m_plater, m_selected, m_unselected, Slic3r::arrangement::ArrangePolygon::name, only_on_partplate, Slic3r::ConfigBase::option(), params, and Slic3r::tlSmooth.

Referenced by prepare_all(), and prepare_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process()

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

overridevirtual

Implements Slic3r::GUI::Job.

{
    static const auto arrangestr = _u8L("Arranging");
    ctl.update_status(0, arrangestr);
    ctl.call_on_main_thread([this]{ prepare(); }).wait();;
 
    auto & partplate_list = m_plater->get_partplate_list();
 
    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_arrange_params(params, m_plater->config(), m_selected);
    update_selected_items_inflation(m_selected, m_plater->config(), params);
    update_unselected_items_inflation(m_unselected, m_plater->config(), params);
    update_selected_items_axis_align(m_selected, m_plater->config(), params);
 
    Points      bedpts = get_shrink_bedpts(m_plater->config(),params);
 
    // Keep the parts on IDEX/IQEX plates in their primary zones; see ImexArranger.
    const ImexArranger imex(m_imex, params, bedpts);
    bedpts = imex.bed_shape();
    imex.add_keep_outs(m_unselected);
 
    bool   enable_wrapping = global_config.option<ConfigOptionBool>("enable_wrapping_detection")->value;
    partplate_list.preprocess_exclude_areas(params.excluded_regions, global_config, enable_wrapping, 1, scale_(1));
 
    BOOST_LOG_TRIVIAL(debug) << "arrange bedpts:" << bedpts[0].transpose() << ", " << bedpts[1].transpose() << ", " << bedpts[2].transpose() << ", " << bedpts[3].transpose();
 
    params.stopcondition = [&ctl]() { return ctl.was_canceled(); };
 
    params.progressind = [this, &ctl](unsigned num_finished, std::string str = "") {
        // TRN Progress status. %1% is the name of the object being arranged.
        ctl.update_status(num_finished * 100 / status_range(), GUI::format(_u8L("Arranging %1%"), str));
    };
 
    {
        BOOST_LOG_TRIVIAL(warning)<< "Arrange full params: "<< params.to_json();
        BOOST_LOG_TRIVIAL(info) << boost::format("arrange: items selected before arranging: %1%") % m_selected.size();
        for (auto selected : m_selected) {
            BOOST_LOG_TRIVIAL(debug) << selected.name << ", extruder: " << selected.extrude_ids.back() << ", bed: " << selected.bed_idx << ", filemant_type:" << selected.filament_temp_type
                << ", trans: " << selected.translation.transpose();
        }
        BOOST_LOG_TRIVIAL(debug) << "arrange: items unselected before arrange: " << m_unselected.size();
        for (auto item : m_unselected)
            BOOST_LOG_TRIVIAL(debug) << item.name << ", bed: " << item.bed_idx << ", trans: " << item.translation.transpose()
            <<", bbox:"<<get_extents(item.poly).min.transpose()<<","<<get_extents(item.poly).max.transpose();
    }
 
    const ArrangePolygons before = imex.active() ? m_selected : ArrangePolygons();
    arrangement::arrange(m_selected, m_unselected, bedpts, params);
    if (!ctl.was_canceled())
        imex.finish(m_selected, before, m_unselected, params);
 
    // sort by item id
    std::sort(m_selected.begin(), m_selected.end(), [](auto a, auto b) {return a.itemid < b.itemid; });
    {
        BOOST_LOG_TRIVIAL(info) << boost::format("arrange: items selected after arranging: %1%") % m_selected.size();
        for (auto selected : m_selected)
            BOOST_LOG_TRIVIAL(debug) << selected.name << ", extruder: " << selected.extrude_ids.back() << ", bed: " << selected.bed_idx
                                     << ", bed_temp: " << selected.first_bed_temp << ", print_temp: " << selected.print_temp
                                     << ", trans: " << unscale<double>(selected.translation(X)) << ","<< unscale<double>(selected.translation(Y));
        BOOST_LOG_TRIVIAL(debug) << "arrange: items unselected after arrange: "<< m_unselected.size();
        for (auto item : m_unselected)
            BOOST_LOG_TRIVIAL(debug) << item.name << ", bed: " << item.bed_idx << ", trans: " << item.translation.transpose();
    }
 
    // put unpackable items to m_unprintable so they goes outside
    bool we_have_unpackable_items = false;
    for (auto item : m_selected) {
        if (item.bed_idx < 0) {
            //BBS: already processed in m_selected
            //m_unprintable.push_back(std::move(item));
            we_have_unpackable_items = true;
        }
    }
 
    // finalize just here.
    ctl.update_status(100,
        ctl.was_canceled() ? _u8L("Arranging canceled.") :
        we_have_unpackable_items ? _u8L("Arranging complete, but some items were not able to be arranged. Reduce spacing and try again.") : _u8L("Arranging done."));
}

References _u8L, Slic3r::ImexArranger::active(), Slic3r::ImexArranger::add_keep_outs(), Slic3r::arrangement::arrange(), Slic3r::ImexArranger::bed_shape(), Slic3r::GUI::Job::Ctl::call_on_main_thread(), Slic3r::ImexArranger::finish(), Slic3r::GUI::format(), Slic3r::get_extents(), Slic3r::PresetBundle::is_bbl_vendor(), m_imex, m_plater, m_selected, m_unselected, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::DynamicConfig::opt_bool(), Slic3r::ConfigBase::option(), params, prepare(), scale_, status_range(), Slic3r::unscale(), Slic3r::GUI::Job::Ctl::update_status(), Slic3r::GUI::Job::Ctl::was_canceled(), Slic3r::X, and Slic3r::Y.

Here is the call graph for this function:

◆ status_range()

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

inline

    {
        // ensure finalize() is called after all operations in process() is finished.
        return int(m_selected.size() + m_unprintable.size() + 1);
    }

References m_selected, and m_unprintable.

Referenced by process().

Here is the caller graph for this function:

Member Data Documentation

◆ bed_poly

Polygon Slic3r::GUI::ArrangeJob::bed_poly

private

Referenced by prepare().

◆ current_plate_index

int Slic3r::GUI::ArrangeJob::current_plate_index = 0

private

Referenced by clear_input(), finalize(), and prepare_partplate().

◆ m_imex

ImexArrangeInput Slic3r::GUI::ArrangeJob::m_imex

private

Referenced by prepare_imex_zones(), and process().

◆ m_locked

ArrangePolygons Slic3r::GUI::ArrangeJob::m_locked

private

Referenced by clear_input(), finalize(), prepare_all(), prepare_partplate(), and prepare_selected().

◆ m_plater

Plater* Slic3r::GUI::ArrangeJob::m_plater

private

Referenced by ArrangeJob(), check_unprintable(), clear_input(), finalize(), prepare(), prepare_all(), prepare_imex_zones(), prepare_partplate(), prepare_selected(), prepare_wipe_tower(), and process().

◆ m_selected

ArrangePolygons Slic3r::GUI::ArrangeJob::m_selected

private

Referenced by check_unprintable(), clear_input(), finalize(), prepare(), prepare_all(), prepare_belt_regions(), prepare_partplate(), prepare_selected(), prepare_wipe_tower(), process(), and status_range().

◆ m_selected_groups

std::map<int, ArrangePolygons> Slic3r::GUI::ArrangeJob::m_selected_groups

private

◆ m_unarranged

std::vector<ModelInstance*> Slic3r::GUI::ArrangeJob::m_unarranged

private

Referenced by clear_input(), and finalize().

◆ m_uncompatible_plates

std::vector<int> Slic3r::GUI::ArrangeJob::m_uncompatible_plates

private

Referenced by clear_input(), finalize(), and prepare_all().

◆ m_unprintable

ArrangePolygons Slic3r::GUI::ArrangeJob::m_unprintable

private

Referenced by check_unprintable(), clear_input(), finalize(), prepare_all(), prepare_partplate(), prepare_selected(), and status_range().

◆ m_unselected

ArrangePolygons Slic3r::GUI::ArrangeJob::m_unselected

private

Referenced by clear_input(), finalize(), prepare_all(), prepare_belt_regions(), prepare_partplate(), prepare_selected(), prepare_wipe_tower(), and process().

◆ only_on_partplate

bool Slic3r::GUI::ArrangeJob::only_on_partplate {false}

private

64{false};

Referenced by finalize(), prepare(), prepare_imex_zones(), and prepare_wipe_tower().

◆ params

arrangement::ArrangeParams Slic3r::GUI::ArrangeJob::params

private

Referenced by check_unprintable(), clear_input(), prepare(), prepare_belt_regions(), prepare_wipe_tower(), and process().

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

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

	OrcaSlicer latest OrcaSlicer

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ArrangePolygon

◆ ArrangePolygons

Member Enumeration Documentation

◆ JobPrepareState

Constructor & Destructor Documentation

◆ ArrangeJob()

Member Function Documentation

◆ check_unprintable()

◆ clear_input()

◆ finalize()

◆ prepare()

◆ prepare_all()

◆ prepare_arrange_polygon()

◆ prepare_belt_regions()

◆ prepare_imex_zones()

◆ prepare_partplate()

◆ prepare_selected()

◆ prepare_wipe_tower()

◆ process()

◆ status_range()

Member Data Documentation

◆ bed_poly

◆ current_plate_index

◆ m_imex

◆ m_locked

◆ m_plater

◆ m_selected

◆ m_selected_groups

◆ m_unarranged

◆ m_uncompatible_plates

◆ m_unprintable

◆ m_unselected

◆ only_on_partplate

◆ params