Slic3r::SLAPrint Class Reference

This class is the high level FSM for the SLA printing process. More...

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

Inheritance diagram for Slic3r::SLAPrint:

Collaboration diagram for Slic3r::SLAPrint:

Classes
class	PrintLayer
class	StatusReporter
class	Steps

Public Types
enum	ApplyStatus
enum	CancelStatus
typedef std::function< void(const SlicingStatus &)>	status_callback_type
typedef std::function< void()>	cancel_callback_type
using	Timestamp

Public Member Functions
	SLAPrint ()
virtual	~SLAPrint () override
PrinterTechnology	technology () const noexcept override
void	clear () override
bool	empty () const override
std::vector< ObjectID >	print_object_ids () const override
ApplyStatus	apply (const Model &model, DynamicPrintConfig config, bool extruder_applied=false) override
void	set_task (const TaskParams &params) override
void	process (long long *time_cost_with_cache=nullptr, bool use_cache=false) override
void	finalize () override
bool	is_step_done (SLAPrintObjectStep step) const
bool	finished () const override
const PrintObjects &	objects () const
const SLAPrintObject *	get_print_object_by_model_object_id (ObjectID object_id) const
const SLAPrintObject *	get_object (ObjectID object_id) const
const SLAPrintConfig &	print_config () const
const SLAPrinterConfig &	printer_config () const
const SLAMaterialConfig &	material_config () const
const SLAPrintObjectConfig &	default_object_config () const
Vec3d	relative_correction () const
Transform3d	sla_trafo (const ModelObject &model_object) const
std::string	output_filename (const std::string &filename_base=std::string()) const override
const SLAPrintStatistics &	print_statistics () const
StringObjectException	validate (std::vector< StringObjectException > *warnings=nullptr, Polygons *collison_polygons=nullptr, std::vector< std::pair< Polygon, float > > *height_polygons=nullptr) const override
const std::vector< PrintLayer > &	print_layers () const
void	set_printer (SLAArchive *archiver)
bool	is_step_done (SLAPrintStep step) const
PrintStateBase::StateWithTimeStamp	step_state_with_timestamp (SLAPrintStep step) const
PrintStateBase::StateWithWarnings	step_state_with_warnings (SLAPrintStep step) const
void	active_step_add_warning (PrintStateBase::WarningLevel warning_level, const std::string &message, PrintStateBase::SlicingNotificationType message_id=PrintStateBase::SlicingDefaultNotification)
const Model &	model () const
virtual int	export_cached_data (const std::string &dir_path, bool with_space=false)
virtual int	load_cached_data (const std::string &directory)
void	set_status_default ()
void	set_status_silent ()
void	set_status_callback (status_callback_type cb)
void	set_status (int percent, const std::string &message, unsigned int flags=SlicingStatus::DEFAULT, int warning_step=-1) const
void	set_cancel_callback (cancel_callback_type cancel_callback)
CancelStatus	cancel_status () const
bool	canceled () const
void	cancel ()
void	cancel_internal ()
void	restart ()
const PlaceholderParser &	placeholder_parser () const
const DynamicPrintConfig &	full_print_config () const
std::string	output_filepath (const std::string &path, const std::string &filename_base=std::string()) const
int	get_plate_index () const
void	set_plate_index (int index)
bool	get_no_check_flag () const
void	set_no_check_flag (bool no_check)
std::string	get_plate_name () const
void	set_plate_name (const std::string &name)
ObjectID	id () const
virtual Timestamp	timestamp () const

Protected Member Functions
bool	set_started (SLAPrintStep step)
PrintStateBase::TimeStamp	set_done (SLAPrintStep step)
bool	invalidate_steps (StepTypeIterator step_begin, StepTypeIterator step_end)
bool	invalidate_steps (std::initializer_list< SLAPrintStep > il)
bool	invalidate_all_steps ()
bool	is_step_started_unguarded (SLAPrintStep step) const
bool	is_step_done_unguarded (SLAPrintStep step) const
std::string	output_filename (const std::string &format, const std::string &default_ext, const std::string &filename_base, const DynamicConfig *config_override=nullptr) const
std::mutex &	state_mutex () const
std::function< void()>	cancel_callback ()
void	call_cancel_callback ()
void	status_update_warnings (int step, PrintStateBase::WarningLevel warning_level, const std::string &message, const PrintObjectBase *print_object=nullptr, PrintStateBase::SlicingNotificationType message_id=PrintStateBase::SlicingDefaultNotification)
void	status_update_warnings (int step, PrintStateBase::WarningLevel warning_level, const std::string &message, PrintObjectBase &object, PrintStateBase::SlicingNotificationType message_id=PrintStateBase::SlicingDefaultNotification)
void	throw_if_canceled () const
PrintTryCancel	make_try_cancel () const
void	update_object_placeholders (DynamicConfig &config, const std::string &default_ext) const
void	set_new_unique_id ()
void	set_invalid_id ()
void	copy_id (const ObjectBase &rhs)
virtual void	assign_new_unique_ids_recursive ()

Protected Attributes
Model	m_model
DynamicPrintConfig	m_full_print_config
DynamicPrintConfig	m_ori_full_print_config
PlaceholderParser	m_placeholder_parser
int	m_plate_index
bool	m_no_check
std::string	m_plate_name
status_callback_type	m_status_callback

Private Types
typedef PrintBaseWithState< SLAPrintStep, slapsCount >	Inherited

Private Member Functions
bool	invalidate_step (SLAPrintStep st)
bool	invalidate_state_by_config_options (const std::vector< t_config_option_key > &opt_keys, bool &invalidate_all_model_objects)
void	serialize (Archive &ar)

Static Private Member Functions
static ObjectID	generate_new_id ()
static void	load_and_construct (Archive &ar, cereal::construct< ObjectBase > &construct)

Private Attributes
SLAPrintConfig	m_print_config
SLAPrinterConfig	m_printer_config
SLAMaterialConfig	m_material_config
SLAPrintObjectConfig	m_default_object_config
PrintObjects	m_objects
std::vector< bool >	m_stepmask
std::vector< PrintLayer >	m_printer_input
SLAArchive *	m_printer = nullptr
SLAPrintStatistics	m_print_statistics
class Slic3r::SLAPrint::StatusReporter	m_report_status
friend	SLAPrintObject
PrintState< SLAPrintStep, COUNT >	m_state
std::atomic< CancelStatus >	m_cancel_status
cancel_callback_type	m_cancel_callback
std::mutex	m_state_mutex
friend	PrintTryCancel
ObjectID	m_id

Static Private Attributes
static size_t	s_last_id

Detailed Description

This class is the high level FSM for the SLA printing process.

It should support the background processing framework and contain the metadata for the support geometries and their slicing. It should also dispatch the SLA printing configuration values to the appropriate calculation steps.

Member Typedef Documentation

cancel_callback_type

typedef std::function<void()> Slic3r::PrintBase::cancel_callback_type

inherited

Inherited

typedef PrintBaseWithState<SLAPrintStep, slapsCount> Slic3r::SLAPrint::Inherited

private

status_callback_type

typedef std::function<void(const SlicingStatus&)> Slic3r::PrintBase::status_callback_type

inherited

Timestamp

using Slic3r::ObjectBase::Timestamp

inherited

Member Enumeration Documentation

ApplyStatus

enum Slic3r::PrintBase::ApplyStatus

inherited

                     {
        // No change after the Print::apply() call.
        APPLY_STATUS_UNCHANGED,
        // Some of the Print / PrintObject / PrintObjectInstance data was changed,
        // but no result was invalidated (only data influencing not yet calculated results were changed).
        APPLY_STATUS_CHANGED,
        // Some data was changed, which in turn invalidated already calculated steps.
        APPLY_STATUS_INVALIDATED,
    };

CancelStatus

enum Slic3r::PrintBase::CancelStatus

inherited

                    {
    // No cancelation, background processing should run.
    NOT_CANCELED = 0,
    // Canceled by user from the user interface (user pressed the "Cancel" button or user closed the application).
    CANCELED_BY_USER = 1,
    // Canceled internally from Print::apply() through the Print/PrintObject::invalidate_step() or ::invalidate_all_steps().
    CANCELED_INTERNAL = 2
  };

Constructor & Destructor Documentation

SLAPrint()

Slic3r::SLAPrint::SLAPrint ( )

inline

: m_stepmask(slapsCount, true) {}

References m_stepmask, and Slic3r::slapsCount.

Referenced by Slic3r::SLAPrint::Steps::Steps(), and Slic3r::SLAPrint::StatusReporter::operator()().

Here is the caller graph for this function:

~SLAPrint()

virtual Slic3r::SLAPrint::~SLAPrint ( )

inlineoverridevirtual

{ this->clear(); }

References clear().

Here is the call graph for this function:

