Slic3r::GUI::OrientJob Class Reference

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

Inheritance diagram for Slic3r::GUI::OrientJob:

Collaboration diagram for Slic3r::GUI::OrientJob:

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

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

Static Public Member Functions
static orientation::OrientMesh	get_orient_mesh (ModelInstance *instance)

Private Types
using	OrientMesh = orientation::OrientMesh
using	OrientMeshs = orientation::OrientMeshs

Private Member Functions
void	clear_input ()
void	prepare_selection (std::vector< bool > obj_sel, bool only_one_plate)
void	prepare_selected ()
void	prepare_partplate ()

Private Attributes
OrientMeshs	m_selected
OrientMeshs	m_unselected
OrientMeshs	m_unprintable
Plater *	m_plater

Detailed Description

Member Typedef Documentation

OrientMesh

using Slic3r::GUI::OrientJob::OrientMesh = orientation::OrientMesh

private

OrientMeshs

using Slic3r::GUI::OrientJob::OrientMeshs = orientation::OrientMeshs

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

OrientJob()

Slic3r::GUI::OrientJob::OrientJob

(

)

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

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

Here is the call graph for this function:

Member Function Documentation

clear_input()

void Slic3r::GUI::OrientJob::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++;
 
    m_selected.clear();
    m_unselected.clear();
    m_unprintable.clear();
    m_selected.reserve(count);
    m_unselected.reserve(count);
    m_unprintable.reserve(cunprint);
}

References count, m_plater, m_selected, m_unprintable, m_unselected, and Slic3r::Model::objects.

Referenced by prepare_partplate(), and prepare_selected().

Here is the caller graph for this function:

finalize()

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

overridevirtual

Reimplemented from Slic3r::GUI::Job.

{
    try {
        if (eptr)
            std::rethrow_exception(eptr);
        eptr = nullptr;
    } catch (...) {
        eptr = std::current_exception();
    }
 
    // Ignore the arrange result if aborted.
    if (canceled || eptr)
        return;
 
    for (OrientMesh& mesh : m_selected)
    {
        mesh.apply();
    }
 
    if (!m_selected.empty()) {
        Slic3r::LifecycleEventContext ctx;
        ctx.code = Slic3r::LifecycleEvtCode::Ok;
        ctx.msg = "auto_oriented";
        Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ObjectTransformed, ctx);
    }
 
    m_plater->update();
 
    // BBS
    //wxGetApp().obj_manipul()->set_dirty();
}

References Slic3r::LifecycleEventContext::code, Slic3r::fire_lifecycle_event(), m_plater, m_selected, Slic3r::LifecycleEventContext::msg, Slic3r::ObjectTransformed, and Slic3r::Ok.

Here is the call graph for this function:

get_orient_mesh()

orientation::OrientMesh Slic3r::GUI::OrientJob::get_orient_mesh ( ModelInstance * instance )

static

{
    using OrientMesh = orientation::OrientMesh;
    OrientMesh om;
    auto obj = instance->get_object();
    om.name = obj->name;
    om.mesh = obj->mesh(); // don't know the difference to obj->raw_mesh(). Both seem OK
    const Slic3r::DynamicPrintConfig& config = wxGetApp().preset_bundle->full_config();
    if (obj->config.has("support_threshold_angle"))
        om.overhang_angle = obj->config.opt_int("support_threshold_angle");
    else {
        om.overhang_angle = config.opt_int("support_threshold_angle");
    }
 
    if (config.has("fan_direction") && config.has("auxiliary_fan")) {
        FanDirection config_dir = config.option<ConfigOptionEnum<FanDirection>>("fan_direction")->value;
        if (config_dir == FanDirection::fdUndefine || !config.opt_bool("auxiliary_fan")) {
            // no part cooling airflow to face, keep the orientation around the z axis unchanged
            om.cooling_direction = {0, 0, 0};
        } else if (config_dir == FanDirection::fdRight) {
            // the part cooling airflow comes from the right side
            om.cooling_direction = {1, 0, 0};
            om.has_cooling_fan = true;
        } else {
            // the part cooling airflow comes from the left side, or from both sides
            om.cooling_direction = {-1, 0, 0};
            om.has_cooling_fan = true;
        }
    }
 
    om.setter = [instance](const OrientMesh& p) {
        instance->rotate(p.rotation_matrix);
        instance->rotate(p.rotation_matrix_vertical);
        instance->get_object()->invalidate_bounding_box();
        instance->get_object()->ensure_on_bed();
    };
    return om;
}

