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

#include <src/libslic3r/SLAPrint.hpp>

Inheritance diagram for Slic3r::SLAPrint:

Collaboration diagram for Slic3r::SLAPrint:

Classes
class	PrintLayer

class	StatusReporter

class	Steps

Public Types
using	PrintStepEnum = SLAPrintStep

enum	ApplyStatus { APPLY_STATUS_UNCHANGED , APPLY_STATUS_CHANGED , APPLY_STATUS_INVALIDATED }

enum	CancelStatus { NOT_CANCELED = 0 , CANCELED_BY_USER = 1 , CANCELED_INTERNAL = 2 }

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

typedef std::function< void()>	cancel_callback_type

using	Timestamp = uint64_t

Public Member Functions
	SLAPrint ()=default

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) override

void	set_task (const TaskParams &params) override

void	process () override

void	finalize () override

void	cleanup () 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

std::string	validate (std::vector< std::string > *warnings=nullptr) const override

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

void	export_print (const std::string &fname, const std::string &projectname="")

void	export_print (const std::string &fname, const ThumbnailsList &thumbnails, const std::string &projectname="")

bool	is_step_done (PrintStepEnum step) const

PrintStateBase::StateWithTimeStamp	step_state_with_timestamp (PrintStepEnum step) const

PrintStateBase::StateWithWarnings	step_state_with_warnings (PrintStepEnum step) const

const Model &	model () const

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)

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

ObjectID	id () const

virtual Timestamp	timestamp () const

Static Public Attributes
static constexpr const size_t	PrintStepEnumSize

Protected Member Functions
bool	set_started (PrintStepEnum step)

PrintStateBase::TimeStamp	set_done (PrintStepEnum step)

bool	invalidate_steps (StepTypeIterator step_begin, StepTypeIterator step_end)

bool	invalidate_steps (std::initializer_list< PrintStepEnum > il)

bool	invalidate_all_steps ()

bool	is_step_started_unguarded (PrintStepEnum step) const

bool	is_step_done_unguarded (PrintStepEnum step) const

void	active_step_add_warning (PrintStateBase::WarningLevel warning_level, const std::string &message, int message_id=0)

void	set_task_impl (const TaskParams &params, std::vector< PrintObject * > &print_objects)

void	finalize_impl (std::vector< PrintObject * > &print_objects)

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)

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

PlaceholderParser	m_placeholder_parser

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)

template<class Archive >
void	serialize (Archive &ar)

Static Private Member Functions
static ObjectID	generate_new_id ()

template<class Archive >
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< PrintLayer >	m_printer_input

std::unique_ptr< SLAArchiveWriter >	m_archiver

SLAPrintStatistics	m_print_statistics

class Slic3r::SLAPrint::StatusReporter	m_report_status

friend	SLAPrintObject

PrintState< PrintStepEnum, 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 = 0

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

◆ PrintStepEnum

using Slic3r::PrintBaseWithState< SLAPrintStep , COUNT >::PrintStepEnum = SLAPrintStep

inherited

◆ status_callback_type

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

inherited

◆ Timestamp

using Slic3r::ObjectBase::Timestamp = uint64_t

inherited

Member Enumeration Documentation

◆ ApplyStatus

enum Slic3r::PrintBase::ApplyStatus

inherited