Member Function Documentation

active_step_add_warning()

void Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::active_step_add_warning ( PrintStateBase::WarningLevel warning_level, const std::string & message, PrintStateBase::SlicingNotificationType message_id = PrintStateBase::SlicingDefaultNotification )

inlineinherited

    {
        std::pair<PrintStepEnum, bool> active_step = m_state.active_step_add_warning(warning_level, message, (int)message_id, this->state_mutex());
        if (active_step.second)
            // Update UI.
            this->status_update_warnings(static_cast<int>(active_step.first), warning_level, message, nullptr, message_id);
    }

apply()

SLAPrint::ApplyStatus Slic3r::SLAPrint::apply ( const Model & model, DynamicPrintConfig config, bool extruder_applied = false )

overridevirtual

Implements Slic3r::PrintBase.

{
#ifdef _DEBUG
    check_model_ids_validity(model);
#endif /* _DEBUG */
 
    // Normalize the config.
    config.option("sla_print_settings_id",        true);
    config.option("sla_material_settings_id",     true);
    config.option("printer_settings_id",          true);
    // Collect changes to print config.
    t_config_option_keys print_diff    = m_print_config.diff(config);
    t_config_option_keys printer_diff  = m_printer_config.diff(config);
    t_config_option_keys material_diff = m_material_config.diff(config);
    t_config_option_keys object_diff   = m_default_object_config.diff(config);
    t_config_option_keys placeholder_parser_diff = m_placeholder_parser.config_diff(config);
 
    // Do not use the ApplyStatus as we will use the max function when updating apply_status.
    unsigned int apply_status = APPLY_STATUS_UNCHANGED;
    auto update_apply_status = [&apply_status](bool invalidated)
        { apply_status = std::max<unsigned int>(apply_status, invalidated ? APPLY_STATUS_INVALIDATED : APPLY_STATUS_CHANGED); };
    if (! (print_diff.empty() && printer_diff.empty() && material_diff.empty() && object_diff.empty()))
        update_apply_status(false);
 
    // Grab the lock for the Print / PrintObject milestones.
    std::scoped_lock<std::mutex> lock(this->state_mutex());
 
    // The following call may stop the background processing.
    bool invalidate_all_model_objects = false;
    if (! print_diff.empty())
        update_apply_status(this->invalidate_state_by_config_options(print_diff, invalidate_all_model_objects));
    if (! printer_diff.empty())
        update_apply_status(this->invalidate_state_by_config_options(printer_diff, invalidate_all_model_objects));
    if (! material_diff.empty())
        update_apply_status(this->invalidate_state_by_config_options(material_diff, invalidate_all_model_objects));
 
    // Apply variables to placeholder parser. The placeholder parser is currently used
    // only to generate the output file name.
    if (! placeholder_parser_diff.empty()) {
        // update_apply_status(this->invalidate_step(slapsRasterize));
        m_placeholder_parser.apply_config(config);
        // Set the profile aliases for the PrintBase::output_filename()
        m_placeholder_parser.set("print_preset",            config.option("sla_print_settings_id")->clone());
        m_placeholder_parser.set("material_preset",         config.option("sla_material_settings_id")->clone());
        m_placeholder_parser.set("printer_preset",          config.option("printer_settings_id")->clone());
    }
 
    // It is also safe to change m_config now after this->invalidate_state_by_config_options() call.
    m_print_config.apply_only(config, print_diff, true);
    m_printer_config.apply_only(config, printer_diff, true);
    // Handle changes to material config.
    m_material_config.apply_only(config, material_diff, true);
    // Handle changes to object config defaults
    m_default_object_config.apply_only(config, object_diff, true);
 
    if (m_printer) m_printer->apply(m_printer_config);
 
    struct ModelObjectStatus {
        enum Status {
            Unknown,
            Old,
            New,
            Moved,
            Deleted,
        };
        ModelObjectStatus(ObjectID id, Status status = Unknown) : id(id), status(status) {}
        ObjectID                id;
        Status                  status;
        // Search by id.
        bool operator<(const ModelObjectStatus &rhs) const { return id < rhs.id; }
    };
    std::set<ModelObjectStatus> model_object_status;
 
    // 1) Synchronize model objects.
    if (model.id() != m_model.id() || invalidate_all_model_objects) {
        // Kill everything, initialize from scratch.
        // Stop background processing.
        this->call_cancel_callback();
        update_apply_status(this->invalidate_all_steps());
        for (SLAPrintObject *object : m_objects) {
            model_object_status.emplace(object->model_object()->id(), ModelObjectStatus::Deleted);
            update_apply_status(object->invalidate_all_steps());
            delete object;
        }
        m_objects.clear();
        m_model.assign_copy(model);
        for (const ModelObject *model_object : m_model.objects)
            model_object_status.emplace(model_object->id(), ModelObjectStatus::New);
    } else {
        if (model_object_list_equal(m_model, model)) {
            // The object list did not change.
            for (const ModelObject *model_object : m_model.objects)
                model_object_status.emplace(model_object->id(), ModelObjectStatus::Old);
        } else if (model_object_list_extended(m_model, model)) {
            // Add new objects. Their volumes and configs will be synchronized later.
            update_apply_status(this->invalidate_step(slapsMergeSlicesAndEval));
            for (const ModelObject *model_object : m_model.objects)
                model_object_status.emplace(model_object->id(), ModelObjectStatus::Old);
            for (size_t i = m_model.objects.size(); i < model.objects.size(); ++ i) {
                model_object_status.emplace(model.objects[i]->id(), ModelObjectStatus::New);
                m_model.objects.emplace_back(ModelObject::new_copy(*model.objects[i]));
                m_model.objects.back()->set_model(&m_model);
            }
        } else {
            // Reorder the objects, add new objects.
            // First stop background processing before shuffling or deleting the PrintObjects in the object list.
            this->call_cancel_callback();
            update_apply_status(this->invalidate_step(slapsMergeSlicesAndEval));
            // Second create a new list of objects.
            std::vector<ModelObject*> model_objects_old(std::move(m_model.objects));
            m_model.objects.clear();
            m_model.objects.reserve(model.objects.size());
            auto by_id_lower = [](const ModelObject *lhs, const ModelObject *rhs){ return lhs->id() < rhs->id(); };
            std::sort(model_objects_old.begin(), model_objects_old.end(), by_id_lower);
            for (const ModelObject *mobj : model.objects) {
                auto it = std::lower_bound(model_objects_old.begin(), model_objects_old.end(), mobj, by_id_lower);
                if (it == model_objects_old.end() || (*it)->id() != mobj->id()) {
                    // New ModelObject added.
                    m_model.objects.emplace_back(ModelObject::new_copy(*mobj));
                    m_model.objects.back()->set_model(&m_model);
                    model_object_status.emplace(mobj->id(), ModelObjectStatus::New);
                } else {
                    // Existing ModelObject re-added (possibly moved in the list).
                    m_model.objects.emplace_back(*it);
                    model_object_status.emplace(mobj->id(), ModelObjectStatus::Moved);
                }
            }
            bool deleted_any = false;
            for (ModelObject *&model_object : model_objects_old) {
                if (model_object_status.find(ModelObjectStatus(model_object->id())) == model_object_status.end()) {
                    model_object_status.emplace(model_object->id(), ModelObjectStatus::Deleted);
                    deleted_any = true;
                } else
                    // Do not delete this ModelObject instance.
                    model_object = nullptr;
            }
            if (deleted_any) {
                // Delete PrintObjects of the deleted ModelObjects.
                std::vector<SLAPrintObject*> print_objects_old = std::move(m_objects);
                m_objects.clear();
                m_objects.reserve(print_objects_old.size());
                for (SLAPrintObject *print_object : print_objects_old) {
                    auto it_status = model_object_status.find(ModelObjectStatus(print_object->model_object()->id()));
                    assert(it_status != model_object_status.end());
                    if (it_status->status == ModelObjectStatus::Deleted) {
                        update_apply_status(print_object->invalidate_all_steps());
                        delete print_object;
                    } else
                        m_objects.emplace_back(print_object);
                }
                for (ModelObject *model_object : model_objects_old)
                    delete model_object;
            }
        }
    }
 
    // 2) Map print objects including their transformation matrices.
    struct PrintObjectStatus {
        enum Status {
            Unknown,
            Deleted,
            Reused,
            New
        };
        PrintObjectStatus(SLAPrintObject *print_object, Status status = Unknown) :
            id(print_object->model_object()->id()),
            print_object(print_object),
            trafo(print_object->trafo()),
            status(status) {}
        PrintObjectStatus(ObjectID id) : id(id), print_object(nullptr), trafo(Transform3d::Identity()), status(Unknown) {}
        // ID of the ModelObject & PrintObject
        ObjectID         id;
        // Pointer to the old PrintObject
        SLAPrintObject  *print_object;
        // Trafo generated with model_object->world_matrix(true)
        Transform3d      trafo;
        Status           status;
        // Search by id.
        bool operator<(const PrintObjectStatus &rhs) const { return id < rhs.id; }
    };
    std::multiset<PrintObjectStatus> print_object_status;
    for (SLAPrintObject *print_object : m_objects)
        print_object_status.emplace(PrintObjectStatus(print_object));
 
    // 3) Synchronize ModelObjects & PrintObjects.
    std::vector<SLAPrintObject*> print_objects_new;
    print_objects_new.reserve(std::max(m_objects.size(), m_model.objects.size()));
    bool new_objects = false;
    for (size_t idx_model_object = 0; idx_model_object < model.objects.size(); ++ idx_model_object) {
        ModelObject &model_object = *m_model.objects[idx_model_object];
        auto it_status = model_object_status.find(ModelObjectStatus(model_object.id()));
        assert(it_status != model_object_status.end());
        assert(it_status->status != ModelObjectStatus::Deleted);
        // PrintObject for this ModelObject, if it exists.
        auto it_print_object_status = print_object_status.end();
        if (it_status->status != ModelObjectStatus::New) {
            // Update the ModelObject instance, possibly invalidate the linked PrintObjects.
            assert(it_status->status == ModelObjectStatus::Old || it_status->status == ModelObjectStatus::Moved);
            const ModelObject &model_object_new       = *model.objects[idx_model_object];
            it_print_object_status = print_object_status.lower_bound(PrintObjectStatus(model_object.id()));
            if (it_print_object_status != print_object_status.end() && it_print_object_status->id != model_object.id())
                it_print_object_status = print_object_status.end();
            // Check whether a model part volume was added or removed, their transformations or order changed.
            bool model_parts_differ = model_volume_list_changed(model_object, model_object_new, ModelVolumeType::MODEL_PART);
            bool sla_trafo_differs  =
                model_object.instances.empty() != model_object_new.instances.empty() ||
                (! model_object.instances.empty() &&
                  (! sla_trafo(model_object).isApprox(sla_trafo(model_object_new)) ||
                    model_object.instances.front()->is_left_handed() != model_object_new.instances.front()->is_left_handed()));
            if (model_parts_differ || sla_trafo_differs) {
                // The very first step (the slicing step) is invalidated. One may freely remove all associated PrintObjects.
                if (it_print_object_status != print_object_status.end()) {
                    update_apply_status(it_print_object_status->print_object->invalidate_all_steps());
                    const_cast<PrintObjectStatus&>(*it_print_object_status).status = PrintObjectStatus::Deleted;
                }
                // Copy content of the ModelObject including its ID, do not change the parent.
                model_object.assign_copy(model_object_new);
            } else {
                // Synchronize Object's config.
                bool object_config_changed = ! model_object.config.timestamp_matches(model_object_new.config);
                if (object_config_changed)
                    model_object.config.assign_config(model_object_new.config);
                if (! object_diff.empty() || object_config_changed) {
                    SLAPrintObjectConfig new_config = m_default_object_config;
                    new_config.apply(model_object.config.get(), true);
                    if (it_print_object_status != print_object_status.end()) {
                        t_config_option_keys diff = it_print_object_status->print_object->config().diff(new_config);
                        if (! diff.empty()) {
                            update_apply_status(it_print_object_status->print_object->invalidate_state_by_config_options(diff));
                            it_print_object_status->print_object->config_apply_only(new_config, diff, true);
                        }
                    }
                }
 
                bool old_user_modified = model_object.sla_points_status == sla::PointsStatus::UserModified;
                bool new_user_modified = model_object_new.sla_points_status == sla::PointsStatus::UserModified;
                if ((old_user_modified && ! new_user_modified) || // switching to automatic supports from manual supports
                    (! old_user_modified && new_user_modified) || // switching to manual supports from automatic supports
                    (new_user_modified && model_object.sla_support_points != model_object_new.sla_support_points)) {
                    if (it_print_object_status != print_object_status.end())
                        update_apply_status(it_print_object_status->print_object->invalidate_step(slaposSupportPoints));
 
                    model_object.sla_support_points = model_object_new.sla_support_points;
                }
                model_object.sla_points_status = model_object_new.sla_points_status;
 
                // Invalidate hollowing if drain holes have changed
                if (model_object.sla_drain_holes != model_object_new.sla_drain_holes)
                {
                    model_object.sla_drain_holes = model_object_new.sla_drain_holes;
                    update_apply_status(it_print_object_status->print_object->invalidate_step(slaposDrillHoles));
                }
 
                // Copy the ModelObject name, input_file and instances. The instances will compared against PrintObject instances in the next step.
                model_object.name       = model_object_new.name;
                model_object.input_file = model_object_new.input_file;
                model_object.clear_instances();
                model_object.instances.reserve(model_object_new.instances.size());
                for (const ModelInstance *model_instance : model_object_new.instances) {
                    model_object.instances.emplace_back(new ModelInstance(*model_instance));
                    model_object.instances.back()->set_model_object(&model_object);
                }
            }
        }
 
        std::vector<SLAPrintObject::Instance> new_instances = sla_instances(model_object);
        if (it_print_object_status != print_object_status.end() && it_print_object_status->status != PrintObjectStatus::Deleted) {
            // The SLAPrintObject is already there.
            if (new_instances.empty()) {
                const_cast<PrintObjectStatus&>(*it_print_object_status).status = PrintObjectStatus::Deleted;
            } else {
                if (new_instances != it_print_object_status->print_object->instances()) {
                    // Instances changed.
                    it_print_object_status->print_object->set_instances(new_instances);
                    update_apply_status(this->invalidate_step(slapsMergeSlicesAndEval));
                }
                print_objects_new.emplace_back(it_print_object_status->print_object);
                const_cast<PrintObjectStatus&>(*it_print_object_status).status = PrintObjectStatus::Reused;
            }
        } else if (! new_instances.empty()) {
            auto print_object = new SLAPrintObject(this, &model_object);
 
            // FIXME: this invalidates the transformed mesh in SLAPrintObject
            // which is expensive to calculate (especially the raw_mesh() call)
            print_object->set_trafo(sla_trafo(model_object), model_object.instances.front()->is_left_handed());
 
            print_object->set_instances(std::move(new_instances));
 
            print_object->config_apply(m_default_object_config, true);
            print_object->config_apply(model_object.config.get(), true);
            print_objects_new.emplace_back(print_object);
            new_objects = true;
        }
    }
 
    if (m_objects != print_objects_new) {
        this->call_cancel_callback();
        update_apply_status(this->invalidate_all_steps());
        m_objects = print_objects_new;
        // Delete the PrintObjects marked as Unknown or Deleted.
        for (auto &pos : print_object_status)
            if (pos.status == PrintObjectStatus::Unknown || pos.status == PrintObjectStatus::Deleted) {
                update_apply_status(pos.print_object->invalidate_all_steps());
                delete pos.print_object;
            }
        if (new_objects)
            update_apply_status(false);
    }
 
    if(m_objects.empty()) {
        m_printer_input = {};
        m_print_statistics = {};
    }
 
#ifdef _DEBUG
    check_model_ids_equal(m_model, model);
#endif /* _DEBUG */
 
    m_full_print_config = std::move(config);
    return static_cast<ApplyStatus>(apply_status);
}

References Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::APPLY_STATUS_CHANGED, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::APPLY_STATUS_INVALIDATED, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::APPLY_STATUS_UNCHANGED, Slic3r::ModelConfig::assign_config(), Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::call_cancel_callback(), Slic3r::check_model_ids_equal(), Slic3r::check_model_ids_validity(), Slic3r::ModelObject::clear_instances(), Slic3r::ConfigOption::clone(), Slic3r::ModelObject::config, Slic3r::ModelObjectStatus::Deleted, Slic3r::PrintObjectStatus::Deleted, Slic3r::diff(), Slic3r::ModelConfig::get(), Slic3r::ModelObjectStatus::id, Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::id(), Slic3r::PrintObjectStatus::id, Slic3r::ModelObject::input_file, Slic3r::ModelObject::instances, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::invalidate_all_steps(), invalidate_state_by_config_options(), invalidate_step(), m_default_object_config, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::m_full_print_config, m_material_config, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::m_model, m_objects, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::m_placeholder_parser, m_print_config, m_print_statistics, m_printer, m_printer_config, m_printer_input, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::model(), Slic3r::PrintObjectBase::model_object(), Slic3r::model_object_list_equal(), Slic3r::model_object_list_extended(), Slic3r::MODEL_PART, Slic3r::model_volume_list_changed(), Slic3r::ModelObjectStatus::Moved, Slic3r::ModelObject::name, Slic3r::New, Slic3r::ModelObjectStatus::New, Slic3r::ModelObjectStatus::Old, operator<(), Slic3r::ConfigBase::option(), Slic3r::PrintObjectStatus::Reused, Slic3r::ModelObject::sla_drain_holes, Slic3r::sla_instances(), Slic3r::ModelObject::sla_points_status, Slic3r::ModelObject::sla_support_points, sla_trafo(), Slic3r::slaposDrillHoles, Slic3r::slaposSupportPoints, SLAPrintObject, Slic3r::slapsMergeSlicesAndEval, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::state_mutex(), Slic3r::PrintObjectStatus::status, Slic3r::ModelConfig::timestamp_matches(), Slic3r::SLAPrintObject::trafo(), Slic3r::CustomGCode::Unknown, Slic3r::PrintObjectStatus::Unknown, and Slic3r::sla::UserModified.