References Slic3r::orientation::OrientMesh::cooling_direction, Slic3r::ModelObject::ensure_on_bed(), Slic3r::fdRight, Slic3r::fdUndefine, Slic3r::ModelInstance::get_object(), Slic3r::ConfigOptionResolver::has(), Slic3r::orientation::OrientMesh::has_cooling_fan, Slic3r::ModelObject::invalidate_bounding_box(), Slic3r::orientation::OrientMesh::mesh, Slic3r::orientation::OrientMesh::name, Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_int(), Slic3r::ConfigBase::option(), Slic3r::orientation::OrientMesh::overhang_angle, Slic3r::ModelInstance::rotate(), and Slic3r::orientation::OrientMesh::setter.

Referenced by prepare_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare()

void Slic3r::GUI::OrientJob::prepare

(

)

{
    int state = m_plater->get_prepare_state();
    m_plater->get_notification_manager()->bbl_close_plateinfo_notification();
    if (state == Job::JobPrepareState::PREPARE_STATE_DEFAULT) {
        // only_on_partplate = false;
        prepare_selected();
    }
    else if (state == Job::JobPrepareState::PREPARE_STATE_MENU) {
        // only_on_partplate = true;   // only arrange items on current plate
        prepare_partplate();
    }
}

References m_plater, prepare_partplate(), prepare_selected(), Slic3r::GUI::Job::PREPARE_STATE_DEFAULT, and Slic3r::GUI::Job::PREPARE_STATE_MENU.

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_partplate()

void Slic3r::GUI::OrientJob::prepare_partplate ( )

private

                                  {
    clear_input();
 
    PartPlateList& plate_list = m_plater->get_partplate_list();
    PartPlate* plate = plate_list.get_curr_plate();
    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-orient on this plate.")));
        return;
    }
 
    Model& model = m_plater->model();
 
    std::vector<bool> obj_sel(model.objects.size(), 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];
        for (size_t inst_idx = 0; inst_idx < mo->instances.size(); ++inst_idx)
        {
            obj_sel[oidx] = plate->contain_instance(oidx, inst_idx);
        }
    }
 
    prepare_selection(obj_sel, true);
}

References _L, Slic3r::GUI::BBLPlateInfo, clear_input(), Slic3r::GUI::PartPlate::contain_instance(), Slic3r::GUI::PartPlate::empty(), Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::ModelObject::instances, Slic3r::GUI::into_u8(), Slic3r::GUI::PartPlate::is_locked(), m_plater, Slic3r::Model::objects, prepare_selection(), 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_selected()

void Slic3r::GUI::OrientJob::prepare_selected ( )

private

                                 {
    clear_input();
 
    Model &model = m_plater->model();
 
    std::vector<bool> obj_sel(model.objects.size(), false);
 
    for (auto &s : m_plater->get_selection().get_content())
        if (s.first < int(obj_sel.size()))
            obj_sel[size_t(s.first)] = !s.second.empty();
 
   //BBS: add only one plate mode
    prepare_selection(obj_sel, false);
}

References clear_input(), m_plater, Slic3r::Model::objects, and prepare_selection().

Referenced by prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_selection()

void Slic3r::GUI::OrientJob::prepare_selection ( std::vector< bool > obj_sel, bool only_one_plate )

private

{
    Model& model = m_plater->model();
    PartPlateList& plate_list = m_plater->get_partplate_list();
    //OrientMeshs selected_in_lock, unselect_in_lock;
    bool selected_is_locked = false;
 
    // Go through the objects and check if inside the selection
    for (size_t oidx = 0; oidx < obj_sel.size(); ++oidx) {
        bool selected = obj_sel[oidx];
        ModelObject* mo = model.objects[oidx];
 
        for (size_t inst_idx = 0; inst_idx < mo->instances.size(); ++inst_idx)
        {
            ModelInstance* mi = mo->instances[inst_idx];
            OrientMesh&& om = get_orient_mesh(mi);
 
            bool locked = false;
            if (!only_one_plate) {
                int plate_index = plate_list.find_instance(oidx, inst_idx);
                if ((plate_index >= 0)&&(plate_index < plate_list.get_plate_count())) {
                    if (plate_list.is_locked(plate_index)) {
                        if (selected) {
                            //selected_in_lock.emplace_back(std::move(om));
                            selected_is_locked = true;
                        }
                        //else
                        //    unselect_in_lock.emplace_back(std::move(om));
                        continue;
                    }
                }
            }
            auto& cont = mo->printable ? (selected ? m_selected : m_unselected) : m_unprintable;
 
            cont.emplace_back(std::move(om));
        }
    }
 
    // If the selection was empty orient everything
    if (m_selected.empty()) {
        if (!selected_is_locked) {
            m_selected.swap(m_unselected);
            //m_unselected.insert(m_unselected.begin(), unselect_in_lock.begin(), unselect_in_lock.end());
        }
        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-orient these objects.")));
        }
    }
}