Enumerator
APPLY_STATUS_UNCHANGED
APPLY_STATUS_CHANGED
APPLY_STATUS_INVALIDATED

                     {
        // 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

Enumerator
NOT_CANCELED
CANCELED_BY_USER
CANCELED_INTERNAL

                    {
    // 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 ( )

default

◆ ~SLAPrint()

virtual Slic3r::SLAPrint::~SLAPrint ( )

inlineoverridevirtual

450{ this->clear(); }

Slic3r::SLAPrint::clear

void clear() override

Definition SLAPrint.cpp:149

Member Function Documentation

◆ active_step_add_warning()

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

inlineprotectedinherited

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

◆ apply()

SLAPrint::ApplyStatus Slic3r::SLAPrint::apply	(	const Model &	model,
		DynamicPrintConfig	config
	)

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);
    config.option("physical_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());
        m_placeholder_parser.set("physical_printer_preset", config.option("physical_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_archiver || !printer_diff.empty())
        m_archiver = SLAArchiveWriter::create(m_printer_config.sla_archive_format.value.c_str(), 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,
                                           ModelVolumeType::NEGATIVE_VOLUME,
                                           ModelVolumeType::SUPPORT_ENFORCER,
                                           ModelVolumeType::SUPPORT_BLOCKER});
            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::PlaceholderParser::apply_config(), Slic3r::PrintBase::APPLY_STATUS_CHANGED, Slic3r::PrintBase::APPLY_STATUS_INVALIDATED, Slic3r::PrintBase::APPLY_STATUS_UNCHANGED, Slic3r::ModelConfig::assign_config(), Slic3r::PrintBase::call_cancel_callback(), Slic3r::check_model_ids_equal(), Slic3r::check_model_ids_validity(), Slic3r::ModelObject::clear_instances(), Slic3r::ConfigOption::clone(), Slic3r::ModelObject::config, Slic3r::PlaceholderParser::config_diff(), Slic3r::SLAArchiveWriter::create(), Slic3r::ModelObjectStatus::Deleted, Slic3r::PrintObjectStatus::Deleted, Slic3r::diff(), Slic3r::ModelConfig::get(), Slic3r::ObjectID::id, Slic3r::ObjectBase::id(), Slic3r::ModelObjectStatus::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(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::isApprox(), m_archiver, m_default_object_config, Slic3r::PrintBase::m_full_print_config, m_material_config, Slic3r::PrintBase::m_model, m_objects, Slic3r::PrintBase::m_placeholder_parser, m_print_config, m_print_statistics, m_printer_config, m_printer_input, Slic3r::PrintBase::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::NEGATIVE_VOLUME, Slic3r::ModelObjectStatus::New, Slic3r::Model::objects, Slic3r::ModelObjectStatus::Old, Slic3r::ConfigBase::option(), Slic3r::PrintObjectStatus::Reused, Slic3r::PlaceholderParser::set(), 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::SLAPrintObjectConfig, Slic3r::slapsMergeSlicesAndEval, Slic3r::PrintBase::state_mutex(), Slic3r::PrintObjectStatus::status, Slic3r::SUPPORT_BLOCKER, Slic3r::SUPPORT_ENFORCER, Slic3r::ModelConfig::timestamp_matches(), Slic3r::SLAPrintObject::trafo(), 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

Reimplemented in Slic3r::Model, Slic3r::ModelObject, and Slic3r::ModelVolume.

79{ this->set_new_unique_id(); }

Slic3r::ObjectBase::set_new_unique_id

void set_new_unique_id()

Definition ObjectID.hpp:73

References Slic3r::ObjectBase::set_new_unique_id().

Here is the call graph for this function:

◆ call_cancel_callback()

void Slic3r::PrintBase::call_cancel_callback ( )

inlineprotectedinherited

536{ m_cancel_callback(); }

Slic3r::PrintBase::m_cancel_callback

cancel_callback_type m_cancel_callback

Definition PrintBase.hpp:564

References Slic3r::PrintBase::m_cancel_callback.

Referenced by apply(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl().

Here is the caller graph for this function:

◆ cancel()

void Slic3r::PrintBase::cancel ( )

inlineinherited

515{ m_cancel_status = CANCELED_BY_USER; }

Slic3r::PrintBase::m_cancel_status

std::atomic< CancelStatus > m_cancel_status

Definition PrintBase.hpp:561

References Slic3r::PrintBase::CANCELED_BY_USER, and Slic3r::PrintBase::m_cancel_status.

Referenced by Slic3r::BackgroundSlicingProcess::stop().

Here is the caller graph for this function:

◆ cancel_callback()

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

inlineprotectedinherited

535{ return m_cancel_callback; }

References Slic3r::PrintBase::m_cancel_callback.

Referenced by Slic3r::PrintObjectBase::cancel_callback(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_all_steps(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_step(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_steps(), and Slic3r::PrintBase::set_cancel_callback().

Here is the caller graph for this function:

◆ cancel_internal()

void Slic3r::PrintBase::cancel_internal ( )

inlineinherited

516{ m_cancel_status = CANCELED_INTERNAL; }

References Slic3r::PrintBase::CANCELED_INTERNAL, and Slic3r::PrintBase::m_cancel_status.

Referenced by Slic3r::BackgroundSlicingProcess::stop_internal().

Here is the caller graph for this function:

◆ cancel_status()

CancelStatus Slic3r::PrintBase::cancel_status ( ) const

inlineinherited

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

References Slic3r::PrintBase::m_cancel_status.

Referenced by Slic3r::BackgroundSlicingProcess::thread_proc().

Here is the caller graph for this function:

◆ canceled()

bool Slic3r::PrintBase::canceled ( ) const

inlineinherited

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

References Slic3r::PrintBase::m_cancel_status, and Slic3r::PrintBase::NOT_CANCELED.

Referenced by Slic3r::SLAPrint::Steps::canceled(), Slic3r::BackgroundSlicingProcess::execute_ui_task(), Slic3r::SLAPrint::Steps::generate_pad(), Slic3r::SLAPrint::Steps::hollow_model(), Slic3r::SLAPrint::Steps::rasterize(), Slic3r::SLAPrint::Steps::slice_supports(), Slic3r::SLAPrint::Steps::support_tree(), Slic3r::BackgroundSlicingProcess::thread_proc(), and Slic3r::BackgroundSlicingProcess::throw_if_canceled().

Here is the caller graph for this function:

◆ cleanup()

void Slic3r::SLAPrint::cleanup ( )

inlineoverridevirtual

Implements Slic3r::PrintBase.

462{}

◆ 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::Model::clear_objects(), Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::invalidate_all_steps(), Slic3r::PrintBase::m_model, m_objects, and Slic3r::PrintBase::state_mutex().

Here is the call graph for this function:

◆ copy_id()

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

inlineprotectedinherited

76{ m_id = rhs.id(); }

Slic3r::ObjectBase::m_id

ObjectID m_id

Definition ObjectID.hpp:82

Slic3r::ObjectID::id

size_t id

Definition ObjectID.hpp:37

References Slic3r::ObjectBase::id(), and Slic3r::ObjectBase::m_id.

Referenced by Slic3r::CutObjectBase::copy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ default_object_config()

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

inline

485{ return m_default_object_config; }

References Slic3r::SLAPrintObjectConfig.

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.

455{ return m_objects.empty(); }

◆ export_print() [1/2]

void Slic3r::SLAPrint::export_print	(	const std::string &	fname,
		const std::string &	projectname = `""`
	)

inline

    {
        ThumbnailsList thumbnails; //empty thumbnail list
        export_print(fname, thumbnails, projectname);
    }

Referenced by Slic3r::BackgroundSlicingProcess::prepare_upload(), Slic3r::BackgroundSlicingProcess::process_sla(), and Slic3r::CLI::run().

Here is the caller graph for this function:

◆ export_print() [2/2]

void Slic3r::SLAPrint::export_print	(	const std::string &	fname,
		const ThumbnailsList &	thumbnails,
		const std::string &	projectname = `""`
	)

{
    if (m_archiver)
        m_archiver->export_print(fname, *this, thumbnails, projectname);
    else {
        throw ExportError(format(_u8L("Unknown archive format: %s"), m_printer_config.sla_archive_format.value));
    }
}

References _u8L, Slic3r::format(), m_archiver, and m_printer_config.

Here is the call graph for this function:

◆ finalize()

void Slic3r::SLAPrint::finalize ( )

inlineoverridevirtual

Implements Slic3r::PrintBase.

461{ PrintBaseWithState<SLAPrintStep, slapsCount>::finalize_impl(m_objects); }

Slic3r::PrintBaseWithState::finalize_impl

void finalize_impl(std::vector< PrintObject * > &print_objects)

Definition PrintBase.hpp:714

◆ finalize_impl()

void Slic3r::PrintBaseWithState< SLAPrintStep , COUNT >::finalize_impl ( std::vector< PrintObject * > & print_objects )

inlineprotectedinherited

    {
        // Grab the lock for the Print / PrintObject milestones.
        std::scoped_lock<std::mutex> lock(this->state_mutex());
        for (auto *po : print_objects)
            po->finalize_impl();
        m_state.enable_all_unguarded(true);
        m_state.mark_canceled_unguarded();
    }

◆ finished()

bool Slic3r::SLAPrint::finished ( ) const

inlineoverridevirtual

Implements Slic3r::PrintBase.

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

Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::is_step_done

bool is_step_done(PrintStepEnum step) const

Definition PrintBase.hpp:583

Slic3r::SLAPrint::is_step_done

bool is_step_done(SLAPrintObjectStep step) const

Definition SLAPrint.cpp:822

Slic3r::slaposSliceSupports

@ slaposSliceSupports

Definition SLAPrint.hpp:35

Slic3r::slapsRasterize

@ slapsRasterize

Definition SLAPrint.hpp:23

References Slic3r::slaposSliceSupports, and Slic3r::slapsRasterize.

Referenced by output_filename().

Here is the caller graph for this function:

◆ full_print_config()

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

inlineinherited

523{ return m_full_print_config; }

References Slic3r::PrintBase::m_full_print_config.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::append_full_config(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::fill_header(), Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf(), Slic3r::anonymous_namespace{SL1.cpp}::fill_slicerconf(), Slic3r::BackgroundSlicingProcess::finalize_gcode(), Slic3r::BackgroundSlicingProcess::prepare_upload(), Slic3r::BackgroundSlicingProcess::process_sla(), and Slic3r::CLI::run().

Here is the caller graph for this function:

◆ generate_new_id()

static ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

84{ return ObjectID(++ s_last_id); }

Slic3r::ObjectBase::s_last_id

static size_t s_last_id

Definition ObjectID.hpp:85

References Slic3r::ObjectBase::s_last_id.

Referenced by Slic3r::ObjectBase::set_new_unique_id().

Here is the caller graph for this function:

◆ 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;
    }

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

Here is the caller graph for this function:

◆ 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;
    }

Referenced by Slic3r::GUI::get_arrange_poly(), Slic3r::GUI::CommonGizmosDataObjects::SelectionInfo::on_update(), Slic3r::GUI::processed_objects_idxs(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the caller graph for this function:

◆ id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

55{ return m_id; }

References Slic3r::ObjectBase::m_id.

◆ invalidate_all_steps()

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

inlineprotectedinherited

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

Slic3r::PrintBase::cancel_callback

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

Definition PrintBase.hpp:535

Slic3r::PrintState::invalidate_all

bool invalidate_all(CancelationCallback cancel)

Definition PrintBase.hpp:279

◆ 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",
        "material_print_speed",
        "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",
        "sla_archive_format",
        "sla_output_precision"
    };
 
    static std::unordered_set<std::string> steps_ignore = {
        "bed_shape",
        "max_print_height",
        "printer_technology",
        "output_filename_format",
        "fast_tilt_time",
        "slow_tilt_time",
        "high_viscosity_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, 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(), and invalidate_state_by_config_options().

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< PrintStepEnum > il )

inlineprotectedinherited

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

Slic3r::PrintState::invalidate_multiple

bool invalidate_multiple(StepTypeIterator step_begin, StepTypeIterator step_end, CancelationCallback cancel)

Definition PrintBase.hpp:249

◆ invalidate_steps() [2/2]

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

inlineprotectedinherited

599 { 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 ( PrintStepEnum step ) const

inlineinherited

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

Slic3r::PrintState::is_done

bool is_done(StepType step, std::mutex &mtx) const

Definition PrintBase.hpp:134

◆ 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, and Slic3r::PrintBase::state_mutex().

Here is the call graph for this function:

◆ is_step_done_unguarded()

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

inlineprotectedinherited

606{ return m_state.is_done_unguarded(step); }

Slic3r::PrintState::is_done_unguarded

bool is_done_unguarded(StepType step) const

Definition PrintBase.hpp:146

◆ is_step_started_unguarded()

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

inlineprotectedinherited

605{ return m_state.is_started_unguarded(step); }

Slic3r::PrintState::is_started_unguarded

bool is_started_unguarded(StepType step) const

Definition PrintBase.hpp:142

◆ load_and_construct()

template<class Archive >

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

inlinestaticprivateinherited

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

References Slic3r::ObjectBase::id().

Here is the call graph for this function:

◆ make_try_cancel()

PrintTryCancel Slic3r::PrintBase::make_try_cancel ( ) const

inlineprotectedinherited

546{ return PrintTryCancel(this); }

Slic3r::PrintBase::PrintTryCancel

friend PrintTryCancel

Definition PrintBase.hpp:571

References Slic3r::PrintBase::PrintTryCancel.

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

Here is the caller graph for this function:

◆ material_config()

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

inline

484{ return m_material_config; }

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::GUI::Preview::load_print_as_sla(), 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

433{ return m_model; }

References Slic3r::PrintBase::m_model.

Referenced by Slic3r::ToolOrdering::ToolOrdering(), Slic3r::GUI::Plater::priv::actualize_object_warnings(), apply(), Slic3r::ToolOrdering::assign_custom_gcodes(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::sort_object_instances_by_model_order(), and Slic3r::DoExport::validate_custom_gcode().

Here is the caller graph for this function:

◆ objects()

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

inline

468{ return m_objects; }

Referenced by Slic3r::GUI::GLCanvas3D::_load_sla_shells(), Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::GUI::MainFrame::can_export_supports(), Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf(), Slic3r::GUI::GLGizmoSlaSupports::get_data_from_backend(), Slic3r::GUI::GLGizmoSlaSupports::has_backend_supports(), Slic3r::GUI::Preview::load_print_as_sla(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the caller graph for this function:

◆ output_filename() [1/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();
    std::string default_ext = get_default_extension(m_printer_config.sla_archive_format.value.c_str());
    if (default_ext.empty())
        default_ext = "sl1";
 
    default_ext.insert(default_ext.begin(), '.');
 
    config.set_key_value("default_output_extension",
                         new ConfigOptionString(default_ext));
 
    return this->PrintBase::output_filename(m_print_config.output_filename_format.value, default_ext, filename_base, &config);
}

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

Here is the call graph for this function:

◆ output_filename() [2/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(SLIC3R_VERSION)));
    PlaceholderParser::update_timestamp(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 = boost::filesystem::change_extension(filename, default_ext);
        return filename.string();
    } catch (std::runtime_error &err) {
        throw Slic3r::PlaceholderParserError(_u8L("Failed processing of the output_filename_format template.") + "\n" + err.what());
    }
}

References _u8L, Slic3r::format(), Slic3r::ConfigBase::opt_string(), Slic3r::PrintBase::placeholder_parser(), Slic3r::PlaceholderParser::process(), Slic3r::DynamicConfig::set_key_value(), Slic3r::PrintBase::update_object_placeholders(), and Slic3r::PlaceholderParser::update_timestamp().

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;
}

References Slic3r::PrintBase::m_model, Slic3r::PrintBase::output_filename(), and Slic3r::Model::propose_export_file_name_and_path().

Referenced by Slic3r::Print::export_gcode(), Slic3r::BackgroundSlicingProcess::output_filepath_for_project(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ placeholder_parser()

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

inlineinherited

522{ return m_placeholder_parser; }

References Slic3r::PrintBase::m_placeholder_parser.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::PrintBase::output_filename().

Here is the caller graph for this function:

◆ print_config()

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

inline

482{ return m_print_config; }

References Slic3r::SLAPrintConfig.

◆ print_layers()

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

inline

539{ return 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.

◆ print_statistics()

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

inline

495{ return m_print_statistics; }

Referenced by Slic3r::anonymous_namespace{AnycubicSLA.cpp}::fill_header(), Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf(), Slic3r::SLAPrint::Steps::merge_slices_and_eval_stats(), output_filename(), Slic3r::BackgroundSlicingProcess::prepare_upload(), Slic3r::BackgroundSlicingProcess::process_sla(), Slic3r::CLI::run(), and Slic3r::GUI::Preview::update_layers_slider().

Here is the caller graph for this function:

◆ printer_config()

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

inline

483{ return m_printer_config; }

References Slic3r::SLAPrinterConfig.

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 ( )

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 = {
        slaposAssembly, 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->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);
 
    st = Steps::max_objstatus;
    for(SLAPrintStep currentstep : print_steps) {
        throw_if_canceled();
 
        if (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, _u8L("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 _u8L, Slic3r::SLAPrint::Steps::execute(), Benchmark::getElapsedSec(), Slic3r::SLAPrint::Steps::label(), m_objects, m_report_status, 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::slaposAssembly, Slic3r::slaposCount, Slic3r::slaposDrillHoles, Slic3r::slaposHollowing, Slic3r::slaposObjectSlice, Slic3r::slaposPad, Slic3r::slaposSliceSupports, Slic3r::slaposSupportPoints, Slic3r::slaposSupportTree, Slic3r::slapsCount, Slic3r::slapsMergeSlicesAndEval, Slic3r::slapsRasterize, Benchmark::start(), Benchmark::stop(), and Slic3r::PrintBase::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(), Slic3r::GUI::GLCanvas3D::reload_scene(), 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

518{ m_cancel_status = NOT_CANCELED; }

References Slic3r::PrintBase::m_cancel_status, and Slic3r::PrintBase::NOT_CANCELED.

Referenced by Slic3r::PrintBase::PrintBase(), and Slic3r::BackgroundSlicingProcess::thread_proc().

Here is the caller graph for this function:

◆ serialize()

template<class Archive >

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

inlineprivateinherited

92{ ar(m_id); }

References Slic3r::ObjectBase::m_id.

◆ set_cancel_callback()

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

inlineinherited

501{ m_cancel_callback = cancel_callback; }

References Slic3r::PrintBase::cancel_callback(), and Slic3r::PrintBase::m_cancel_callback.

Referenced by Slic3r::BackgroundSlicingProcess::start(), Slic3r::BackgroundSlicingProcess::stop(), and Slic3r::BackgroundSlicingProcess::stop_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_done()

PrintStateBase::TimeStamp Slic3r::PrintBaseWithState< SLAPrintStep , COUNT >::set_done ( PrintStepEnum 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;
  }

◆ set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

74{ m_id = 0; }

References Slic3r::ObjectBase::m_id.

Referenced by Slic3r::CutObjectBase::invalidate().

Here is the caller graph for this function:

◆ set_new_unique_id()

void Slic3r::ObjectBase::set_new_unique_id ( )

inlineprotectedinherited

73{ m_id = generate_new_id(); }

Slic3r::ObjectBase::generate_new_id

static ObjectID generate_new_id()

Definition ObjectID.hpp:84

References Slic3r::ObjectBase::generate_new_id(), and Slic3r::ObjectBase::m_id.

Referenced by Slic3r::ModelVolume::ModelVolume(), Slic3r::Model::assign_new_unique_ids_recursive(), Slic3r::ObjectBase::assign_new_unique_ids_recursive(), Slic3r::ModelObject::assign_new_unique_ids_recursive(), Slic3r::CutObjectBase::init(), Slic3r::ModelMaterial::set_new_unique_id(), Slic3r::ModelObject::set_new_unique_id(), and Slic3r::ModelVolume::set_new_unique_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_started()

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

inlineprotectedinherited

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

Slic3r::PrintState::set_started

bool set_started(StepType step, std::mutex &mtx, ThrowIfCanceled throw_if_canceled)

Definition PrintBase.hpp:169

◆ set_status()

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

inlineinherited

                                                                                                                         {
    if (m_status_callback) m_status_callback(SlicingStatus(percent, message, flags));
        else printf("%d => %s\n", percent, message.c_str());
    }

References Slic3r::PrintBase::m_status_callback.

Referenced by Slic3r::Print::alert_when_supports_needed(), Slic3r::Print::export_gcode(), Slic3r::BackgroundSlicingProcess::finalize_gcode(), Slic3r::PrintObject::make_perimeters(), Slic3r::SLAPrint::StatusReporter::operator()(), Slic3r::BackgroundSlicingProcess::prepare_upload(), Slic3r::Print::process(), Slic3r::BackgroundSlicingProcess::process_fff(), and Slic3r::BackgroundSlicingProcess::process_sla().

Here is the caller graph for this function:

◆ set_status_callback()

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

inlineinherited

490{ m_status_callback = cb; }

References Slic3r::PrintBase::m_status_callback.

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

◆ set_status_default()

void Slic3r::PrintBase::set_status_default ( )

inlineinherited

486{ m_status_callback = nullptr; }

References Slic3r::PrintBase::m_status_callback.

◆ set_status_silent()

void Slic3r::PrintBase::set_status_silent ( )

inlineinherited

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

References Slic3r::PrintBase::m_status_callback.

◆ set_task()

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

inlineoverridevirtual

Implements Slic3r::PrintBase.

459{ PrintBaseWithState<SLAPrintStep, slapsCount>::set_task_impl(params, m_objects); }

Slic3r::PrintBaseWithState::set_task_impl

void set_task_impl(const TaskParams &params, std::vector< PrintObject * > &print_objects)

Definition PrintBase.hpp:620

◆ set_task_impl()

void Slic3r::PrintBaseWithState< SLAPrintStep , COUNT >::set_task_impl	(	const TaskParams &	params,
		std::vector< PrintObject * > &	print_objects
	)

inlineprotectedinherited

    {
        static constexpr const auto PrintObjectStepEnumSize = int(PrintObject::PrintObjectStepEnumSize);
        using                       PrintObjectStepEnum     = typename PrintObject::PrintObjectStepEnum;
        // 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 = PrintObjectStepEnumSize;
 
        if (params.single_model_object.valid()) {
            // Find the print object to be processed with priority.
            PrintObject *print_object = nullptr;
            size_t       idx_print_object = 0;
            for (; idx_print_object < print_objects.size(); ++ idx_print_object)
                if (print_objects[idx_print_object]->model_object()->id() == params.single_model_object) {
                    print_object = print_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->is_step_enabled_unguarded(PrintObjectStepEnum(istep)))
                    // Step was skipped, cancel.
                    break;
                if (print_object->is_step_started_unguarded(PrintObjectStepEnum(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 (PrintObject *po : print_objects)
                    for (size_t istep = 0; istep < PrintObjectStepEnumSize; ++ istep)
                        po->enable_step_unguarded(PrintObjectStepEnum(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(print_objects.front(), print_objects[idx_print_object]);
            }
            // and set the steps for the current object.
            for (int istep = 0; istep < n_object_steps; ++ istep)
                print_object->enable_step_unguarded(PrintObjectStepEnum(istep), true);
            for (int istep = n_object_steps; istep < PrintObjectStepEnumSize; ++ istep)
                print_object->enable_step_unguarded(PrintObjectStepEnum(istep), false);
        } else {
            // Slicing all objects.
            bool running = false;
            for (PrintObject *print_object : print_objects)
                for (int istep = 0; istep < n_object_steps; ++ istep) {
                    if (! print_object->is_step_enabled_unguarded(PrintObjectStepEnum(istep))) {
                        // Step may have been skipped. Restart.
                        goto loop_end;
                    }
                    if (print_object->is_step_started_unguarded(PrintObjectStepEnum(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 PrintObjects and Print now.
                        running = true;
                        goto loop_end;
                    }
                }
        loop_end:
            if (! running)
                this->call_cancel_callback();
            for (PrintObject *po : print_objects) {
                for (int istep = 0; istep < n_object_steps; ++ istep)
                    po->enable_step_unguarded(PrintObjectStepEnum(istep), true);
                for (int istep = n_object_steps; istep < PrintObjectStepEnumSize; ++ istep)
                    po->enable_step_unguarded(PrintObjectStepEnum(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 < PrintStepEnumSize; ++ istep)
                m_state.enable_unguarded(PrintStepEnum(istep), false);
        }
    }

◆ sla_trafo()

Transform3d Slic3r::SLAPrint::sla_trafo ( const ModelObject & model_object ) const

{
    ModelInstance &model_instance = *model_object.instances.front();
    auto trafo = Transform3d::Identity();
    trafo.translate(Vec3d{ 0., 0., model_instance.get_offset().z() * this->relative_correction().z() });
    trafo.linear() = Eigen::DiagonalMatrix<double, 3, 3>(this->relative_correction()) * model_instance.get_matrix().linear();
    if (model_instance.is_left_handed())
        trafo = Eigen::Scaling(Vec3d(-1., 1., 1.)) * trafo;
    return trafo;
}

References Slic3r::ModelInstance::get_matrix(), Slic3r::ModelInstance::get_offset(), Eigen::Transform< double, 3, Eigen::Affine, Eigen::DontAlign >::Identity(), Slic3r::ModelObject::instances, Slic3r::ModelInstance::is_left_handed(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::linear(), relative_correction(), and Eigen::Scaling().

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

534{ return m_state_mutex; }

Slic3r::PrintBase::m_state_mutex

std::mutex m_state_mutex

Definition PrintBase.hpp:569

References Slic3r::PrintBase::m_state_mutex.

Here is the caller graph for this function:

◆ status_update_warnings()

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

protectedinherited

{
    if (m_status_callback) {
        auto status = print_object ? SlicingStatus(*print_object, step) : SlicingStatus(*this, step);
        m_status_callback(status);
    }
    else if (! message.empty())
        printf("%s warning: %s\n",  print_object ? "print_object" : "print", message.c_str());
}

References Slic3r::PrintBase::m_status_callback.

Referenced by Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::active_step_add_warning(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_done(), and Slic3r::PrintObjectBase::status_update_warnings().

Here is the caller graph for this function:

◆ step_state_with_timestamp()

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

inlineinherited

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

Slic3r::PrintState::state_with_timestamp

StateWithTimeStamp state_with_timestamp(StepType step, std::mutex &mtx) const

Definition PrintBase.hpp:118

◆ step_state_with_warnings()

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

inlineinherited

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

Slic3r::PrintState::state_with_warnings

StateWithWarnings state_with_warnings(StepType step, std::mutex &mtx) const

Definition PrintBase.hpp:124

◆ technology()

PrinterTechnology Slic3r::SLAPrint::technology ( ) const

inlineoverridevirtualnoexcept

Implements Slic3r::PrintBase.

452{ return ptSLA; }

Slic3r::ptSLA

@ ptSLA

Definition Config.hpp:209

References Slic3r::ptSLA.

◆ throw_if_canceled()

void Slic3r::PrintBase::throw_if_canceled ( ) const

inlineprotectedinherited

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

References Slic3r::PrintBase::m_cancel_status.

Referenced by Slic3r::GCode::_do_export(), Slic3r::Print::_make_skirt(), Slic3r::Print::_make_wipe_tower(), Slic3r::SLAPrint::Steps::generate_pad(), Slic3r::SLAPrint::Steps::hollow_model(), Slic3r::PrintObject::make_perimeters(), Slic3r::PrintTryCancel::operator()(), process(), Slic3r::GCode::process_layers(), Slic3r::GCode::process_layers(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_done(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_started(), Slic3r::PrintObject::slice_support_volumes(), Slic3r::SLAPrint::Steps::slice_supports(), Slic3r::PrintObject::slice_volumes(), Slic3r::SLAPrint::Steps::support_points(), Slic3r::SLAPrint::Steps::support_tree(), and Slic3r::SLAPrint::Steps::throw_if_canceled().

Here is the caller graph for this function:

◆ timestamp()

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

inlinevirtualinherited

Reimplemented in Slic3r::ModelConfigObject, and Slic3r::ObjectWithTimestamp.

60{ return 0; }

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

Here is the caller graph for this function:

◆ 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::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;
          // 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));
    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));
    }
}

References Slic3r::ModelInstance::get_scaling_factor(), Slic3r::PrintBase::m_model, Slic3r::Model::objects, Slic3r::DynamicConfig::set_key_value(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::PrintBase::output_filename().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate()

std::string Slic3r::SLAPrint::validate ( std::vector< std::string > * warnings = 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 _u8L("Cannot proceed without support points! "
                     "Add support points or disable support generation.");
 
        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 _u8L(
                "Elevation is too low for object. Use the \"Pad around "
                "object\" feature to print the object without elevation.");
        
        if(supports_en && builtinpad.enabled &&
           cfg.pillar_base_safety_distance_mm < builtinpad.object_gap_mm) {
            return _u8L(
                "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.");
        }
        
        std::string pval = padcfg.validate();
        if (!pval.empty()) return pval;
    }
 
    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 _u8L("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 _u8L("Initial exposition time is out of printer profile bounds.");
 
    return "";
}

References _u8L, Slic3r::ModelObject::config, Slic3r::sla::PadConfig::embed_object, Slic3r::sla::PadConfig::EmbedObject::enabled, Slic3r::sla::SupportTreeConfig::head_fullwidth(), 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, Slic3r::sla::UserModified, and Slic3r::sla::PadConfig::validate().

Here is the call graph for this function:

Member Data Documentation

◆ m_archiver

std::unique_ptr<SLAArchiveWriter> Slic3r::SLAPrint::m_archiver

private

Referenced by apply(), and export_print().

◆ m_cancel_callback

cancel_callback_type Slic3r::PrintBase::m_cancel_callback = [](){}

privateinherited

Referenced by Slic3r::PrintBase::call_cancel_callback(), Slic3r::PrintBase::cancel_callback(), and Slic3r::PrintBase::set_cancel_callback().

◆ m_cancel_status

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

privateinherited

Referenced by Slic3r::PrintBase::cancel(), Slic3r::PrintBase::cancel_internal(), Slic3r::PrintBase::cancel_status(), Slic3r::PrintBase::canceled(), Slic3r::PrintBase::restart(), and Slic3r::PrintBase::throw_if_canceled().

◆ m_default_object_config

SLAPrintObjectConfig Slic3r::SLAPrint::m_default_object_config

private

Referenced by apply().

◆ m_full_print_config

DynamicPrintConfig Slic3r::PrintBase::m_full_print_config

protectedinherited

Referenced by apply(), and Slic3r::PrintBase::full_print_config().

◆ m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

Referenced by Slic3r::ObjectBase::copy_id(), Slic3r::ObjectBase::id(), Slic3r::ObjectBase::serialize(), Slic3r::ObjectBase::set_invalid_id(), and Slic3r::ObjectBase::set_new_unique_id().

◆ m_material_config

SLAMaterialConfig Slic3r::SLAPrint::m_material_config

private

Referenced by apply(), and validate().

◆ m_model

Model Slic3r::PrintBase::m_model

protectedinherited

Referenced by apply(), Slic3r::Print::clear(), clear(), Slic3r::PrintBase::model(), Slic3r::PrintBase::output_filepath(), and Slic3r::PrintBase::update_object_placeholders().

◆ m_objects

PrintObjects Slic3r::SLAPrint::m_objects

private

Referenced by apply(), clear(), invalidate_state_by_config_options(), is_step_done(), print_object_ids(), process(), and validate().

◆ m_placeholder_parser

PlaceholderParser Slic3r::PrintBase::m_placeholder_parser

protectedinherited

Referenced by apply(), and Slic3r::PrintBase::placeholder_parser().

◆ m_print_config

SLAPrintConfig Slic3r::SLAPrint::m_print_config

private

Referenced by apply(), and output_filename().

◆ m_print_statistics

SLAPrintStatistics Slic3r::SLAPrint::m_print_statistics

private

Referenced by apply().

◆ m_printer_config

SLAPrinterConfig Slic3r::SLAPrint::m_printer_config

private

Referenced by apply(), export_print(), output_filename(), and validate().

◆ m_printer_input

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

private

Referenced by apply().

◆ m_report_status

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

private

Referenced by Slic3r::SLAPrint::Steps::current_status(), process(), and Slic3r::SLAPrint::Steps::report_status().

◆ m_state

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

privateinherited

◆ m_state_mutex

std::mutex Slic3r::PrintBase::m_state_mutex

mutableprivateinherited

Referenced by Slic3r::PrintBase::state_mutex().

◆ m_status_callback

status_callback_type Slic3r::PrintBase::m_status_callback

protectedinherited

Referenced by Slic3r::PrintBase::set_status(), Slic3r::PrintBase::set_status_callback(), Slic3r::PrintBase::set_status_default(), Slic3r::PrintBase::set_status_silent(), and Slic3r::PrintBase::status_update_warnings().

◆ PrintStepEnumSize

constexpr const size_t Slic3r::PrintBaseWithState< SLAPrintStep , COUNT >::PrintStepEnumSize

staticconstexprinherited

◆ PrintTryCancel

friend Slic3r::PrintBase::PrintTryCancel

privateinherited

Referenced by Slic3r::PrintBase::make_try_cancel().

◆ s_last_id

size_t Slic3r::ObjectBase::s_last_id = 0

staticprivateinherited

Referenced by Slic3r::ObjectBase::generate_new_id().

◆ SLAPrintObject

friend Slic3r::SLAPrint::SLAPrintObject

private

Referenced by apply().

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

src/libslic3r/SLAPrint.hpp
src/libslic3r/SLAPrint.cpp

Classes

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ cancel_callback_type

◆ Inherited

◆ PrintStepEnum

◆ status_callback_type

◆ Timestamp

Member Enumeration Documentation

◆ ApplyStatus

◆ CancelStatus

Constructor & Destructor Documentation

◆ SLAPrint()

◆ ~SLAPrint()

Member Function Documentation

◆ active_step_add_warning()

◆ apply()

◆ assign_new_unique_ids_recursive()

◆ call_cancel_callback()

◆ cancel()

◆ cancel_callback()

◆ cancel_internal()

◆ cancel_status()

◆ canceled()

◆ cleanup()

◆ clear()

◆ copy_id()

◆ default_object_config()

◆ empty()

◆ export_print() [1/2]

◆ export_print() [2/2]

◆ finalize()

◆ finalize_impl()

◆ finished()

◆ full_print_config()

◆ generate_new_id()

◆ get_object()

◆ get_print_object_by_model_object_id()

◆ id()

◆ invalidate_all_steps()

◆ invalidate_state_by_config_options()

◆ invalidate_step()

◆ invalidate_steps() [1/2]

◆ invalidate_steps() [2/2]

◆ is_step_done() [1/2]

◆ is_step_done() [2/2]

◆ is_step_done_unguarded()

◆ is_step_started_unguarded()

◆ load_and_construct()

◆ make_try_cancel()

◆ material_config()

◆ model()

◆ objects()

◆ output_filename() [1/2]

◆ output_filename() [2/2]

◆ output_filepath()

◆ placeholder_parser()

◆ print_config()

◆ print_layers()

◆ print_object_ids()

◆ print_statistics()

◆ printer_config()

◆ process()

◆ relative_correction()

◆ restart()

◆ serialize()

◆ set_cancel_callback()

◆ set_done()

◆ set_invalid_id()

◆ set_new_unique_id()