Here is the call graph for this function:

assign_new_unique_ids_recursive()

virtual void Slic3r::ObjectBase::assign_new_unique_ids_recursive ( )

inlineprotectedvirtualinherited

{ this->set_new_unique_id(); }

call_cancel_callback()

void Slic3r::PrintBase::call_cancel_callback ( )

inlineprotectedinherited

{ m_cancel_callback(); }

Referenced by Slic3r::SLAPrint::apply(), and Slic3r::SLAPrint::set_task().

Here is the caller graph for this function:

cancel()

void Slic3r::PrintBase::cancel ( )

inlineinherited

{ m_cancel_status = CANCELED_BY_USER; }

cancel_callback()

std::function< void()> Slic3r::PrintBase::cancel_callback ( )

inlineprotectedinherited

{ return m_cancel_callback; }

cancel_internal()

void Slic3r::PrintBase::cancel_internal ( )

inlineinherited

{ m_cancel_status = CANCELED_INTERNAL; }

cancel_status()

CancelStatus Slic3r::PrintBase::cancel_status ( ) const

inlineinherited

{ return m_cancel_status.load(std::memory_order_acquire); }

canceled()

bool Slic3r::PrintBase::canceled ( ) const

inlineinherited

{ return m_cancel_status.load(std::memory_order_acquire) != NOT_CANCELED; }

Referenced by Slic3r::SLAPrint::Steps::rasterize(), and Slic3r::SLAPrint::Steps::support_tree().

Here is the caller graph for this function:

clear()

void Slic3r::SLAPrint::clear ( )

overridevirtual

Implements Slic3r::PrintBase.

{
    std::scoped_lock<std::mutex> lock(this->state_mutex());
    // The following call should stop background processing if it is running.
    this->invalidate_all_steps();
    for (SLAPrintObject *object : m_objects)
        delete object;
    m_objects.clear();
    m_model.clear_objects();
}

References Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::invalidate_all_steps(), Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::m_model, m_objects, SLAPrintObject, and Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::state_mutex().

Referenced by ~SLAPrint().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_id()

void Slic3r::ObjectBase::copy_id ( const ObjectBase & rhs )

inlineprotectedinherited

{ m_id = rhs.id(); }

default_object_config()

const SLAPrintObjectConfig & Slic3r::SLAPrint::default_object_config ( ) const

inline

{ return m_default_object_config; }

References m_default_object_config.

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), and Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf().

Here is the caller graph for this function:

empty()

bool Slic3r::SLAPrint::empty ( ) const

inlineoverridevirtual

Implements Slic3r::PrintBase.

{ return m_objects.empty(); }

References m_objects.

export_cached_data()

virtual int Slic3r::PrintBase::export_cached_data ( const std::string & dir_path, bool with_space = false )

inlinevirtualinherited

{ return 0;}

finalize()

void Slic3r::SLAPrint::finalize ( )

overridevirtual

Reimplemented from Slic3r::PrintBase.

{
    for (SLAPrintObject *po : m_objects)
        for (size_t istep = 0; istep < slaposCount; ++ istep)
            po->m_stepmask[istep] = true;
    for (size_t istep = 0; istep < slapsCount; ++ istep)
        m_stepmask[istep] = true;
}

References m_objects, m_stepmask, Slic3r::slaposCount, SLAPrintObject, and Slic3r::slapsCount.

finished()

bool Slic3r::SLAPrint::finished ( ) const

inlineoverridevirtual

Implements Slic3r::PrintBase.

{ return this->is_step_done(slaposSliceSupports) && this->Inherited::is_step_done(slapsRasterize); }

References Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::is_step_done(), is_step_done(), Slic3r::slaposSliceSupports, and Slic3r::slapsRasterize.

Referenced by output_filename().

Here is the call graph for this function:

Here is the caller graph for this function:

full_print_config()

const DynamicPrintConfig & Slic3r::PrintBase::full_print_config ( ) const

inlineinherited

{ return m_full_print_config; }

generate_new_id()

ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

{ return ObjectID(++ s_last_id); }

get_no_check_flag()

bool Slic3r::PrintBase::get_no_check_flag ( ) const

inlineinherited

{ return m_no_check; }

get_object()

const SLAPrintObject * Slic3r::SLAPrint::get_object ( ObjectID object_id ) const

inline

                                                               {
        auto it = std::find_if(m_objects.begin(), m_objects.end(),
            [object_id](const SLAPrintObject *obj) { return obj->id() == object_id; });
        return (it == m_objects.end()) ? nullptr : *it;
    }

References m_objects, and SLAPrintObject.

Referenced by Slic3r::GUI::Plater::priv::on_slicing_update().

Here is the caller graph for this function:

get_plate_index()

int Slic3r::PrintBase::get_plate_index ( ) const

inlineinherited

{ return m_plate_index; }

get_plate_name()

std::string Slic3r::PrintBase::get_plate_name ( ) const

inlineinherited

{ return m_plate_name; }

get_print_object_by_model_object_id()

const SLAPrintObject * Slic3r::SLAPrint::get_print_object_by_model_object_id ( ObjectID object_id ) const

inline

                                                                                        {
        auto it = std::find_if(m_objects.begin(), m_objects.end(),
            [object_id](const SLAPrintObject* obj) { return obj->model_object()->id() == object_id; });
        return (it == m_objects.end()) ? nullptr : *it;
    }

References m_objects, and SLAPrintObject.

id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

{ return m_id; }

Referenced by Slic3r::SLAPrint::apply().

Here is the caller graph for this function:

invalidate_all_steps()

bool Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::invalidate_all_steps ( )

inlineprotectedinherited

        { return m_state.invalidate_all(this->cancel_callback()); }

Referenced by Slic3r::SLAPrint::apply(), Slic3r::SLAPrint::clear(), and Slic3r::SLAPrint::invalidate_step().

Here is the caller graph for this function:

invalidate_state_by_config_options()

bool Slic3r::SLAPrint::invalidate_state_by_config_options ( const std::vector< t_config_option_key > & opt_keys, bool & invalidate_all_model_objects )

private

{
    if (opt_keys.empty())
        return false;
 
    static std::unordered_set<std::string> steps_full = {
        "initial_layer_height",
        "material_correction",
        "material_correction_x",
        "material_correction_y",
        "material_correction_z",
        "relative_correction",
        "relative_correction_x",
        "relative_correction_y",
        "relative_correction_z",
        "absolute_correction",
        "elefant_foot_compensation",
        "elefant_foot_min_width",
        "gamma_correction"
    };
 
    // Cache the plenty of parameters, which influence the final rasterization only,
    // or they are only notes not influencing the rasterization step.
    static std::unordered_set<std::string> steps_rasterize = {
        "min_exposure_time",
        "max_exposure_time",
        "exposure_time",
        "min_initial_exposure_time",
        "max_initial_exposure_time",
        "initial_exposure_time",
        "display_width",
        "display_height",
        "display_pixels_x",
        "display_pixels_y",
        "display_mirror_x",
        "display_mirror_y",
        "display_orientation"
    };
 
    static std::unordered_set<std::string> steps_ignore = {
        "printable_area",
        "printable_height",
        "printer_technology",
        "filename_format",
        "fast_tilt_time",
        "slow_tilt_time",
        "area_fill",
        "bottle_cost",
        "bottle_volume",
        "bottle_weight",
        "material_density"
    };
 
    std::vector<SLAPrintStep> steps;
    std::vector<SLAPrintObjectStep> osteps;
    bool invalidated = false;
 
    for (const t_config_option_key &opt_key : opt_keys) {
        if (steps_rasterize.find(opt_key) != steps_rasterize.end()) {
            // These options only affect the final rasterization, or they are just notes without influence on the output,
            // so there is nothing to invalidate.
            steps.emplace_back(slapsMergeSlicesAndEval);
        } else if (steps_ignore.find(opt_key) != steps_ignore.end()) {
            // These steps have no influence on the output. Just ignore them.
        } else if (steps_full.find(opt_key) != steps_full.end()) {
            steps.emplace_back(slapsMergeSlicesAndEval);
            osteps.emplace_back(slaposObjectSlice);
            invalidate_all_model_objects = true;
        } else {
            // All values should be covered.
            assert(false);
        }
    }
 
    sort_remove_duplicates(steps);
    for (SLAPrintStep step : steps)
        invalidated |= this->invalidate_step(step);
    sort_remove_duplicates(osteps);
    for (SLAPrintObjectStep ostep : osteps)
        for (SLAPrintObject *object : m_objects)
            invalidated |= object->invalidate_step(ostep);
    return invalidated;
}