References _L, Slic3r::GUI::BBLPlateInfo, Slic3r::GUI::PartPlateList::find_instance(), get_orient_mesh(), Slic3r::GUI::PartPlateList::get_plate_count(), Slic3r::ModelObject::instances, Slic3r::GUI::into_u8(), Slic3r::GUI::PartPlateList::is_locked(), m_plater, m_selected, m_unprintable, m_unselected, Slic3r::Model::objects, Slic3r::ModelObject::printable, and Slic3r::GUI::NotificationManager::WarningNotificationLevel.

Referenced by prepare_partplate(), and prepare_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

process()

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

overridevirtual

Implements Slic3r::GUI::Job.

{
    static const auto arrangestr = _u8L("Orienting...");
 
    ctl.update_status(0, arrangestr);
    ctl.call_on_main_thread([this]{ prepare(); }).wait();;
 
    auto start = std::chrono::steady_clock::now();
 
    const GLCanvas3D::OrientSettings& settings = m_plater->canvas3D()->get_orient_settings();
 
    orientation::OrientParams params;
    if (settings.min_area) {
        setMinimalSupportAreaPrams(params);
        params.min_volume = false;
    }
    else {
        params.min_volume = true;
    }
 
    auto count = unsigned(m_selected.size() + m_unprintable.size());
    params.stopcondition = [&ctl]() { return ctl.was_canceled(); };
 
    params.progressind = [this, count, &ctl](unsigned st, std::string orientstr) {
        st += m_unprintable.size();
        // TRN Progress status. %1% is the name of the object being oriented.
        if (st > 0) ctl.update_status(int(st / float(count) * 100), GUI::format(_u8L("Orienting %1%"), orientstr));
    };
 
    orientation::orient(m_selected, m_unselected, params);
 
    auto time_elapsed = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - start);
 
    std::stringstream ss;
    if (!m_selected.empty())
        ss << std::fixed << std::setprecision(3) << "Orient " << m_selected.back().name << " in " << time_elapsed.count() << " seconds. "
        << "Orientation: " << m_selected.back().orientation.transpose() << "; v,phi: " << m_selected.back().axis.transpose() << ", " << m_selected.back().angle << "; euler: " << m_selected.back().euler_angles.transpose();
 
    // finalize just here.
    ctl.update_status(100,
        ctl.was_canceled() ? _u8L("Orienting canceled.")
        : _u8L(ss.str().c_str()));
    wxGetApp().plater()->show_status_message(ctl.was_canceled() ? "Orienting canceled." : ss.str());
}

References _u8L, Slic3r::GUI::Job::Ctl::call_on_main_thread(), count, Slic3r::GUI::format(), m_plater, m_selected, m_unprintable, m_unselected, Slic3r::GUI::GLCanvas3D::OrientSettings::min_area, Slic3r::orientation::OrientParams::min_volume, Slic3r::orientation::orient(), prepare(), Slic3r::orientation::OrientParams::progressind, Slic3r::GUI::setMinimalSupportAreaPrams(), Slic3r::orientation::OrientParams::stopcondition, Slic3r::GUI::Job::Ctl::update_status(), and Slic3r::GUI::Job::Ctl::was_canceled().

Here is the call graph for this function:

Member Data Documentation

m_plater

Plater* Slic3r::GUI::OrientJob::m_plater

private

Referenced by OrientJob(), clear_input(), finalize(), prepare(), prepare_partplate(), prepare_selected(), prepare_selection(), and process().

m_selected

OrientMeshs Slic3r::GUI::OrientJob::m_selected

private

Referenced by clear_input(), finalize(), prepare_selection(), and process().

m_unprintable

OrientMeshs Slic3r::GUI::OrientJob::m_unprintable

private

Referenced by clear_input(), prepare_selection(), and process().

m_unselected

OrientMeshs Slic3r::GUI::OrientJob::m_unselected

private

Referenced by clear_input(), prepare_selection(), and process().

---

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

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