References invalidate_step(), m_objects, Slic3r::slaposObjectSlice, SLAPrintObject, Slic3r::slapsMergeSlicesAndEval, and Slic3r::sort_remove_duplicates().

Referenced by apply().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_step()

bool Slic3r::SLAPrint::invalidate_step ( SLAPrintStep st )

private

{
    bool invalidated = Inherited::invalidate_step(step);
 
    // propagate to dependent steps
    if (step == slapsMergeSlicesAndEval) {
        invalidated |= this->invalidate_all_steps();
    }
 
    return invalidated;
}

References Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::invalidate_all_steps(), Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::invalidate_step(), and Slic3r::slapsMergeSlicesAndEval.

Referenced by apply(), invalidate_state_by_config_options(), and set_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_steps() [1/2]

bool Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::invalidate_steps ( std::initializer_list< SLAPrintStep > il )

inlineprotectedinherited

        { return m_state.invalidate_multiple(il.begin(), il.end(), this->cancel_callback()); }

invalidate_steps() [2/2]

bool Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::invalidate_steps ( StepTypeIterator step_begin, StepTypeIterator step_end )

inlineprotectedinherited

        { return m_state.invalidate_multiple(step_begin, step_end, this->cancel_callback()); }

is_step_done() [1/2]

bool Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::is_step_done ( SLAPrintStep step ) const

inlineinherited

{ return m_state.is_done(step, this->state_mutex()); }

Referenced by Slic3r::SLAPrint::finished().

Here is the caller graph for this function:

is_step_done() [2/2]

bool Slic3r::SLAPrint::is_step_done

(

SLAPrintObjectStep

step

)

const

{
    if (m_objects.empty())
        return false;
    std::scoped_lock<std::mutex> lock(this->state_mutex());
    for (const SLAPrintObject *object : m_objects)
        if (! object->is_step_done_unguarded(step))
            return false;
    return true;
}

References m_objects, SLAPrintObject, and Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::state_mutex().

Referenced by finished().

Here is the call graph for this function:

Here is the caller graph for this function:

is_step_done_unguarded()

bool Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::is_step_done_unguarded ( SLAPrintStep step ) const

inlineprotectedinherited

{ return m_state.is_done_unguarded(step); }

is_step_started_unguarded()

bool Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::is_step_started_unguarded ( SLAPrintStep step ) const

inlineprotectedinherited

{ return m_state.is_started_unguarded(step); }

load_and_construct()

void Slic3r::ObjectBase::load_and_construct ( Archive & ar, cereal::construct< ObjectBase > & construct )

inlinestaticprivateinherited

{ ObjectID id; ar(id); construct(id); }

load_cached_data()

virtual int Slic3r::PrintBase::load_cached_data ( const std::string & directory )

inlinevirtualinherited

{ return 0;}

make_try_cancel()

PrintTryCancel Slic3r::PrintBase::make_try_cancel ( ) const

inlineprotectedinherited

{ return PrintTryCancel(this); }

material_config()

const SLAMaterialConfig & Slic3r::SLAPrint::material_config ( ) const

inline

{ return m_material_config; }

References m_material_config.

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::SLAPrint::Steps::merge_slices_and_eval_stats(), and relative_correction().

Here is the caller graph for this function:

model()

const Model & Slic3r::PrintBase::model ( ) const

inlineinherited

{ return m_model; }

Referenced by Slic3r::SLAPrint::apply().

Here is the caller graph for this function:

objects()

const PrintObjects & Slic3r::SLAPrint::objects ( ) const

inline

{ return m_objects; }

References m_objects.

Referenced by Slic3r::GUI::GLCanvas3D::_load_sla_shells(), Slic3r::GUI::GLCanvas3D::_render_sla_slices(), and Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf().

Here is the caller graph for this function:

output_filename() [1/2]

std::string Slic3r::PrintBase::output_filename ( const std::string & format, const std::string & default_ext, const std::string & filename_base, const DynamicConfig * config_override = nullptr ) const

protectedinherited

{
    DynamicConfig cfg;
    if (config_override != nullptr)
      cfg = *config_override;
    cfg.set_key_value("version", new ConfigOptionString(std::string(SoftFever_VERSION)));
    PlaceholderParser::update_timestamp(cfg);
    PlaceholderParser::update_user_name(cfg);
    this->update_object_placeholders(cfg, default_ext);
    if (! filename_base.empty()) {
    cfg.set_key_value("input_filename", new ConfigOptionString(filename_base + default_ext));
    cfg.set_key_value("input_filename_base", new ConfigOptionString(filename_base));
    }
    try {
    boost::filesystem::path filename = format.empty() ?
      cfg.opt_string("input_filename_base") + default_ext :
      this->placeholder_parser().process(format, 0, &cfg);
        if (filename.extension().empty())
            filename.replace_extension(default_ext);
        return filename.string();
    } catch (std::runtime_error &err) {
        throw Slic3r::PlaceholderParserError(L("Processing of the filename_format template failed.") + "\n" + err.what());
    }
}

output_filename() [2/2]

std::string Slic3r::SLAPrint::output_filename ( const std::string & filename_base = std::string() ) const

overridevirtual

Implements Slic3r::PrintBase.

{
    DynamicConfig config = this->finished() ? this->print_statistics().config() : this->print_statistics().placeholders();
    return this->PrintBase::output_filename(m_print_config.filename_format.value, ".sl1", filename_base, &config);
}

References Slic3r::SLAPrintStatistics::config(), finished(), m_print_config, Slic3r::PrintBase::output_filename(), Slic3r::SLAPrintStatistics::placeholders(), and print_statistics().

Here is the call graph for this function:

output_filepath()

std::string Slic3r::PrintBase::output_filepath ( const std::string & path, const std::string & filename_base = std::string() ) const

inherited

{
    // if we were supplied no path, generate an automatic one based on our first object's input file
    if (path.empty())
        // get the first input file name
        return (boost::filesystem::path(m_model.propose_export_file_name_and_path()).parent_path() / this->output_filename(filename_base)).make_preferred().string();
 
    // if we were supplied a directory, use it and append our automatically generated filename
    boost::filesystem::path p(path);
    if (boost::filesystem::is_directory(p))
        return (p / this->output_filename(filename_base)).make_preferred().string();
 
    // if we were supplied a file which is not a directory, use it
    return path;
}

placeholder_parser()

const PlaceholderParser & Slic3r::PrintBase::placeholder_parser ( ) const

inlineinherited

{ return m_placeholder_parser; }

print_config()

const SLAPrintConfig & Slic3r::SLAPrint::print_config ( ) const

inline

{ return m_print_config; }

References m_print_config.

print_layers()

const std::vector< PrintLayer > & Slic3r::SLAPrint::print_layers ( ) const

inline

{ return m_printer_input; }

References m_printer_input.

print_object_ids()

std::vector< ObjectID > Slic3r::SLAPrint::print_object_ids ( ) const

overridevirtual

Implements Slic3r::PrintBase.

{
    std::vector<ObjectID> out;
    // Reserve one more for the caller to append the ID of the Print itself.
    out.reserve(m_objects.size() + 1);
    for (const SLAPrintObject *print_object : m_objects)
        out.emplace_back(print_object->id());
    return out;
}

References m_objects, and SLAPrintObject.

print_statistics()

const SLAPrintStatistics & Slic3r::SLAPrint::print_statistics ( ) const

inline

{ return m_print_statistics; }

References m_print_statistics.

Referenced by Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf(), Slic3r::SLAPrint::Steps::merge_slices_and_eval_stats(), and output_filename().

Here is the caller graph for this function:

printer_config()

const SLAPrinterConfig & Slic3r::SLAPrint::printer_config ( ) const

inline

{ return m_printer_config; }

References m_printer_config.

Referenced by Slic3r::SLAPrint::Steps::merge_slices_and_eval_stats(), and relative_correction().

Here is the caller graph for this function:

process()

void Slic3r::SLAPrint::process ( long long * time_cost_with_cache = nullptr, bool use_cache = false )

overridevirtual

Implements Slic3r::PrintBase.

{
    if (m_objects.empty())
        return;
 
    name_tbb_thread_pool_threads_set_locale();
 
    // Assumption: at this point the print objects should be populated only with
    // the model objects we have to process and the instances are also filtered
 
    Steps printsteps(this);
 
    // We want to first process all objects...
    std::vector<SLAPrintObjectStep> level1_obj_steps = {
        slaposHollowing, slaposDrillHoles, slaposObjectSlice, slaposSupportPoints, slaposSupportTree, slaposPad
    };
 
    // and then slice all supports to allow preview to be displayed ASAP
    std::vector<SLAPrintObjectStep> level2_obj_steps = {
        slaposSliceSupports
    };
 
    SLAPrintStep print_steps[] = { slapsMergeSlicesAndEval, slapsRasterize };
 
    double st = Steps::min_objstatus;
 
    BOOST_LOG_TRIVIAL(info) << "Start slicing process.";
 
#ifdef SLAPRINT_DO_BENCHMARK
    Benchmark bench;
#else
    struct {
        void start() {} void stop() {} double getElapsedSec() { return .0; }
    } bench;
#endif
 
    std::array<double, slaposCount + slapsCount> step_times {};
 
    auto apply_steps_on_objects =
        [this, &st, &printsteps, &step_times, &bench]
        (const std::vector<SLAPrintObjectStep> &steps)
    {
        double incr = 0;
        for (SLAPrintObject *po : m_objects) {
            for (SLAPrintObjectStep step : steps) {
 
                // Cancellation checking. Each step will check for
                // cancellation on its own and return earlier gracefully.
                // Just after it returns execution gets to this point and
                // throws the canceled signal.
                throw_if_canceled();
 
                st += incr;
 
                if (po->m_stepmask[step] && po->set_started(step)) {
                    m_report_status(*this, st, printsteps.label(step));
                    bench.start();
                    printsteps.execute(step, *po);
                    bench.stop();
                    step_times[step] += bench.getElapsedSec();
                    throw_if_canceled();
                    po->set_done(step);
                }
 
                incr = printsteps.progressrange(step);
            }
        }
    };
 
    apply_steps_on_objects(level1_obj_steps);
    apply_steps_on_objects(level2_obj_steps);
 
    // this would disable the rasterization step
    // std::fill(m_stepmask.begin(), m_stepmask.end(), false);
 
    st = Steps::max_objstatus;
    for(SLAPrintStep currentstep : print_steps) {
        throw_if_canceled();
 
        if (m_stepmask[currentstep] && set_started(currentstep)) {
            m_report_status(*this, st, printsteps.label(currentstep));
            bench.start();
            printsteps.execute(currentstep);
            bench.stop();
            step_times[slaposCount + currentstep] += bench.getElapsedSec();
            throw_if_canceled();
            set_done(currentstep);
        }
 
        st += printsteps.progressrange(currentstep);
    }
 
    // If everything vent well
    m_report_status(*this, 100, L("Slicing done"));
 
#ifdef SLAPRINT_DO_BENCHMARK
    std::string csvbenchstr;
    for (size_t i = 0; i < size_t(slaposCount); ++i)
        csvbenchstr += printsteps.label(SLAPrintObjectStep(i)) + ";";
 
    for (size_t i = 0; i < size_t(slapsCount); ++i)
        csvbenchstr += printsteps.label(SLAPrintStep(i)) + ";";
 
    csvbenchstr += "\n";
    for (double t : step_times) csvbenchstr += std::to_string(t) + ";";
 
    std::cout << "Performance stats: \n" << csvbenchstr << std::endl;
#endif
 
}

References Slic3r::SLAPrint::Steps::execute(), L, Slic3r::SLAPrint::Steps::label(), m_objects, m_report_status, m_stepmask, Slic3r::SLAPrint::Steps::max_objstatus, Slic3r::SLAPrint::Steps::min_objstatus, Slic3r::name_tbb_thread_pool_threads_set_locale(), Slic3r::SLAPrint::Steps::progressrange(), Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::set_done(), Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::set_started(), Slic3r::slaposCount, Slic3r::slaposDrillHoles, Slic3r::slaposHollowing, Slic3r::slaposObjectSlice, Slic3r::slaposPad, Slic3r::slaposSliceSupports, Slic3r::slaposSupportPoints, Slic3r::slaposSupportTree, SLAPrintObject, Slic3r::slapsCount, Slic3r::slapsMergeSlicesAndEval, Slic3r::slapsRasterize, and Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::throw_if_canceled().

Here is the call graph for this function:

relative_correction()

Vec3d Slic3r::SLAPrint::relative_correction

(

)

const

{
    Vec3d corr(1., 1., 1.);
 
    if(printer_config().relative_correction.values.size() >= 2) {
        corr.x() = printer_config().relative_correction_x.value;
        corr.y() = printer_config().relative_correction_y.value;
        corr.z() = printer_config().relative_correction_z.value;
    }
 
    if(material_config().material_correction.values.size() >= 2) {
        corr.x() *= material_config().material_correction_x.value;
        corr.y() *= material_config().material_correction_y.value;
        corr.z() *= material_config().material_correction_z.value;
    }
 
    return corr;
}

References material_config(), printer_config(), and relative_correction().

Referenced by relative_correction(), and sla_trafo().

Here is the call graph for this function:

Here is the caller graph for this function:

restart()

void Slic3r::PrintBase::restart ( )

inlineinherited

{ m_cancel_status = NOT_CANCELED; }

serialize()

void Slic3r::ObjectBase::serialize ( Archive & ar )

inlineprivateinherited

{ ar(m_id); }

set_cancel_callback()

void Slic3r::PrintBase::set_cancel_callback ( cancel_callback_type cancel_callback )

inlineinherited

{ m_cancel_callback = cancel_callback; }

set_done()

PrintStateBase::TimeStamp Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::set_done ( SLAPrintStep step )

inlineprotectedinherited

                                                       {
    std::pair<PrintStateBase::TimeStamp, bool> status = m_state.set_done(step, this->state_mutex(), [this](){ this->throw_if_canceled(); });
        if (status.second)
            this->status_update_warnings(static_cast<int>(step), PrintStateBase::WarningLevel::NON_CRITICAL, std::string());
        return status.first;
  }

Referenced by Slic3r::SLAPrint::process().

Here is the caller graph for this function:

set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

{ m_id = 0; }

set_new_unique_id()

void Slic3r::ObjectBase::set_new_unique_id ( )

inlineprotectedinherited

{ m_id = generate_new_id(); }

set_no_check_flag()

void Slic3r::PrintBase::set_no_check_flag ( bool no_check )

inlineinherited

{ m_no_check = no_check; }

set_plate_index()

void Slic3r::PrintBase::set_plate_index ( int index )

inlineinherited

{ m_plate_index = index; }

set_plate_name()

void Slic3r::PrintBase::set_plate_name ( const std::string & name )

inlineinherited

{ m_plate_name = name; }

set_printer()

void Slic3r::SLAPrint::set_printer

(

SLAArchive *

archiver

)

{
    invalidate_step(slapsRasterize);
    m_printer = arch;
}

References invalidate_step(), m_printer, and Slic3r::slapsRasterize.

Here is the call graph for this function:

set_started()

bool Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::set_started ( SLAPrintStep step )

inlineprotectedinherited

{ return m_state.set_started(step, this->state_mutex(), [this](){ this->throw_if_canceled(); }); }

Referenced by Slic3r::SLAPrint::process().

Here is the caller graph for this function:

set_status()

void Slic3r::PrintBase::set_status ( int percent, const std::string & message, unsigned int flags = SlicingStatus::DEFAULT, int warning_step = -1 ) const

inherited

{
  if (m_status_callback)
        m_status_callback(SlicingStatus(percent, message, flags, warning_step));
    else
        BOOST_LOG_TRIVIAL(debug) <<boost::format("Percent %1%: %2%\n")%percent %message.c_str();
}

set_status_callback()

void Slic3r::PrintBase::set_status_callback ( status_callback_type cb )

inlineinherited

{ m_status_callback = cb; }

set_status_default()

void Slic3r::PrintBase::set_status_default ( )

inlineinherited

{ m_status_callback = nullptr; }

set_status_silent()

void Slic3r::PrintBase::set_status_silent ( )

inlineinherited

{ m_status_callback = [](const SlicingStatus&){}; }

set_task()

void Slic3r::SLAPrint::set_task ( const TaskParams & params )

overridevirtual

Reimplemented from Slic3r::PrintBase.

{
    // Grab the lock for the Print / PrintObject milestones.
    std::scoped_lock<std::mutex> lock(this->state_mutex());
 
    int n_object_steps = int(params.to_object_step) + 1;
    if (n_object_steps == 0)
        n_object_steps = int(slaposCount);
 
    if (params.single_model_object.valid()) {
        // Find the print object to be processed with priority.
        SLAPrintObject *print_object = nullptr;
        size_t          idx_print_object = 0;
        for (; idx_print_object < m_objects.size(); ++ idx_print_object)
            if (m_objects[idx_print_object]->model_object()->id() == params.single_model_object) {
                print_object = m_objects[idx_print_object];
                break;
            }
        assert(print_object != nullptr);
        // Find out whether the priority print object is being currently processed.
        bool running = false;
        for (int istep = 0; istep < n_object_steps; ++ istep) {
            if (! print_object->m_stepmask[size_t(istep)])
                // Step was skipped, cancel.
                break;
            if (print_object->is_step_started_unguarded(SLAPrintObjectStep(istep))) {
                // No step was skipped, and a wanted step is being processed. Don't cancel.
                running = true;
                break;
            }
        }
        if (! running)
            this->call_cancel_callback();
 
        // Now the background process is either stopped, or it is inside one of the print object steps to be calculated anyway.
        if (params.single_model_instance_only) {
            // Suppress all the steps of other instances.
            for (SLAPrintObject *po : m_objects)
                for (size_t istep = 0; istep < slaposCount; ++ istep)
                    po->m_stepmask[istep] = false;
        } else if (! running) {
            // Swap the print objects, so that the selected print_object is first in the row.
            // At this point the background processing must be stopped, so it is safe to shuffle print objects.
            if (idx_print_object != 0)
                std::swap(m_objects.front(), m_objects[idx_print_object]);
        }
        // and set the steps for the current object.
        for (int istep = 0; istep < n_object_steps; ++ istep)
            print_object->m_stepmask[size_t(istep)] = true;
        for (int istep = n_object_steps; istep < int(slaposCount); ++ istep)
            print_object->m_stepmask[size_t(istep)] = false;
    } else {
        // Slicing all objects.
        bool running = false;
        for (SLAPrintObject *print_object : m_objects)
            for (int istep = 0; istep < n_object_steps; ++ istep) {
                if (! print_object->m_stepmask[size_t(istep)]) {
                    // Step may have been skipped. Restart.
                    goto loop_end;
                }
                if (print_object->is_step_started_unguarded(SLAPrintObjectStep(istep))) {
                    // This step is running, and the state cannot be changed due to the this->state_mutex() being locked.
                    // It is safe to manipulate m_stepmask of other SLAPrintObjects and SLAPrint now.
                    running = true;
                    goto loop_end;
                }
            }
    loop_end:
        if (! running)
            this->call_cancel_callback();
        for (SLAPrintObject *po : m_objects) {
            for (int istep = 0; istep < n_object_steps; ++ istep)
                po->m_stepmask[size_t(istep)] = true;
            for (auto istep = size_t(n_object_steps); istep < slaposCount; ++ istep)
                po->m_stepmask[istep] = false;
        }
    }
 
    if (params.to_object_step != -1 || params.to_print_step != -1) {
        // Limit the print steps.
        size_t istep = (params.to_object_step != -1) ? 0 : size_t(params.to_print_step) + 1;
        for (; istep < m_stepmask.size(); ++ istep)
            m_stepmask[istep] = false;
    }
}

References Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::call_cancel_callback(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnum, COUNT >::is_step_started_unguarded(), m_objects, m_stepmask, Slic3r::SLAPrintObject::m_stepmask, Slic3r::PrintBase::TaskParams::single_model_instance_only, Slic3r::PrintBase::TaskParams::single_model_object, Slic3r::slaposCount, SLAPrintObject, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::state_mutex(), Slic3r::PrintBase::TaskParams::to_object_step, Slic3r::PrintBase::TaskParams::to_print_step, and Slic3r::ObjectID::valid().

Here is the call graph for this function:

sla_trafo()

Transform3d Slic3r::SLAPrint::sla_trafo

(

const ModelObject &

model_object

)

const

{
 
    Vec3d corr = this->relative_correction();
 
    ModelInstance &model_instance = *model_object.instances.front();
    Vec3d          offset         = model_instance.get_offset();
    Vec3d          rotation       = model_instance.get_rotation();
    offset(0) = 0.;
    offset(1) = 0.;
    rotation(2) = 0.;
 
    offset.z() *= corr.z();
 
    auto trafo = Transform3d::Identity();
    trafo.translate(offset);
    trafo.scale(corr);
    trafo.rotate(Eigen::AngleAxisd(rotation.z(), Vec3d::UnitZ()));
    trafo.rotate(Eigen::AngleAxisd(rotation.y(), Vec3d::UnitY()));
    trafo.rotate(Eigen::AngleAxisd(rotation.x(), Vec3d::UnitX()));
    trafo.scale(model_instance.get_scaling_factor());
    trafo.scale(model_instance.get_mirror());
 
    if (model_instance.is_left_handed())
        trafo = Eigen::Scaling(Vec3d(-1., 1., 1.)) * trafo;
 
    return trafo;
}

References Slic3r::ModelInstance::get_mirror(), Slic3r::ModelInstance::get_offset(), Slic3r::ModelInstance::get_rotation(), Slic3r::ModelInstance::get_scaling_factor(), Slic3r::ModelObject::instances, Slic3r::ModelInstance::is_left_handed(), Slic3r::offset(), and relative_correction().

Referenced by apply().

Here is the call graph for this function:

Here is the caller graph for this function:

state_mutex()

std::mutex & Slic3r::PrintBase::state_mutex ( ) const

inlineprotectedinherited

{ return m_state_mutex; }

Referenced by Slic3r::SLAPrint::apply(), Slic3r::SLAPrint::clear(), Slic3r::SLAPrint::is_step_done(), and Slic3r::SLAPrint::set_task().

Here is the caller graph for this function:

status_update_warnings() [1/2]

void Slic3r::PrintBase::status_update_warnings ( int step, PrintStateBase::WarningLevel warning_level, const std::string & message, const PrintObjectBase * print_object = nullptr, PrintStateBase::SlicingNotificationType message_id = PrintStateBase::SlicingDefaultNotification )

protectedinherited

{
    if (this->m_status_callback) {
        auto status = print_object ? SlicingStatus(*print_object, step, message, message_id, warning_level) : SlicingStatus(*this, step, message, message_id, warning_level);
        m_status_callback(status);
    }
    else if (! message.empty())
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", Print warning: %1%\n")% message.c_str();
}

status_update_warnings() [2/2]

void Slic3r::PrintBase::status_update_warnings ( int step, PrintStateBase::WarningLevel warning_level, const std::string & message, PrintObjectBase & object, PrintStateBase::SlicingNotificationType message_id = PrintStateBase::SlicingDefaultNotification )

protectedinherited

{
    //BBS: add object it into slicing status
    if (this->m_status_callback) {
        m_status_callback(SlicingStatus(object, step, message, message_id, warning_level));
    }
    else if (!message.empty())
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", PrintObject warning: %1%\n")% message.c_str();
}

step_state_with_timestamp()

PrintStateBase::StateWithTimeStamp Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::step_state_with_timestamp ( SLAPrintStep step ) const

inlineinherited

{ return m_state.state_with_timestamp(step, this->state_mutex()); }

step_state_with_warnings()

PrintStateBase::StateWithWarnings Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::step_state_with_warnings ( SLAPrintStep step ) const

inlineinherited

{ return m_state.state_with_warnings(step, this->state_mutex()); }

technology()

PrinterTechnology Slic3r::SLAPrint::technology ( ) const

inlineoverridevirtualnoexcept

Implements Slic3r::PrintBase.

{ return ptSLA; }

References Slic3r::ptSLA.

throw_if_canceled()

void Slic3r::PrintBase::throw_if_canceled ( ) const

inlineprotectedinherited

{ if (m_cancel_status.load(std::memory_order_acquire)) throw CanceledException(); }

Referenced by Slic3r::SLAPrint::Steps::generate_pad(), Slic3r::SLAPrint::process(), Slic3r::SLAPrint::Steps::support_points(), and Slic3r::SLAPrint::Steps::support_tree().

Here is the caller graph for this function:

timestamp()

virtual Timestamp Slic3r::ObjectBase::timestamp ( ) const

inlinevirtualinherited

{ return 0; }

update_object_placeholders()

void Slic3r::PrintBase::update_object_placeholders ( DynamicConfig & config, const std::string & default_ext ) const

protectedinherited

{
    // get the first input file name
    std::string input_file;
    std::string first_object_name;
    std::vector<std::string> v_scale;
    int num_objects = 0;
    int num_instances = 0;
  for (const ModelObject *model_object : m_model.objects) {
    ModelInstance *printable = nullptr;
    for (ModelInstance *model_instance : model_object->instances)
      if (model_instance->is_printable()) {
        printable = model_instance;
        ++ num_instances;
      }
    if (printable) {
            ++ num_objects;
          if (num_objects == 1)
              first_object_name = model_object->name;
          // CHECK_ME -> Is the following correct ?
      v_scale.push_back("x:" + boost::lexical_cast<std::string>(printable->get_scaling_factor(X) * 100) +
        "% y:" + boost::lexical_cast<std::string>(printable->get_scaling_factor(Y) * 100) +
        "% z:" + boost::lexical_cast<std::string>(printable->get_scaling_factor(Z) * 100) + "%");
          if (input_file.empty())
              input_file = model_object->name.empty() ? model_object->input_file : model_object->name;
      }
    }
 
    config.set_key_value("num_objects", new ConfigOptionInt(num_objects));
    config.set_key_value("num_instances", new ConfigOptionInt(num_instances));
 
    config.set_key_value("scale", new ConfigOptionStrings(v_scale));
    config.set_key_value("first_object_name", new ConfigOptionString(first_object_name));
    if (! input_file.empty()) {
        // get basename with and without suffix
        const std::string input_filename = boost::filesystem::path(input_file).filename().string();
        const std::string input_filename_base = input_filename.substr(0, input_filename.find_last_of("."));
        config.set_key_value("input_filename", new ConfigOptionString(input_filename_base + default_ext));
        config.set_key_value("input_filename_base", new ConfigOptionString(input_filename_base));
    }
}

validate()

StringObjectException Slic3r::SLAPrint::validate ( std::vector< StringObjectException > * warnings = nullptr, Polygons * collison_polygons = nullptr, std::vector< std::pair< Polygon, float > > * height_polygons = nullptr ) const

overridevirtual

Reimplemented from Slic3r::PrintBase.

{
    for(SLAPrintObject * po : m_objects) {
 
        const ModelObject *mo = po->model_object();
        bool supports_en = po->config().supports_enable.getBool();
 
        if(supports_en &&
           mo->sla_points_status == sla::PointsStatus::UserModified &&
           mo->sla_support_points.empty())
            return {L("Cannot proceed without support points! "
                     "Add support points or disable support generation."), po};
 
        sla::SupportTreeConfig cfg = make_support_cfg(po->config());
 
        double elv = cfg.object_elevation_mm;
 
        sla::PadConfig padcfg = make_pad_cfg(po->config());
        sla::PadConfig::EmbedObject &builtinpad = padcfg.embed_object;
 
        if(supports_en && !builtinpad.enabled && elv < cfg.head_fullwidth())
            return {L(
                "Elevation is too low for object. Use the \"Pad around "
                "object\" feature to print the object without elevation."), po};
 
        if(supports_en && builtinpad.enabled &&
           cfg.pillar_base_safety_distance_mm < builtinpad.object_gap_mm) {
            return {L(
                "The endings of the support pillars will be deployed on the "
                "gap between the object and the pad. 'Support base safety "
                "distance' has to be greater than the 'Pad object gap' "
                "parameter to avoid this."), po};
        }
 
        std::string pval = padcfg.validate();
        if (!pval.empty()) return {pval, po};
    }
 
    double expt_max = m_printer_config.max_exposure_time.getFloat();
    double expt_min = m_printer_config.min_exposure_time.getFloat();
    double expt_cur = m_material_config.exposure_time.getFloat();
 
    if (expt_cur < expt_min || expt_cur > expt_max)
        return {L("Exposition time is out of printer profile bounds.")};
 
    double iexpt_max = m_printer_config.max_initial_exposure_time.getFloat();
    double iexpt_min = m_printer_config.min_initial_exposure_time.getFloat();
    double iexpt_cur = m_material_config.initial_exposure_time.getFloat();
 
    if (iexpt_cur < iexpt_min || iexpt_cur > iexpt_max)
        return {L("Initial exposition time is out of printer profile bounds.")};
 
    return {};
}

References Slic3r::ModelObject::config, Slic3r::sla::PadConfig::embed_object, Slic3r::sla::PadConfig::EmbedObject::enabled, Slic3r::sla::SupportTreeConfig::head_fullwidth(), L, m_material_config, m_objects, m_printer_config, Slic3r::make_pad_cfg(), Slic3r::make_support_cfg(), Slic3r::sla::SupportTreeConfig::object_elevation_mm, Slic3r::sla::PadConfig::EmbedObject::object_gap_mm, Slic3r::sla::SupportTreeConfig::pillar_base_safety_distance_mm, Slic3r::ModelObject::sla_points_status, Slic3r::ModelObject::sla_support_points, SLAPrintObject, Slic3r::sla::UserModified, and Slic3r::sla::PadConfig::validate().

Here is the call graph for this function:

Member Data Documentation

m_cancel_callback

cancel_callback_type Slic3r::PrintBase::m_cancel_callback

privateinherited

{};

m_cancel_status

std::atomic<CancelStatus> Slic3r::PrintBase::m_cancel_status

privateinherited

m_default_object_config

SLAPrintObjectConfig Slic3r::SLAPrint::m_default_object_config

private

Referenced by apply(), and default_object_config().

m_full_print_config

DynamicPrintConfig Slic3r::PrintBase::m_full_print_config

protectedinherited

Referenced by Slic3r::SLAPrint::apply().

m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

m_material_config

SLAMaterialConfig Slic3r::SLAPrint::m_material_config

private

Referenced by Slic3r::SLAPrint::Steps::Steps(), apply(), material_config(), and validate().

m_model

Model Slic3r::PrintBase::m_model

protectedinherited

Referenced by Slic3r::SLAPrint::apply(), and Slic3r::SLAPrint::clear().

m_no_check

bool Slic3r::PrintBase::m_no_check

protectedinherited

m_objects

PrintObjects Slic3r::SLAPrint::m_objects

private

Referenced by Slic3r::SLAPrint::Steps::Steps(), apply(), clear(), empty(), finalize(), get_object(), get_print_object_by_model_object_id(), invalidate_state_by_config_options(), is_step_done(), objects(), print_object_ids(), process(), set_task(), and validate().

m_ori_full_print_config

DynamicPrintConfig Slic3r::PrintBase::m_ori_full_print_config

protectedinherited

m_placeholder_parser

PlaceholderParser Slic3r::PrintBase::m_placeholder_parser

protectedinherited

Referenced by Slic3r::SLAPrint::apply().

m_plate_index

int Slic3r::PrintBase::m_plate_index

protectedinherited

{ 0 };

m_plate_name

std::string Slic3r::PrintBase::m_plate_name

protectedinherited

m_print_config

SLAPrintConfig Slic3r::SLAPrint::m_print_config

private

Referenced by apply(), output_filename(), and print_config().

m_print_statistics

SLAPrintStatistics Slic3r::SLAPrint::m_print_statistics

private

Referenced by apply(), and print_statistics().

m_printer

SLAArchive* Slic3r::SLAPrint::m_printer = nullptr

private

Referenced by apply(), and set_printer().

m_printer_config

SLAPrinterConfig Slic3r::SLAPrint::m_printer_config

private

Referenced by apply(), printer_config(), and validate().

m_printer_input

std::vector<PrintLayer> Slic3r::SLAPrint::m_printer_input

private

Referenced by apply(), and print_layers().

m_report_status

class Slic3r::SLAPrint::StatusReporter Slic3r::SLAPrint::m_report_status

private

Referenced by process().

m_state

PrintState<SLAPrintStep, COUNT> Slic3r::PrintBaseWithState< SLAPrintStep, COUNT >::m_state

privateinherited

m_state_mutex

std::mutex Slic3r::PrintBase::m_state_mutex

mutableprivateinherited

m_status_callback

status_callback_type Slic3r::PrintBase::m_status_callback

protectedinherited

m_stepmask

std::vector<bool> Slic3r::SLAPrint::m_stepmask

private

Referenced by SLAPrint(), finalize(), process(), and set_task().

PrintTryCancel

friend Slic3r::PrintBase::PrintTryCancel

privateinherited

s_last_id

size_t Slic3r::ObjectBase::s_last_id

staticprivateinherited

SLAPrintObject

friend Slic3r::SLAPrint::SLAPrintObject

private

Referenced by apply(), Slic3r::SLAPrint::Steps::apply_printer_corrections(), clear(), Slic3r::SLAPrint::Steps::drill_holes(), Slic3r::SLAPrint::Steps::execute(), finalize(), Slic3r::SLAPrint::Steps::generate_pad(), get_object(), get_print_object_by_model_object_id(), Slic3r::SLAPrint::Steps::hollow_model(), Slic3r::SLAPrint::Steps::initialize_printer_input(), invalidate_state_by_config_options(), is_step_done(), print_object_ids(), process(), set_task(), Slic3r::SLAPrint::Steps::slice_model(), Slic3r::SLAPrint::Steps::slice_supports(), Slic3r::SLAPrint::Steps::support_points(), Slic3r::SLAPrint::Steps::support_tree(), and validate().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SLAPrint.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SLAPrint.cpp