#include <src/libslic3r/Print.hpp>

Inheritance diagram for Slic3r::Print:

Collaboration diagram for Slic3r::Print:

Public Types
using	PrintStepEnum = PrintStep

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
	Print ()=default

virtual	~Print ()

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

std::string	export_gcode (const std::string &path_template, GCodeProcessorResult *result, ThumbnailsGeneratorCallback thumbnail_cb=nullptr)

bool	is_step_done (PrintStep step) const

bool	is_step_done (PrintObjectStep step) const

bool	finished () const override

bool	has_infinite_skirt () const

bool	has_skirt () const

bool	has_brim () const

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

double	skirt_first_layer_height () const

Flow	brim_flow () const

Flow	skirt_flow () const

std::vector< unsigned int >	object_extruders () const

std::vector< unsigned int >	support_material_extruders () const

std::vector< unsigned int >	extruders () const

double	max_allowed_layer_height () const

bool	has_support_material () const

void	auto_assign_extruders (ModelObject *model_object) const

const PrintConfig &	config () const

const PrintObjectConfig &	default_object_config () const

const PrintRegionConfig &	default_region_config () const

SpanOfConstPtrs< PrintObject >	objects () const

PrintObject *	get_object (size_t idx)

const PrintObject *	get_object (size_t idx) const

const PrintObject *	get_print_object_by_model_object_id (ObjectID object_id) const

const PrintObject *	get_object (ObjectID object_id) const

unsigned int	num_object_instances () const

PrintObjectPtrs &	objects_mutable ()

PrintRegionPtrs &	print_regions_mutable ()

const ExtrusionEntityCollection &	skirt () const

const ExtrusionEntityCollection &	brim () const

const Polygon &	first_layer_convex_hull () const

const PrintStatistics &	print_statistics () const

PrintStatistics &	print_statistics ()

bool	has_wipe_tower () const

const WipeTowerData &	wipe_tower_data (size_t extruders_cnt=0) const

const ToolOrdering &	tool_ordering () const

std::string	output_filename (const std::string &filename_base=std::string()) const override

size_t	num_print_regions () const throw ()

const PrintRegion &	get_print_region (size_t idx) const

const ToolOrdering &	get_tool_ordering () const

const Polygons &	get_sequential_print_clearance_contours () 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 Member Functions
static bool	sequential_print_horizontal_clearance_valid (const Print &print, Polygons *polygons=nullptr)

Static Public Attributes
static constexpr const size_t	PrintStepEnumSize

Protected Member Functions
bool	invalidate_step (PrintStep step)

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< PrintStep, psCount >	Inherited

typedef std::pair< PrintObject *, bool >	PrintObjectInfo

Private Member Functions
bool	invalidate_state_by_config_options (const ConfigOptionResolver &new_config, const std::vector< t_config_option_key > &opt_keys)

void	_make_skirt ()

void	_make_wipe_tower ()

void	finalize_first_layer_convex_hull ()

void	alert_when_supports_needed ()

Polygons	first_layer_islands () const

Points	first_layer_wipe_tower_corners () const

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

Static Private Member Functions
static bool	is_shared_print_object_step_valid_unguarded (SpanOfConstPtrs< PrintObject > print_objects, PrintObjectStep print_object_step)

static ObjectID	generate_new_id ()

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

Static Private Attributes
static size_t	s_last_id = 0

Friends
class	GCode

class	GCodeProcessor

class	PrintObject

Detailed Description

Member Typedef Documentation

◆ cancel_callback_type

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

inherited

◆ Inherited

typedef PrintBaseWithState<PrintStep, psCount> Slic3r::Print::Inherited

private

◆ PrintObjectInfo

typedef std::pair<PrintObject *, bool> Slic3r::Print::PrintObjectInfo

private

◆ PrintStepEnum

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

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

◆ Print()

Slic3r::Print::Print ( )

default

◆ ~Print()

virtual Slic3r::Print::~Print ( )

inlinevirtual

548{ this->clear(); }

Slic3r::Print::clear

void clear() override

Definition Print.cpp:38

References clear().

Here is the call graph for this function:

Member Function Documentation

◆ _make_skirt()

void Slic3r::Print::_make_skirt ( )

private

{
    // First off we need to decide how tall the skirt must be.
    // The skirt_height option from config is expressed in layers, but our
    // object might have different layer heights, so we need to find the print_z
    // of the highest layer involved.
    // Note that unless has_infinite_skirt() == true
    // the actual skirt might not reach this $skirt_height_z value since the print
    // order of objects on each layer is not guaranteed and will not generally
    // include the thickest object first. It is just guaranteed that a skirt is
    // prepended to the first 'n' layers (with 'n' = skirt_height).
    // $skirt_height_z in this case is the highest possible skirt height for safety.
    coordf_t skirt_height_z = 0.;
    for (const PrintObject *object : m_objects) {
        size_t skirt_layers = this->has_infinite_skirt() ?
            object->layer_count() : 
            std::min(size_t(m_config.skirt_height.value), object->layer_count());
        skirt_height_z = std::max(skirt_height_z, object->m_layers[skirt_layers-1]->print_z);
    }
    
    // Collect points from all layers contained in skirt height.
    Points points;
    for (const PrintObject *object : m_objects) {
        Points object_points;
        // Get object layers up to skirt_height_z.
        for (const Layer *layer : object->m_layers) {
            if (layer->print_z > skirt_height_z)
                break;
            for (const ExPolygon &expoly : layer->lslices)
                // Collect the outer contour points only, ignore holes for the calculation of the convex hull.
                append(object_points, expoly.contour.points);
        }
        // Get support layers up to skirt_height_z.
        for (const SupportLayer *layer : object->support_layers()) {
            if (layer->print_z > skirt_height_z)
                break;
            layer->support_fills.collect_points(object_points);
        }
        // Repeat points for each object copy.
        for (const PrintInstance &instance : object->instances()) {
            Points copy_points = object_points;
            for (Point &pt : copy_points)
                pt += instance.shift;
            append(points, copy_points);
        }
    }
 
    // Include the wipe tower.
    append(points, this->first_layer_wipe_tower_corners());
 
    // Unless draft shield is enabled, include all brims as well.
    if (config().draft_shield == dsDisabled)
        append(points, m_first_layer_convex_hull.points);
 
    if (points.size() < 3)
        // At least three points required for a convex hull.
        return;
    
    this->throw_if_canceled();
    Polygon convex_hull = Slic3r::Geometry::convex_hull(points);
    
    // Skirt may be printed on several layers, having distinct layer heights,
    // but loops must be aligned so can't vary width/spacing
    // TODO: use each extruder's own flow
    double first_layer_height = this->skirt_first_layer_height();
    Flow   flow = this->skirt_flow();
    float  spacing = flow.spacing();
    double mm3_per_mm = flow.mm3_per_mm();
    
    std::vector<size_t> extruders;
    std::vector<double> extruders_e_per_mm;
    {
        auto set_extruders = this->extruders();
        extruders.reserve(set_extruders.size());
        extruders_e_per_mm.reserve(set_extruders.size());
        for (auto &extruder_id : set_extruders) {
            extruders.push_back(extruder_id);
            extruders_e_per_mm.push_back(Extruder((unsigned int)extruder_id, &m_config).e_per_mm(mm3_per_mm));
        }
    }
 
    // Number of skirt loops per skirt layer.
    size_t n_skirts = m_config.skirts.value;
    if (this->has_infinite_skirt() && n_skirts == 0)
        n_skirts = 1;
 
    // Initial offset of the brim inner edge from the object (possible with a support & raft).
    // The skirt will touch the brim if the brim is extruded.
    auto   distance = float(scale_(m_config.skirt_distance.value) - spacing/2.);
    // Draw outlines from outside to inside.
    // Loop while we have less skirts than required or any extruder hasn't reached the min length if any.
    std::vector<coordf_t> extruded_length(extruders.size(), 0.);
    for (size_t i = n_skirts, extruder_idx = 0; i > 0; -- i) {
        this->throw_if_canceled();
        // Offset the skirt outside.
        distance += float(scale_(spacing));
        // Generate the skirt centerline.
        Polygon loop;
        {
            Polygons loops = offset(convex_hull, distance, ClipperLib::jtRound, float(scale_(0.1)));
            Geometry::simplify_polygons(loops, scale_(0.05), &loops);
      if (loops.empty())
        break;
      loop = loops.front();
        }
        // Extrude the skirt loop.
        ExtrusionLoop eloop(elrSkirt);
        eloop.paths.emplace_back(ExtrusionPath(
            ExtrusionPath(
                ExtrusionRole::Skirt,
                (float)mm3_per_mm,         // this will be overridden at G-code export time
                flow.width(),
        (float)first_layer_height  // this will be overridden at G-code export time
            )));
        eloop.paths.back().polyline = loop.split_at_first_point();
        m_skirt.append(eloop);
        if (m_config.min_skirt_length.value > 0) {
            // The skirt length is limited. Sum the total amount of filament length extruded, in mm.
            extruded_length[extruder_idx] += unscale<double>(loop.length()) * extruders_e_per_mm[extruder_idx];
            if (extruded_length[extruder_idx] < m_config.min_skirt_length.value) {
                // Not extruded enough yet with the current extruder. Add another loop.
                if (i == 1)
                    ++ i;
            } else {
                assert(extruded_length[extruder_idx] >= m_config.min_skirt_length.value);
                // Enough extruded with the current extruder. Extrude with the next one,
                // until the prescribed number of skirt loops is extruded.
                if (extruder_idx + 1 < extruders.size())
                    ++ extruder_idx;
            }
        } else {
            // The skirt lenght is not limited, extrude the skirt with the 1st extruder only.
        }
    }
    // Brims were generated inside out, reverse to print the outmost contour first.
    m_skirt.reverse();
 
    // Remember the outer edge of the last skirt line extruded as m_skirt_convex_hull.
    for (Polygon &poly : offset(convex_hull, distance + 0.5f * float(scale_(spacing)), ClipperLib::jtRound, float(scale_(0.1))))
        append(m_skirt_convex_hull, std::move(poly.points));
}

References Slic3r::ExtrusionEntityCollection::append(), Slic3r::append(), config(), Slic3r::Geometry::convex_hull(), Slic3r::dsDisabled, Slic3r::Extruder::e_per_mm(), Slic3r::elrSkirt, extruders(), first_layer_wipe_tower_corners(), has_infinite_skirt(), ClipperLib::jtRound, m_config, m_first_layer_convex_hull, m_objects, m_skirt, m_skirt_convex_hull, Slic3r::Flow::mm3_per_mm(), Slic3r::offset(), Slic3r::ExtrusionLoop::paths, Slic3r::MultiPoint::points, Slic3r::ExtrusionEntityCollection::reverse(), scale_, Slic3r::Geometry::simplify_polygons(), Slic3r::ExtrusionRole::Skirt, skirt_first_layer_height(), skirt_flow(), Slic3r::Flow::spacing(), Slic3r::PrintBase::throw_if_canceled(), and Slic3r::Flow::width().

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _make_wipe_tower()

void Slic3r::Print::_make_wipe_tower ( )

private

{
    m_wipe_tower_data.clear();
    if (! this->has_wipe_tower())
        return;
 
    std::vector<std::vector<float>> wipe_volumes = WipeTower::extract_wipe_volumes(m_config);
 
    // Let the ToolOrdering class know there will be initial priming extrusions at the start of the print.
    m_wipe_tower_data.tool_ordering = ToolOrdering(*this, (unsigned int)-1, true);
 
    if (! m_wipe_tower_data.tool_ordering.has_wipe_tower())
        // Don't generate any wipe tower.
        return;
 
    // Check whether there are any layers in m_tool_ordering, which are marked with has_wipe_tower,
    // they print neither object, nor support. These layers are above the raft and below the object, and they
    // shall be added to the support layers to be printed.
    // see https://github.com/prusa3d/PrusaSlicer/issues/607
    {
        size_t idx_begin = size_t(-1);
        size_t idx_end   = m_wipe_tower_data.tool_ordering.layer_tools().size();
        // Find the first wipe tower layer, which does not have a counterpart in an object or a support layer.
        for (size_t i = 0; i < idx_end; ++ i) {
            const LayerTools &lt = m_wipe_tower_data.tool_ordering.layer_tools()[i];
            if (lt.has_wipe_tower && ! lt.has_object && ! lt.has_support) {
                idx_begin = i;
                break;
            }
        }
        if (idx_begin != size_t(-1)) {
            // Find the position in m_objects.first()->support_layers to insert these new support layers.
            double wipe_tower_new_layer_print_z_first = m_wipe_tower_data.tool_ordering.layer_tools()[idx_begin].print_z;
            auto it_layer = m_objects.front()->support_layers().begin();
            auto it_end   = m_objects.front()->support_layers().end();
            for (; it_layer != it_end && (*it_layer)->print_z - EPSILON < wipe_tower_new_layer_print_z_first; ++ it_layer);
            // Find the stopper of the sequence of wipe tower layers, which do not have a counterpart in an object or a support layer.
            for (size_t i = idx_begin; i < idx_end; ++ i) {
                LayerTools &lt = const_cast<LayerTools&>(m_wipe_tower_data.tool_ordering.layer_tools()[i]);
                if (! (lt.has_wipe_tower && ! lt.has_object && ! lt.has_support))
                    break;
                lt.has_support = true;
                // Insert the new support layer.
                double height    = lt.print_z - (i == 0 ? 0. : m_wipe_tower_data.tool_ordering.layer_tools()[i-1].print_z);
                //FIXME the support layer ID is set to -1, as Vojtech hopes it is not being used anyway.
                it_layer = m_objects.front()->insert_support_layer(it_layer, -1, 0, height, lt.print_z, lt.print_z - 0.5 * height);
                ++ it_layer;
            }
        }
    }
    this->throw_if_canceled();
 
    // Initialize the wipe tower.
    WipeTower wipe_tower(m_config, wipe_volumes, m_wipe_tower_data.tool_ordering.first_extruder());
 
    //wipe_tower.set_retract();
    //wipe_tower.set_zhop();
 
    // Set the extruder & material properties at the wipe tower object.
    for (size_t i = 0; i < m_config.nozzle_diameter.size(); ++ i)
        wipe_tower.set_extruder(i, m_config);
 
    m_wipe_tower_data.priming = Slic3r::make_unique<std::vector<WipeTower::ToolChangeResult>>(
        wipe_tower.prime((float)this->skirt_first_layer_height(), m_wipe_tower_data.tool_ordering.all_extruders(), false));
 
    // Lets go through the wipe tower layers and determine pairs of extruder changes for each
    // to pass to wipe_tower (so that it can use it for planning the layout of the tower)
    {
        unsigned int current_extruder_id = m_wipe_tower_data.tool_ordering.all_extruders().back();
        for (auto &layer_tools : m_wipe_tower_data.tool_ordering.layer_tools()) { // for all layers
            if (!layer_tools.has_wipe_tower) continue;
            bool first_layer = &layer_tools == &m_wipe_tower_data.tool_ordering.front();
            wipe_tower.plan_toolchange((float)layer_tools.print_z, (float)layer_tools.wipe_tower_layer_height, current_extruder_id, current_extruder_id, false);
            for (const auto extruder_id : layer_tools.extruders) {
                if ((first_layer && extruder_id == m_wipe_tower_data.tool_ordering.all_extruders().back()) || extruder_id != current_extruder_id) {
                    float volume_to_wipe = wipe_volumes[current_extruder_id][extruder_id];             // total volume to wipe after this toolchange
                    // Not all of that can be used for infill purging:
                    volume_to_wipe -= (float)m_config.filament_minimal_purge_on_wipe_tower.get_at(extruder_id);
 
                    // try to assign some infills/objects for the wiping:
                    volume_to_wipe = layer_tools.wiping_extrusions_nonconst().mark_wiping_extrusions(*this, layer_tools, current_extruder_id, extruder_id, volume_to_wipe);
 
                    // add back the minimal amount toforce on the wipe tower:
                    volume_to_wipe += (float)m_config.filament_minimal_purge_on_wipe_tower.get_at(extruder_id);
 
                    // request a toolchange at the wipe tower with at least volume_to_wipe purging amount
                    wipe_tower.plan_toolchange((float)layer_tools.print_z, (float)layer_tools.wipe_tower_layer_height,
                                               current_extruder_id, extruder_id, volume_to_wipe);
                    current_extruder_id = extruder_id;
                }
            }
            layer_tools.wiping_extrusions_nonconst().ensure_perimeters_infills_order(*this, layer_tools);
            if (&layer_tools == &m_wipe_tower_data.tool_ordering.back() || (&layer_tools + 1)->wipe_tower_partitions == 0)
                break;
        }
    }
 
    // Generate the wipe tower layers.
    m_wipe_tower_data.tool_changes.reserve(m_wipe_tower_data.tool_ordering.layer_tools().size());
    wipe_tower.generate(m_wipe_tower_data.tool_changes);
    m_wipe_tower_data.depth = wipe_tower.get_depth();
    m_wipe_tower_data.z_and_depth_pairs = wipe_tower.get_z_and_depth_pairs();
    m_wipe_tower_data.brim_width = wipe_tower.get_brim_width();
    m_wipe_tower_data.height = wipe_tower.get_wipe_tower_height();
 
    // Unload the current filament over the purge tower.
    coordf_t layer_height = m_objects.front()->config().layer_height.value;
    if (m_wipe_tower_data.tool_ordering.back().wipe_tower_partitions > 0) {
        // The wipe tower goes up to the last layer of the print.
        if (wipe_tower.layer_finished()) {
            // The wipe tower is printed to the top of the print and it has no space left for the final extruder purge.
            // Lift Z to the next layer.
            wipe_tower.set_layer(float(m_wipe_tower_data.tool_ordering.back().print_z + layer_height), float(layer_height), 0, false, true);
        } else {
            // There is yet enough space at this layer of the wipe tower for the final purge.
        }
    } else {
        // The wipe tower does not reach the last print layer, perform the pruge at the last print layer.
        assert(m_wipe_tower_data.tool_ordering.back().wipe_tower_partitions == 0);
        wipe_tower.set_layer(float(m_wipe_tower_data.tool_ordering.back().print_z), float(layer_height), 0, false, true);
    }
    m_wipe_tower_data.final_purge = Slic3r::make_unique<WipeTower::ToolChangeResult>(
        wipe_tower.tool_change((unsigned int)(-1)));
 
    m_wipe_tower_data.used_filament = wipe_tower.get_used_filament();
    m_wipe_tower_data.number_of_toolchanges = wipe_tower.get_number_of_toolchanges();
    const Vec3d origin = Vec3d::Zero();
    m_fake_wipe_tower.set_fake_extrusion_data(wipe_tower.position(), wipe_tower.width(), wipe_tower.get_wipe_tower_height(), config().first_layer_height, m_wipe_tower_data.depth,
                                              m_wipe_tower_data.z_and_depth_pairs, m_wipe_tower_data.brim_width, config().wipe_tower_rotation_angle, config().wipe_tower_cone_angle, {scale_(origin.x()), scale_(origin.y())});
 
}

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ active_step_add_warning()

void Slic3r::PrintBaseWithState< PrintStep , 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);
    }

◆ alert_when_supports_needed()

void Slic3r::Print::alert_when_supports_needed ( )

private

{
    if (this->set_started(psAlertWhenSupportsNeeded)) {
        BOOST_LOG_TRIVIAL(debug) << "psAlertWhenSupportsNeeded - start";
        set_status(69, _u8L("Alert if supports needed"));
 
        auto issue_to_alert_message = [](SupportSpotsGenerator::SupportPointCause cause, bool critical) {
            std::string message;
            switch (cause) {
            //TRN Alert when support is needed. Describes that the model has long bridging extrusions which may print badly 
            case SupportSpotsGenerator::SupportPointCause::LongBridge: message = _u8L("Long bridging extrusions"); break;
            //TRN Alert when support is needed. Describes bridge anchors/turns in the air, which will definitely print badly
            case SupportSpotsGenerator::SupportPointCause::FloatingBridgeAnchor: message = _u8L("Floating bridge anchors"); break;
            case SupportSpotsGenerator::SupportPointCause::FloatingExtrusion:
                if (critical) {
                     //TRN Alert when support is needed. Describes that the print has large overhang area which will print badly or not print at all.
                    message = _u8L("Collapsing overhang");
                } else {
                    //TRN Alert when support is needed. Describes extrusions that are not supported enough and come out curled or loose.
                    message = _u8L("Loose extrusions");
                }
                break;
            //TRN Alert when support is needed. Describes that the print has low bed adhesion and may became loose.
            case SupportSpotsGenerator::SupportPointCause::SeparationFromBed: message = _u8L("Low bed adhesion"); break;
            //TRN Alert when support is needed. Describes that the object has part that is not connected to the bed and will not print at all without supports.
            case SupportSpotsGenerator::SupportPointCause::UnstableFloatingPart: message = _u8L("Floating object part"); break;
            //TRN Alert when support is needed. Describes that the object has thin part that may brake during printing 
            case SupportSpotsGenerator::SupportPointCause::WeakObjectPart: message = _u8L("Thin fragile part"); break;
            }
 
            return message;
        };
 
        // TRN this translation rule is used to translate lists of uknown size on single line. The first argument is element of the list,
        // the second argument may be element or rest of the list. For most languages, this does not need translation, but some use different 
        // separator than comma and some use blank space in front of the separator.
        auto single_line_list_rule = L("%1%, %2%");
        auto multiline_list_rule   = "%1%\n%2%";
 
        auto elements_to_translated_list = [](const std::vector<std::string> &translated_elements, std::string expansion_rule) {
            if (expansion_rule.find("%1%") == expansion_rule.npos || expansion_rule.find("%2%") == expansion_rule.npos) {
                BOOST_LOG_TRIVIAL(error) << "INCORRECT EXPANSION RULE FOR LIST TRANSLATION: " << expansion_rule
                                         << " - IT SHOULD CONTAIN %1% and %2%!";
                expansion_rule = "%1% %2%";
            }
            if (translated_elements.size() == 0) {
                return std::string{};
            }
            if (translated_elements.size() == 1) {
                return translated_elements.front();
            }
 
            std::string translated_list = expansion_rule;
            for (int i = 0; i < int(translated_elements.size()) - 1; ++ i) {
                auto first_elem = translated_list.find("%1%");
                assert(first_elem != translated_list.npos);
                translated_list.replace(first_elem, 3, translated_elements[i]);
 
                // expand the translated list by another application of the same rule
                auto second_elem = translated_list.find("%2%");
                assert(second_elem != translated_list.npos);
                if (i < int(translated_elements.size()) - 2) {
                    translated_list.replace(second_elem, 3, expansion_rule);
                } else {
                    translated_list.replace(second_elem, 3, translated_elements[i + 1]);
                }
            }
 
            return translated_list;
        };
 
        // vector of pairs of object and its issues, where each issue is a pair of type and critical flag
        std::vector<std::pair<const PrintObject *, std::vector<std::pair<SupportSpotsGenerator::SupportPointCause, bool>>>> objects_isssues;
 
        for (const PrintObject *object : m_objects) {
            std::unordered_set<const ModelObject *> checked_model_objects;
            if (!object->has_support() && checked_model_objects.find(object->model_object()) == checked_model_objects.end()) {
                if (object->m_shared_regions->generated_support_points.has_value()) {
                    SupportSpotsGenerator::SupportPoints  supp_points = object->m_shared_regions->generated_support_points->support_points;
                    SupportSpotsGenerator::PartialObjects partial_objects = object->m_shared_regions->generated_support_points
                                                                                ->partial_objects;
                    auto issues = SupportSpotsGenerator::gather_issues(supp_points, partial_objects);
                    if (issues.size() > 0) {
                        objects_isssues.emplace_back(object, issues);
                    }
                }
                checked_model_objects.emplace(object->model_object());
            }
        }
 
        bool                                                                                                  recommend_brim = false;
        std::map<std::pair<SupportSpotsGenerator::SupportPointCause, bool>, std::vector<const PrintObject *>> po_by_support_issues;
        for (const auto &obj : objects_isssues) {
            for (const auto &issue : obj.second) {
                po_by_support_issues[issue].push_back(obj.first);
                if (issue.first == SupportSpotsGenerator::SupportPointCause::SeparationFromBed && !obj.first->has_brim()) {
                    recommend_brim = true;
                }
            }
        }
 
        std::vector<std::pair<std::string, std::vector<std::string>>> message_elements;
        if (objects_isssues.size() > po_by_support_issues.size()) {
            // there are more objects than causes, group by issues
            for (const auto &issue : po_by_support_issues) {
                auto &pair = message_elements.emplace_back(issue_to_alert_message(issue.first.first, issue.first.second),
                                                           std::vector<std::string>{});
                for (const auto &obj : issue.second) {
                    pair.second.push_back(obj->m_model_object->name);
                }
            }
        } else {
            // more causes than objects, group by objects
            for (const auto &obj : objects_isssues) {
                auto &pair = message_elements.emplace_back(obj.first->model_object()->name,  std::vector<std::string>{});
                for (const auto &issue : obj.second) {
                    pair.second.push_back(issue_to_alert_message(issue.first, issue.second));
                }
            }
        }
 
        // first, gather sublements into single line list, store in first subelement
        for (auto &pair : message_elements) {
            pair.second.front() = elements_to_translated_list(pair.second, single_line_list_rule);
        }
 
        // then gather elements to create multiline list
        std::vector<std::string> lines = {};
        for (auto &pair : message_elements) {
            lines.push_back(""); // empty line for readability
            lines.push_back(pair.first);
            lines.push_back(pair.second.front());
        }
 
        lines.push_back("");
        lines.push_back(_u8L("Consider enabling supports."));
        if (recommend_brim) {
            lines.push_back(_u8L("Also consider enabling brim."));
        }
 
        // TRN Alert message for detected print issues. first argument is a list of detected issues.
        auto message = Slic3r::format(_u8L("Detected print stability issues:\n%1%"), elements_to_translated_list(lines, multiline_list_rule));
 
        if (objects_isssues.size() > 0) {
            this->active_step_add_warning(PrintStateBase::WarningLevel::NON_CRITICAL, message);
        }
 
        BOOST_LOG_TRIVIAL(debug) << "psAlertWhenSupportsNeeded - end";
        this->set_done(psAlertWhenSupportsNeeded);
    }
}

References _u8L, Slic3r::PrintBaseWithState< PrintStep, psCount >::active_step_add_warning(), error, Slic3r::SupportSpotsGenerator::FloatingBridgeAnchor, Slic3r::SupportSpotsGenerator::FloatingExtrusion, Slic3r::format(), Slic3r::SupportSpotsGenerator::gather_issues(), L, Slic3r::SupportSpotsGenerator::LongBridge, m_objects, Slic3r::PrintStateBase::NON_CRITICAL, Slic3r::psAlertWhenSupportsNeeded, Slic3r::SupportSpotsGenerator::SeparationFromBed, Slic3r::PrintBaseWithState< PrintStep, psCount >::set_done(), Slic3r::PrintBaseWithState< PrintStep, psCount >::set_started(), Slic3r::PrintBase::set_status(), Slic3r::SupportSpotsGenerator::UnstableFloatingPart, and Slic3r::SupportSpotsGenerator::WeakObjectPart.

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply()

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

overridevirtual

Implements Slic3r::PrintBase.

{
#ifdef _DEBUG
    check_model_ids_validity(model);
#endif /* _DEBUG */
 
    // Normalize the config.
  new_full_config.option("print_settings_id",            true);
  new_full_config.option("filament_settings_id",         true);
  new_full_config.option("printer_settings_id",          true);
    new_full_config.option("physical_printer_settings_id", true);
    new_full_config.normalize_fdm();
 
    // Find modified keys of the various configs. Resolve overrides extruder retract values by filament profiles.
    DynamicPrintConfig   filament_overrides;
    t_config_option_keys print_diff       = print_config_diffs(m_config, new_full_config, filament_overrides);
    t_config_option_keys full_config_diff = full_print_config_diffs(m_full_print_config, new_full_config);
    // If just a physical printer was changed, but printer preset is the same, then there is no need to apply whole print
    // see https://github.com/prusa3d/PrusaSlicer/issues/8800
    if (full_config_diff.size() == 1 && full_config_diff[0] == "physical_printer_settings_id")
        full_config_diff.clear();
 
    // Collect changes to object and region configs.
    t_config_option_keys object_diff      = m_default_object_config.diff(new_full_config);
    t_config_option_keys region_diff      = m_default_region_config.diff(new_full_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() && object_diff.empty() && region_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.
    if (! print_diff.empty())
        update_apply_status(this->invalidate_state_by_config_options(new_full_config, print_diff));
 
    // Apply variables to placeholder parser. The placeholder parser is used by G-code export,
    // which should be stopped if print_diff is not empty.
    size_t num_extruders = m_config.nozzle_diameter.size();
    bool   num_extruders_changed = false;
    if (! full_config_diff.empty()) {
        update_apply_status(this->invalidate_step(psGCodeExport));
        m_placeholder_parser.clear_config();
        // Set the profile aliases for the PrintBase::output_filename()
    m_placeholder_parser.set("print_preset",              new_full_config.option("print_settings_id")->clone());
    m_placeholder_parser.set("filament_preset",           new_full_config.option("filament_settings_id")->clone());
    m_placeholder_parser.set("printer_preset",            new_full_config.option("printer_settings_id")->clone());
        m_placeholder_parser.set("physical_printer_preset",   new_full_config.option("physical_printer_settings_id")->clone());
    // We want the filament overrides to be applied over their respective extruder parameters by the PlaceholderParser.
    // see "Placeholders do not respect filament overrides." GH issue #3649
    m_placeholder_parser.apply_config(filament_overrides);
      // It is also safe to change m_config now after this->invalidate_state_by_config_options() call.
      m_config.apply_only(new_full_config, print_diff, true);
      //FIXME use move semantics once ConfigBase supports it.
        // Some filament_overrides may contain values different from new_full_config, but equal to m_config.
        // As long as these config options don't reallocate memory when copying, we are safe overriding a value, which is in use by a worker thread.
      m_config.apply(filament_overrides);
      // Handle changes to object config defaults
      m_default_object_config.apply_only(new_full_config, object_diff, true);
      // Handle changes to regions config defaults
      m_default_region_config.apply_only(new_full_config, region_diff, true);
        m_full_print_config = std::move(new_full_config);
        if (num_extruders != m_config.nozzle_diameter.size()) {
            num_extruders = m_config.nozzle_diameter.size();
            num_extruders_changed = true;
        }
    }
    
    ModelObjectStatusDB model_object_status_db;
 
    // 1) Synchronize model objects.
    bool print_regions_reshuffled = false;
    if (model.id() != m_model.id()) {
        // Kill everything, initialize from scratch.
        // Stop background processing.
        this->call_cancel_callback();
        update_apply_status(this->invalidate_all_steps());
        for (PrintObject *object : m_objects) {
            model_object_status_db.add(*object->model_object(), ModelObjectStatus::Deleted);
      update_apply_status(object->invalidate_all_steps());
      delete object;
        }
        m_objects.clear();
        print_regions_reshuffled = true;
        m_model.assign_copy(model);
    for (const ModelObject *model_object : m_model.objects)
      model_object_status_db.add(*model_object, ModelObjectStatus::New);
    } else {
        if (m_model.custom_gcode_per_print_z != model.custom_gcode_per_print_z) {
            update_apply_status(num_extruders_changed || 
              // Tool change G-codes are applied as color changes for a single extruder printer, no need to invalidate tool ordering.
              //FIXME The tool ordering may be invalidated unnecessarily if the custom_gcode_per_print_z.mode is not applicable
              // to the active print / model state, and then it is reset, so it is being applicable, but empty, thus the effect is the same.
              (num_extruders > 1 && custom_per_printz_gcodes_tool_changes_differ(m_model.custom_gcode_per_print_z.gcodes, model.custom_gcode_per_print_z.gcodes)) ?
              // The Tool Ordering and the Wipe Tower are no more valid.
              this->invalidate_steps({ psWipeTower, psGCodeExport }) :
              // There is no change in Tool Changes stored in custom_gcode_per_print_z, therefore there is no need to update Tool Ordering.
              this->invalidate_step(psGCodeExport));
            m_model.custom_gcode_per_print_z = model.custom_gcode_per_print_z;
        }
        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_db.add(*model_object, 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(psGCodeExport));
            for (const ModelObject *model_object : m_model.objects)
                model_object_status_db.add(*model_object, ModelObjectStatus::Old);
            for (size_t i = m_model.objects.size(); i < model.objects.size(); ++ i) {
                model_object_status_db.add(*model.objects[i], 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(psGCodeExport));
            // 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_db.add(*mobj, ModelObjectStatus::New);
                } else {
                    // Existing ModelObject re-added (possibly moved in the list).
                    m_model.objects.emplace_back(*it);
                    model_object_status_db.add(*mobj, ModelObjectStatus::Moved);
                }
            }
            bool deleted_any = false;
      for (ModelObject *&model_object : model_objects_old)
                if (model_object_status_db.add_if_new(*model_object, ModelObjectStatus::Deleted))
                    deleted_any = true;
                else
                    // Do not delete this ModelObject instance.
                    model_object = nullptr;
            if (deleted_any) {
                // Delete PrintObjects of the deleted ModelObjects.
                PrintObjectPtrs print_objects_old = std::move(m_objects);
                m_objects.clear();
                m_objects.reserve(print_objects_old.size());
                for (PrintObject *print_object : print_objects_old) {
                    const ModelObjectStatus &status = model_object_status_db.get(*print_object->model_object());
                    if (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;
                print_regions_reshuffled = true;
            }
        }
    }
 
    // 2) Map print objects including their transformation matrices.
    PrintObjectStatusDB print_object_status_db(m_objects);
 
    // 3) Synchronize ModelObjects & PrintObjects.
    const std::initializer_list<ModelVolumeType> solid_or_modifier_types { ModelVolumeType::MODEL_PART, ModelVolumeType::NEGATIVE_VOLUME, ModelVolumeType::PARAMETER_MODIFIER };
    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];
        ModelObjectStatus &model_object_status = const_cast<ModelObjectStatus&>(model_object_status_db.reuse(model_object));
    const ModelObject &model_object_new    = *model.objects[idx_model_object];
        if (model_object_status.status == ModelObjectStatus::New)
            // PrintObject instances will be added in the next loop.
            continue;
        // Update the ModelObject instance, possibly invalidate the linked PrintObjects.
        assert(model_object_status.status == ModelObjectStatus::Old || model_object_status.status == ModelObjectStatus::Moved);
        // Check whether a model part volume was added or removed, their transformations or order changed.
        // Only volume IDs, volume types, transformation matrices and their order are checked, configuration and other parameters are NOT checked.
        bool solid_or_modifier_differ   = model_volume_list_changed(model_object, model_object_new, solid_or_modifier_types) ||
                                          model_mmu_segmentation_data_changed(model_object, model_object_new) ||
                                          (model_object_new.is_mm_painted() && num_extruders_changed);
        bool supports_differ            = model_volume_list_changed(model_object, model_object_new, ModelVolumeType::SUPPORT_BLOCKER) ||
                                          model_volume_list_changed(model_object, model_object_new, ModelVolumeType::SUPPORT_ENFORCER);
        bool layer_height_ranges_differ = ! layer_height_ranges_equal(model_object.layer_config_ranges, model_object_new.layer_config_ranges, model_object_new.layer_height_profile.empty());
        bool model_origin_translation_differ = model_object.origin_translation != model_object_new.origin_translation;
        auto print_objects_range        = print_object_status_db.get_range(model_object);
        // The list actually can be empty if all instances are out of the print bed.
        //assert(print_objects_range.begin() != print_objects_range.end());
        // All PrintObjects in print_objects_range shall point to the same prints_objects_regions
        if (print_objects_range.begin() != print_objects_range.end()) {
            model_object_status.print_object_regions = print_objects_range.begin()->print_object->m_shared_regions;
            model_object_status.print_object_regions->ref_cnt_inc();
        }
        if (solid_or_modifier_differ || model_origin_translation_differ || layer_height_ranges_differ ||
            ! model_object.layer_height_profile.timestamp_matches(model_object_new.layer_height_profile)) {
            // The very first step (the slicing step) is invalidated. One may freely remove all associated PrintObjects.
            model_object_status.print_object_regions_status = 
                model_object_status.print_object_regions == nullptr || model_origin_translation_differ || layer_height_ranges_differ ?
                // Drop print_objects_regions.
                ModelObjectStatus::PrintObjectRegionsStatus::Invalid :
                // Reuse bounding boxes of print_objects_regions for ModelVolumes with unmodified transformation.
                ModelObjectStatus::PrintObjectRegionsStatus::PartiallyValid;
            for (const PrintObjectStatus &print_object_status : print_objects_range) {
                update_apply_status(print_object_status.print_object->invalidate_all_steps());
                const_cast<PrintObjectStatus&>(print_object_status).status = PrintObjectStatus::Deleted;
            }
            if (model_object_status.print_object_regions_status == ModelObjectStatus::PrintObjectRegionsStatus::PartiallyValid)
                // Drop everything from PrintObjectRegions but those VolumeExtents (of their particular ModelVolumes) that are still valid.
                print_objects_regions_invalidate_keep_some_volumes(*model_object_status.print_object_regions, model_object.volumes, model_object_new.volumes);
            else if (model_object_status.print_object_regions != nullptr)
                model_object_status.print_object_regions->clear();
            // Copy content of the ModelObject including its ID, do not change the parent.
            model_object.assign_copy(model_object_new);
        } else {
            model_object_status.print_object_regions_status = ModelObjectStatus::PrintObjectRegionsStatus::Valid;
            if (supports_differ || model_custom_supports_data_changed(model_object, model_object_new)) {
                // First stop background processing before shuffling or deleting the ModelVolumes in the ModelObject's list.
                if (supports_differ) {
                    this->call_cancel_callback();
                    update_apply_status(false);
                }
                // Invalidate just the supports step.
                for (const PrintObjectStatus &print_object_status : print_objects_range) {
                    update_apply_status(print_object_status.print_object->invalidate_step(posSupportMaterial));
                }
                if (supports_differ) {
                    // Copy just the support volumes.
                    model_volume_list_update_supports(model_object, model_object_new);
                }
            } else if (model_custom_seam_data_changed(model_object, model_object_new)) {
                update_apply_status(this->invalidate_step(psGCodeExport));
            }
        }
        if (! solid_or_modifier_differ) {
            // 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 || num_extruders_changed) {
                PrintObjectConfig new_config = PrintObject::object_config_from_model_object(m_default_object_config, model_object, num_extruders);
                for (const PrintObjectStatus &print_object_status : print_object_status_db.get_range(model_object)) {
                    t_config_option_keys diff = print_object_status.print_object->config().diff(new_config);
                    if (! diff.empty()) {
                        update_apply_status(print_object_status.print_object->invalidate_state_by_config_options(print_object_status.print_object->config(), new_config, diff));
                        print_object_status.print_object->config_apply_only(new_config, diff, true);
                    }
                }
            }
            // Synchronize (just copy) the remaining data of ModelVolumes (name, config, custom supports data).
            //FIXME What to do with m_material_id?
      model_volume_list_copy_configs(model_object /* dst */, model_object_new /* src */, ModelVolumeType::MODEL_PART);
      model_volume_list_copy_configs(model_object /* dst */, model_object_new /* src */, ModelVolumeType::PARAMETER_MODIFIER);
            layer_height_ranges_copy_configs(model_object.layer_config_ranges /* dst */, model_object_new.layer_config_ranges /* src */);
            // Copy the ModelObject name, input_file and instances. The instances will be compared against PrintObject instances in the next step.
            model_object.name       = model_object_new.name;
            model_object.input_file = model_object_new.input_file;
            // Only refresh ModelInstances if there is any change.
            if (model_object.instances.size() != model_object_new.instances.size() || 
              ! std::equal(model_object.instances.begin(), model_object.instances.end(), model_object_new.instances.begin(), [](auto l, auto r){ return l->id() == r->id(); })) {
              // G-code generator accesses model_object.instances to generate sequential print ordering matching the Plater object list.
              update_apply_status(this->invalidate_step(psGCodeExport));
              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);
              }
          } else if (! std::equal(model_object.instances.begin(), model_object.instances.end(), model_object_new.instances.begin(), 
              [](auto l, auto r){ return l->print_volume_state == r->print_volume_state && l->printable == r->printable && 
                                 l->get_transformation().get_matrix().isApprox(r->get_transformation().get_matrix()); })) {
            // If some of the instances changed, the bounding box of the updated ModelObject is likely no more valid.
            // This is safe as the ModelObject's bounding box is only accessed from this function, which is called from the main thread only.
            // Synchronize the content of instances.
            auto new_instance = model_object_new.instances.begin();
        for (auto old_instance = model_object.instances.begin(); old_instance != model_object.instances.end(); ++ old_instance, ++ new_instance) {
          (*old_instance)->set_transformation((*new_instance)->get_transformation());
                    (*old_instance)->print_volume_state = (*new_instance)->print_volume_state;
                    (*old_instance)->printable        = (*new_instance)->printable;
          }
          }
            // Source / dest object share the same bounding boxes, just copy them.
            model_object.copy_transformation_caches(model_object_new);
        }
    }
 
    // 4) Generate PrintObjects from ModelObjects and their instances.
    {
        PrintObjectPtrs print_objects_new;
        print_objects_new.reserve(std::max(m_objects.size(), m_model.objects.size()));
        bool new_objects = false;
        // Walk over all new model objects and check, whether there are matching PrintObjects.
        for (ModelObject *model_object : m_model.objects) {
            ModelObjectStatus &model_object_status = const_cast<ModelObjectStatus&>(model_object_status_db.reuse(*model_object));
            model_object_status.print_instances    = print_objects_from_model_object(*model_object);
            std::vector<const PrintObjectStatus*> old;
            old.reserve(print_object_status_db.count(*model_object));
            for (const PrintObjectStatus &print_object_status : print_object_status_db.get_range(*model_object))
                if (print_object_status.status != PrintObjectStatus::Deleted)
                    old.emplace_back(&print_object_status);
            // Generate a list of trafos and XY offsets for instances of a ModelObject
            // Producing the config for PrintObject on demand, caching it at print_object_last.
            const PrintObject *print_object_last = nullptr;
            auto print_object_apply_config = [this, &print_object_last, model_object, num_extruders](PrintObject *print_object) {
                print_object->config_apply(print_object_last ?
                    print_object_last->config() :
                    PrintObject::object_config_from_model_object(m_default_object_config, *model_object, num_extruders));
                print_object_last = print_object;
            };
            if (old.empty()) {
                // Simple case, just generate new instances.
                for (PrintObjectTrafoAndInstances &print_instances : model_object_status.print_instances) {
                    PrintObject *print_object = new PrintObject(this, model_object, print_instances.trafo, std::move(print_instances.instances));
                    print_object_apply_config(print_object);
                    print_objects_new.emplace_back(print_object);
                    // print_object_status.emplace(PrintObjectStatus(print_object, PrintObjectStatus::New));
                    new_objects = true;
                }
                continue;
            }
            // Complex case, try to merge the two lists.
            // Sort the old lexicographically by their trafos.
            std::sort(old.begin(), old.end(), [](const PrintObjectStatus *lhs, const PrintObjectStatus *rhs){ return transform3d_lower(lhs->trafo, rhs->trafo); });
            // Merge the old / new lists.
            auto it_old = old.begin();
            for (PrintObjectTrafoAndInstances &new_instances : model_object_status.print_instances) {
        for (; it_old != old.end() && transform3d_lower((*it_old)->trafo, new_instances.trafo); ++ it_old);
        if (it_old == old.end() || ! transform3d_equal((*it_old)->trafo, new_instances.trafo)) {
                    // This is a new instance (or a set of instances with the same trafo). Just add it.
                    PrintObject *print_object = new PrintObject(this, model_object, new_instances.trafo, std::move(new_instances.instances));
                    print_object_apply_config(print_object);
                    print_objects_new.emplace_back(print_object);
                    // print_object_status.emplace(PrintObjectStatus(print_object, PrintObjectStatus::New));
                    new_objects = true;
                    if (it_old != old.end())
                        const_cast<PrintObjectStatus*>(*it_old)->status = PrintObjectStatus::Deleted;
                } else {
                    // The PrintObject already exists and the copies differ.
          PrintBase::ApplyStatus status = (*it_old)->print_object->set_instances(std::move(new_instances.instances));
                    if (status != PrintBase::APPLY_STATUS_UNCHANGED)
            update_apply_status(status == PrintBase::APPLY_STATUS_INVALIDATED);
          print_objects_new.emplace_back((*it_old)->print_object);
          const_cast<PrintObjectStatus*>(*it_old)->status = PrintObjectStatus::Reused;
        }
            }
        }
        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.
            bool deleted_objects = false;
            for (const PrintObjectStatus &pos : print_object_status_db)
                if (pos.status == PrintObjectStatus::Unknown || pos.status == PrintObjectStatus::Deleted) {
                    update_apply_status(pos.print_object->invalidate_all_steps());
                    delete pos.print_object;
          deleted_objects = true;
                }
      if (new_objects || deleted_objects)
                update_apply_status(this->invalidate_steps({ psAlertWhenSupportsNeeded, psSkirtBrim, psWipeTower, psGCodeExport }));
      if (new_objects)
              update_apply_status(false);
            print_regions_reshuffled = true;
        }
        print_object_status_db.clear();
    }
 
    // All regions now have distinct settings.
    // Check whether applying the new region config defaults we would get different regions,
    // update regions or create regions from scratch.
    for (auto it_print_object = m_objects.begin(); it_print_object != m_objects.end();) {
        // Find the range of PrintObjects sharing the same associated ModelObject.
        auto                it_print_object_end  = it_print_object;
        PrintObject        &print_object         = *(*it_print_object);
        const ModelObject  &model_object         = *print_object.model_object();
        ModelObjectStatus  &model_object_status  = const_cast<ModelObjectStatus&>(model_object_status_db.reuse(model_object));
        PrintObjectRegions *print_object_regions = model_object_status.print_object_regions;
        for (++ it_print_object_end; it_print_object_end != m_objects.end() && (*it_print_object)->model_object() == (*it_print_object_end)->model_object(); ++ it_print_object_end)
            assert((*it_print_object_end)->m_shared_regions == nullptr || (*it_print_object_end)->m_shared_regions == print_object_regions);
        if (print_object_regions == nullptr) {
            print_object_regions = new PrintObjectRegions{};
            model_object_status.print_object_regions = print_object_regions;
            print_object_regions->ref_cnt_inc();
        }
        std::vector<unsigned int> painting_extruders;
        if (const auto &volumes = print_object.model_object()->volumes;
            num_extruders > 1 &&
            std::find_if(volumes.begin(), volumes.end(), [](const ModelVolume *v) { return ! v->mmu_segmentation_facets.empty(); }) != volumes.end()) {
            //FIXME be more specific! Don't enumerate extruders that are not used for painting!
            painting_extruders.assign(num_extruders, 0);
            std::iota(painting_extruders.begin(), painting_extruders.end(), 1);
        }
        if (model_object_status.print_object_regions_status == ModelObjectStatus::PrintObjectRegionsStatus::Valid) {
            // Verify that the trafo for regions & volume bounding boxes thus for regions is still applicable.
            auto invalidate = [it_print_object, it_print_object_end, update_apply_status]() {
                for (auto it = it_print_object; it != it_print_object_end; ++ it)
                    if ((*it)->m_shared_regions != nullptr)
                        update_apply_status((*it)->invalidate_all_steps());
            };
            if (print_object_regions && ! trafos_differ_in_rotation_by_z_and_mirroring_by_xy_only(print_object_regions->trafo_bboxes, model_object_status.print_instances.front().trafo)) {
                invalidate();
                print_object_regions->clear();
                model_object_status.print_object_regions_status = ModelObjectStatus::PrintObjectRegionsStatus::Invalid;
                print_regions_reshuffled = true;
            } else if (print_object_regions &&
                verify_update_print_object_regions(
                    print_object.model_object()->volumes,
                    m_default_region_config,
                    num_extruders,
                    painting_extruders,
                    *print_object_regions,
                    [it_print_object, it_print_object_end, &update_apply_status](const PrintRegionConfig &old_config, const PrintRegionConfig &new_config, const t_config_option_keys &diff_keys) {
                        for (auto it = it_print_object; it != it_print_object_end; ++it)
                            if ((*it)->m_shared_regions != nullptr)
                                update_apply_status((*it)->invalidate_state_by_config_options(old_config, new_config, diff_keys));
                    })) {
                // Regions are valid, just keep them.
            } else {
                // Regions were reshuffled.
                invalidate();
                // At least reuse layer ranges and bounding boxes of ModelVolumes.
                model_object_status.print_object_regions_status = ModelObjectStatus::PrintObjectRegionsStatus::PartiallyValid;
                print_regions_reshuffled = true;
            }
        }
        if (print_object_regions == nullptr || model_object_status.print_object_regions_status != ModelObjectStatus::PrintObjectRegionsStatus::Valid) {
            // Layer ranges with their associated configurations. Remove overlaps between the ranges
            // and create the regions from scratch.
            print_object_regions = generate_print_object_regions(
                print_object_regions,
                print_object.model_object()->volumes,
                LayerRanges(print_object.model_object()->layer_config_ranges),
                m_default_region_config,
                model_object_status.print_instances.front().trafo,
                num_extruders,
                print_object.is_mm_painted() ? 0.f : float(print_object.config().xy_size_compensation.value),
                painting_extruders);
        }
        for (auto it = it_print_object; it != it_print_object_end; ++it)
            if ((*it)->m_shared_regions) {
                assert((*it)->m_shared_regions == print_object_regions);
            } else {
                (*it)->m_shared_regions = print_object_regions;
                print_object_regions->ref_cnt_inc();
            }
        it_print_object = it_print_object_end;
    }
 
    if (print_regions_reshuffled) {
        // Update Print::m_print_regions from objects.
        struct cmp { bool operator() (const PrintRegion *l, const PrintRegion *r) const { return l->config_hash() == r->config_hash() && l->config() == r->config(); } };
        std::set<const PrintRegion*, cmp> region_set;
        m_print_regions.clear();
        PrintObjectRegions *print_object_regions = nullptr;
        for (PrintObject *print_object : m_objects)
            if (print_object_regions != print_object->m_shared_regions) {
                print_object_regions = print_object->m_shared_regions;
                for (std::unique_ptr<Slic3r::PrintRegion> &print_region : print_object_regions->all_regions)
                    if (auto it = region_set.find(print_region.get()); it == region_set.end()) {
                        int print_region_id = int(m_print_regions.size());
                        m_print_regions.emplace_back(print_region.get());
                        print_region->m_print_region_id = print_region_id;
                    } else {
                        print_region->m_print_region_id = (*it)->print_region_id();
                    }
            }
    }
 
    // Update SlicingParameters for each object where the SlicingParameters is not valid.
    // If it is not valid, then it is ensured that PrintObject.m_slicing_params is not in use
    // (posSlicing and posSupportMaterial was invalidated).
    for (PrintObject *object : m_objects)
        object->update_slicing_parameters();
 
    if (apply_status == APPLY_STATUS_CHANGED || apply_status == APPLY_STATUS_INVALIDATED)
        this->cleanup();
 
#ifdef _DEBUG
    check_model_ids_equal(m_model, model);
#endif /* _DEBUG */
 
  return static_cast<ApplyStatus>(apply_status);
}

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:

◆ auto_assign_extruders()

void Slic3r::Print::auto_assign_extruders ( ModelObject * model_object ) const

{
    // only assign extruders if object has more than one volume
    if (model_object->volumes.size() < 2)
        return;
    
//    size_t extruders = m_config.nozzle_diameter.values.size();
    for (size_t volume_id = 0; volume_id < model_object->volumes.size(); ++ volume_id) {
        ModelVolume *volume = model_object->volumes[volume_id];
        //FIXME Vojtech: This assigns an extruder ID even to a modifier volume, if it has a material assigned.
        if ((volume->is_model_part() || volume->is_modifier()) && ! volume->material_id().empty() && ! volume->config.has("extruder"))
            volume->config.set("extruder", int(volume_id + 1));
    }
}

References Slic3r::ModelObject::volumes.

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

Here is the caller graph for this function:

◆ brim()

const ExtrusionEntityCollection & Slic3r::Print::brim ( ) const

inline

624{ return m_brim; }

Slic3r::Print::m_brim

ExtrusionEntityCollection m_brim

Definition Print.hpp:680

References m_brim.

Referenced by Slic3r::GUI::GLCanvas3D::_load_print_toolpaths(), Slic3r::get_print_extrusions_extents(), and Slic3r::GCode::process_layer().

Here is the caller graph for this function:

◆ brim_flow()

Flow Slic3r::Print::brim_flow ( ) const

{
    ConfigOptionFloatOrPercent width = m_config.first_layer_extrusion_width;
    if (width.value == 0) 
        width = m_print_regions.front()->config().perimeter_extrusion_width;
    if (width.value == 0) 
        width = m_objects.front()->config().extrusion_width;
    
    /* We currently use a random region's perimeter extruder.
       While this works for most cases, we should probably consider all of the perimeter
       extruders and take the one with, say, the smallest index.
       The same logic should be applied to the code that selects the extruder during G-code
       generation as well. */
    return Flow::new_from_config_width(
        frPerimeter,
    width,
        (float)m_config.nozzle_diameter.get_at(m_print_regions.front()->config().perimeter_extruder-1),
    (float)this->skirt_first_layer_height());
}

References Slic3r::frPerimeter, m_config, m_objects, m_print_regions, and Slic3r::Flow::new_from_config_width().

Referenced by Slic3r::make_brim(), and Slic3r::make_inner_brim().

Here is the call graph for this function:

Here is the caller 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 Slic3r::SLAPrint::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::Print::cleanup ( )

overridevirtual

Implements Slic3r::PrintBase.

{
    // Invalidate data of a single ModelObject shared by multiple PrintObjects.
    // Find spans of PrintObjects sharing the same PrintObjectRegions.
    std::vector<PrintObject*> all_objects(m_objects);
    std::sort(all_objects.begin(), all_objects.end(), [](const PrintObject *l, const PrintObject *r){ return l->shared_regions() < r->shared_regions(); } );
    for (auto it = all_objects.begin(); it != all_objects.end();) {
        PrintObjectRegions *shared_regions = (*it)->m_shared_regions;
        auto it_begin = it;
        for (; it != all_objects.end() && shared_regions == (*it)->shared_regions(); ++ it)
            // Let the PrintObject clean up its data with invalidated milestones.
            (*it)->cleanup();
        auto this_objects = SpanOfConstPtrs<PrintObject>(const_cast<const PrintObject* const* const>(&(*it_begin)), it - it_begin);
        if (! Print::is_shared_print_object_step_valid_unguarded(this_objects, posSupportSpotsSearch))
            shared_regions->generated_support_points.reset();
    }    
}

References const, Slic3r::PrintObjectRegions::generated_support_points, and Slic3r::posSupportSpotsSearch.

◆ clear()

void Slic3r::Print::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 (PrintObject *object : m_objects)
    delete object;
  m_objects.clear();
    m_print_regions.clear();
    m_model.clear_objects();
}

References Slic3r::Model::clear_objects(), Slic3r::PrintBaseWithState< PrintStep, psCount >::invalidate_all_steps(), Slic3r::PrintBase::m_model, m_objects, m_print_regions, and Slic3r::PrintBase::state_mutex().

Referenced by ~Print(), and validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ config()

const PrintConfig & Slic3r::Print::config ( ) const

inline

597{ return m_config; }

References m_config.

Referenced by Slic3r::FillLightning::Generator::Generator(), Slic3r::GUI::PlaterAfterLoadAutoArrange::PlaterAfterLoadAutoArrange(), Slic3r::ToolOrdering::ToolOrdering(), Slic3r::FFFTreeSupport::TreeSupportMeshGroupSettings::TreeSupportMeshGroupSettings(), Slic3r::GCode::_do_export(), Slic3r::GUI::GLCanvas3D::_load_print_toolpaths(), Slic3r::GUI::GLCanvas3D::_load_wipe_tower_toolpaths(), _make_skirt(), _make_wipe_tower(), Slic3r::GCode::_print_first_layer_bed_temperature(), Slic3r::GCode::_print_first_layer_extruder_temperatures(), Slic3r::FillAdaptive::adaptive_fill_line_spacing(), Slic3r::ToolOrdering::assign_custom_gcodes(), Slic3r::DoExport::autospeed_volumetric_limit(), Slic3r::LayerRegion::bridging_flow(), Slic3r::PrintRegion::collect_object_printing_extruders(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), Slic3r::WipingExtrusions::ensure_perimeters_infills_order(), extruders(), Slic3r::FFFTreeSupport::generate_overhangs(), Slic3r::get_default_perimeter_spacing(), Slic3r::GUI::get_skirt_offset(), Slic3r::get_wipe_tower_extrusions_extents(), Slic3r::DoExport::init_ooze_prevention(), Slic3r::GUI::GCodeViewer::load_shells(), Slic3r::make_brim(), Slic3r::make_inner_brim(), Slic3r::LayerRegion::make_perimeters(), Slic3r::Skirt::make_skirt_loops_per_extruder_other_layers(), Slic3r::WipingExtrusions::mark_wiping_extrusions(), Slic3r::mmu_segmentation_top_and_bottom_layers(), Slic3r::multi_material_segmentation_by_painting(), output_filename(), Slic3r::GCode::print_machine_envelope(), process(), Slic3r::GCode::process_layer(), Slic3r::GCode::process_layer_single_object(), sequential_print_horizontal_clearance_valid(), Slic3r::sequential_print_vertical_clearance_valid(), Slic3r::PrintObject::slice_volumes(), Slic3r::support_material_flow(), Slic3r::support_material_interface_flow(), validate(), and Slic3r::DoExport::validate_custom_gcode().

Here is the caller 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 PrintObjectConfig & Slic3r::Print::default_object_config ( ) const

inline

598{ return m_default_object_config; }

References m_default_object_config.

◆ default_region_config()

const PrintRegionConfig & Slic3r::Print::default_region_config ( ) const

inline

599{ return m_default_region_config; }

References m_default_region_config.

◆ empty()

bool Slic3r::Print::empty ( ) const

inlineoverridevirtual

Implements Slic3r::PrintBase.

558{ return m_objects.empty(); }

References m_objects.

Referenced by Slic3r::GUI::GLCanvas3D::_load_wipe_tower_toolpaths().

Here is the caller graph for this function:

◆ export_gcode()

std::string Slic3r::Print::export_gcode	(	const std::string &	path_template,
		GCodeProcessorResult *	result,
		ThumbnailsGeneratorCallback	thumbnail_cb = `nullptr`
	)

{
    // output everything to a G-code file
    // The following call may die if the output_filename_format template substitution fails.
    std::string path = this->output_filepath(path_template);
    std::string message;
    if (!path.empty() && result == nullptr) {
        // Only show the path if preview_data is not set -> running from command line.
        message = _u8L("Exporting G-code");
        message += " to ";
        message += path;
    } else
        message = _u8L("Generating G-code");
    this->set_status(90, message);
 
    // Create GCode on heap, it has quite a lot of data.
    std::unique_ptr<GCode> gcode(new GCode);
    gcode->do_export(this, path.c_str(), result, thumbnail_cb);
 
    if (m_conflict_result.has_value())
        result->conflict_result = *m_conflict_result;
 
    return path.c_str();
}

References _u8L, Slic3r::GCodeProcessorResult::conflict_result, m_conflict_result, Slic3r::PrintBase::output_filepath(), and Slic3r::PrintBase::set_status().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extruders()

std::vector< unsigned int > Slic3r::Print::extruders ( ) const

{
    std::vector<unsigned int> extruders = this->object_extruders();
    append(extruders, this->support_material_extruders());
    sort_remove_duplicates(extruders);
 
    // The wipe tower extruder can also be set. When the wipe tower is enabled and it will be generated,
    // append its extruder into the list too.
    if (has_wipe_tower() && config().wipe_tower_extruder != 0 && extruders.size() > 1) {
        assert(config().wipe_tower_extruder > 0 && config().wipe_tower_extruder < int(config().nozzle_diameter.size()));
        extruders.emplace_back(config().wipe_tower_extruder - 1); // the config value is 1-based
        sort_remove_duplicates(extruders);
    }
 
    return extruders;
}

References Slic3r::append(), config(), extruders(), has_wipe_tower(), object_extruders(), Slic3r::sort_remove_duplicates(), and support_material_extruders().

Referenced by Slic3r::GCode::_do_export(), _make_skirt(), Slic3r::GCode::_print_first_layer_extruder_temperatures(), extruders(), Slic3r::GUI::Preview::load_print_as_fff(), max_allowed_layer_height(), object_extruders(), support_material_extruders(), and validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finalize()

void Slic3r::Print::finalize ( )

inlineoverridevirtual

Implements Slic3r::PrintBase.

565{ PrintBaseWithState<PrintStep, psCount>::finalize_impl(m_objects); }

Slic3r::PrintBaseWithState::finalize_impl

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

Definition PrintBase.hpp:714

References Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::finalize_impl(), and m_objects.

Here is the call graph for this function:

◆ finalize_first_layer_convex_hull()

void Slic3r::Print::finalize_first_layer_convex_hull ( )

private

{
    append(m_first_layer_convex_hull.points, m_skirt_convex_hull);
    if (m_first_layer_convex_hull.empty()) {
        // Neither skirt nor brim was extruded. Collect points of printed objects from 1st layer.
        for (Polygon &poly : this->first_layer_islands())
            append(m_first_layer_convex_hull.points, std::move(poly.points));
    }
    append(m_first_layer_convex_hull.points, this->first_layer_wipe_tower_corners());
    m_first_layer_convex_hull = Geometry::convex_hull(m_first_layer_convex_hull.points);
}

References Slic3r::append(), Slic3r::Geometry::convex_hull(), Slic3r::MultiPoint::empty(), first_layer_islands(), m_first_layer_convex_hull, m_skirt_convex_hull, and Slic3r::MultiPoint::points.

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finalize_impl()

void Slic3r::PrintBaseWithState< PrintStep , 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::Print::finished ( ) const

inlineoverridevirtual

Implements Slic3r::PrintBase.

577{ return this->is_step_done(psGCodeExport); }

Slic3r::Print::is_step_done

bool is_step_done(PrintStep step) const

Definition Print.hpp:573

References is_step_done(), and Slic3r::psGCodeExport.

Referenced by output_filename().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ first_layer_convex_hull()

const Polygon & Slic3r::Print::first_layer_convex_hull ( ) const

inline

630{ return m_first_layer_convex_hull; }

References m_first_layer_convex_hull.

Referenced by Slic3r::GCode::_do_export().

Here is the caller graph for this function:

◆ first_layer_islands()

Polygons Slic3r::Print::first_layer_islands ( ) const

private

{
    Polygons islands;
    for (PrintObject *object : m_objects) {
        Polygons object_islands;
        for (ExPolygon &expoly : object->m_layers.front()->lslices)
            object_islands.push_back(expoly.contour);
        if (! object->support_layers().empty())
            object->support_layers().front()->support_fills.polygons_covered_by_spacing(object_islands, float(SCALED_EPSILON));
        islands.reserve(islands.size() + object_islands.size() * object->instances().size());
        for (const PrintInstance &instance : object->instances())
            for (Polygon &poly : object_islands) {
                islands.push_back(poly);
                islands.back().translate(instance.shift);
            }
    }
    return islands;
}

References m_objects, and SCALED_EPSILON.

Referenced by finalize_first_layer_convex_hull(), and process().

Here is the caller graph for this function:

◆ first_layer_wipe_tower_corners()

Points Slic3r::Print::first_layer_wipe_tower_corners ( ) const

private

{
    Points pts_scaled;
 
    if (has_wipe_tower() && ! m_wipe_tower_data.tool_changes.empty()) {
        double width = m_config.wipe_tower_width + 2*m_wipe_tower_data.brim_width;
        double depth = m_wipe_tower_data.depth + 2*m_wipe_tower_data.brim_width;
        Vec2d pt0(-m_wipe_tower_data.brim_width, -m_wipe_tower_data.brim_width);
        
        // First the corners.
        std::vector<Vec2d> pts = { pt0,
                                   Vec2d(pt0.x()+width, pt0.y()),
                                   Vec2d(pt0.x()+width, pt0.y()+depth),
                                   Vec2d(pt0.x(),pt0.y()+depth)
                                 };
 
        // Now the stabilization cone.
        Vec2d center = (pts[0] + pts[2])/2.;
        const auto [cone_R, cone_x_scale] = WipeTower::get_wipe_tower_cone_base(m_config.wipe_tower_width, m_wipe_tower_data.height, m_wipe_tower_data.depth, m_config.wipe_tower_cone_angle);
        double r = cone_R + m_wipe_tower_data.brim_width;
        for (double alpha = 0.; alpha<2*M_PI; alpha += M_PI/20.)
            pts.emplace_back(center + r*Vec2d(std::cos(alpha)/cone_x_scale, std::sin(alpha)));
 
        for (Vec2d& pt : pts) {
            pt = Eigen::Rotation2Dd(Geometry::deg2rad(m_config.wipe_tower_rotation_angle.value)) * pt;
            pt += Vec2d(m_config.wipe_tower_x.value, m_config.wipe_tower_y.value);
            pts_scaled.emplace_back(Point(scale_(pt.x()), scale_(pt.y())));
        }
    }
    return pts_scaled;
}

References Slic3r::WipeTowerData::brim_width, Slic3r::Geometry::deg2rad(), Slic3r::WipeTowerData::depth, Slic3r::WipeTower::get_wipe_tower_cone_base(), has_wipe_tower(), Slic3r::WipeTowerData::height, m_config, M_PI, m_wipe_tower_data, scale_, and Slic3r::WipeTowerData::tool_changes.

Referenced by _make_skirt().

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

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() [1/3]

const PrintObject * Slic3r::Print::get_object ( ObjectID object_id ) const

inline

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

References m_objects.

◆ get_object() [2/3]

PrintObject * Slic3r::Print::get_object ( size_t idx )

inline

601{ return const_cast<PrintObject*>(m_objects[idx]); }

References m_objects.

Referenced by Slic3r::FFFTreeSupport::generate_support_areas(), Slic3r::FFFTreeSupport::group_meshes(), Slic3r::GUI::Plater::priv::on_slicing_update(), and Slic3r::FFFTreeSupport::precalculate().

Here is the caller graph for this function:

◆ get_object() [3/3]

const PrintObject * Slic3r::Print::get_object ( size_t idx ) const

inline

602{ return m_objects[idx]; }

References m_objects.

◆ get_print_object_by_model_object_id()

const PrintObject * Slic3r::Print::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 PrintObject* obj) { return obj->model_object()->id() == object_id; });
        return (it == m_objects.end()) ? nullptr : *it;
    }

References m_objects.

Referenced by Slic3r::GUI::get_arrange_poly().

Here is the caller graph for this function:

◆ get_print_region()

const PrintRegion & Slic3r::Print::get_print_region ( size_t idx ) const

inline

643{ return *m_print_regions[idx]; }

References m_print_regions.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::GCode::process_layer_single_object().

Here is the caller graph for this function:

◆ get_sequential_print_clearance_contours()

const Polygons & Slic3r::Print::get_sequential_print_clearance_contours ( ) const

inline

646{ return m_sequential_print_clearance_contours; }

Slic3r::Print::m_sequential_print_clearance_contours

Polygons m_sequential_print_clearance_contours

Definition Print.hpp:697

References m_sequential_print_clearance_contours.

◆ get_tool_ordering()

const ToolOrdering & Slic3r::Print::get_tool_ordering ( ) const

inline

644{ return m_wipe_tower_data.tool_ordering; }

References m_wipe_tower_data, and Slic3r::WipeTowerData::tool_ordering.

◆ has_brim()

bool Slic3r::Print::has_brim ( ) const

{
    return std::any_of(m_objects.begin(), m_objects.end(), [](PrintObject *object) { return object->has_brim(); });
}

References m_objects.

Referenced by Slic3r::GUI::GLCanvas3D::_load_print_toolpaths(), Slic3r::PrintRegion::collect_object_printing_extruders(), process(), and Slic3r::GCode::process_layer().

Here is the caller graph for this function:

◆ has_infinite_skirt()

bool Slic3r::Print::has_infinite_skirt ( ) const

{
    return (m_config.draft_shield == dsEnabled && m_config.skirts > 0)/* || (m_config.ooze_prevention && this->extruders().size() > 1)*/;
}

References Slic3r::dsEnabled, and m_config.

Referenced by Slic3r::GUI::GLCanvas3D::_load_print_toolpaths(), _make_skirt(), has_skirt(), Slic3r::Skirt::make_skirt_loops_per_extruder_other_layers(), and Slic3r::GCode::process_layer().

Here is the caller graph for this function:

◆ has_skirt()

bool Slic3r::Print::has_skirt ( ) const

{
    return (m_config.skirt_height > 0 && m_config.skirts > 0) || has_infinite_skirt();
    // case dsLimited should only be taken into account when skirt_height and skirts are positive,
    // so it is covered by the first condition.
}

References has_infinite_skirt(), and m_config.

Referenced by Slic3r::GUI::GLCanvas3D::_load_print_toolpaths(), Slic3r::GUI::get_skirt_offset(), Slic3r::Skirt::make_skirt_loops_per_extruder_1st_layer(), Slic3r::Skirt::make_skirt_loops_per_extruder_other_layers(), and process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_support_material()

bool Slic3r::Print::has_support_material ( ) const

{
    for (const PrintObject *object : m_objects)
        if (object->has_support_material()) 
            return true;
    return false;
}

References m_objects.

Referenced by Slic3r::GCode::_do_export().

Here is the caller graph for this function:

◆ has_wipe_tower()

bool Slic3r::Print::has_wipe_tower ( ) const

{
    return 
        ! m_config.spiral_vase.value &&
        m_config.wipe_tower.value && 
        m_config.nozzle_diameter.values.size() > 1;
}

References m_config.

Referenced by Slic3r::GCode::_do_export(), _make_wipe_tower(), extruders(), first_layer_wipe_tower_corners(), process(), and validate().

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< PrintStep , 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::Print::invalidate_state_by_config_options	(	const ConfigOptionResolver &	new_config,
		const std::vector< t_config_option_key > &	opt_keys
	)

private

{
    if (opt_keys.empty())
        return false;
 
    // Cache the plenty of parameters, which influence the G-code generator only,
    // or they are only notes not influencing the generated G-code.
    static std::unordered_set<std::string> steps_gcode = {
        "autoemit_temperature_commands",
        "avoid_crossing_perimeters",
        "avoid_crossing_perimeters_max_detour",
        "bed_shape",
        "bed_temperature",
        "before_layer_gcode",
        "between_objects_gcode",
        "bridge_acceleration",
        "bridge_fan_speed",
        "enable_dynamic_fan_speeds",
        "overhang_fan_speed_0",
        "overhang_fan_speed_1",
        "overhang_fan_speed_2",
        "overhang_fan_speed_3",
        "colorprint_heights",
        "cooling",
        "default_acceleration",
        "deretract_speed",
        "disable_fan_first_layers",
        "duplicate_distance",
        "end_gcode",
        "end_filament_gcode",
        "external_perimeter_acceleration",
        "extrusion_axis",
        "extruder_clearance_height",
        "extruder_clearance_radius",
        "extruder_colour",
        "extruder_offset",
        "extrusion_multiplier",
        "fan_always_on",
        "fan_below_layer_time",
        "full_fan_speed_layer",
        "filament_colour",
        "filament_diameter",
        "filament_density",
        "filament_notes",
        "filament_cost",
        "filament_spool_weight",
        "first_layer_acceleration",
        "first_layer_acceleration_over_raft",
        "first_layer_bed_temperature",
        "first_layer_speed_over_raft",
        "gcode_comments",
        "gcode_label_objects",
        "infill_acceleration",
        "layer_gcode",
        "min_fan_speed",
        "max_fan_speed",
        "max_print_height",
        "min_print_speed",
        "max_print_speed",
        "max_volumetric_speed",
        "max_volumetric_extrusion_rate_slope_positive",
        "max_volumetric_extrusion_rate_slope_negative",
        "notes",
        "only_retract_when_crossing_perimeters",
        "output_filename_format",
        "perimeter_acceleration",
        "post_process",
        "gcode_substitutions",
        "printer_notes",
        "retract_before_travel",
        "retract_before_wipe",
        "retract_layer_change",
        "retract_length",
        "retract_length_toolchange",
        "retract_lift",
        "retract_lift_above",
        "retract_lift_below",
        "retract_restart_extra",
        "retract_restart_extra_toolchange",
        "retract_speed",
        "single_extruder_multi_material_priming",
        "slowdown_below_layer_time",
        "solid_infill_acceleration",
        "standby_temperature_delta",
        "start_gcode",
        "start_filament_gcode",
        "toolchange_gcode",
        "top_solid_infill_acceleration",
        "travel_acceleration",
        "thumbnails",
        "thumbnails_format",
        "use_firmware_retraction",
        "use_relative_e_distances",
        "use_volumetric_e",
        "variable_layer_height",
        "wipe"
    };
 
    static std::unordered_set<std::string> steps_ignore;
 
    std::vector<PrintStep> steps;
    std::vector<PrintObjectStep> osteps;
    bool invalidated = false;
 
    for (const t_config_option_key &opt_key : opt_keys) {
        if (steps_gcode.find(opt_key) != steps_gcode.end()) {
            // These options only affect G-code export or they are just notes without influence on the generated G-code,
            // so there is nothing to invalidate.
            steps.emplace_back(psGCodeExport);
        } else if (steps_ignore.find(opt_key) != steps_ignore.end()) {
            // These steps have no influence on the G-code whatsoever. Just ignore them.
        } else if (
               opt_key == "skirts"
            || opt_key == "skirt_height"
            || opt_key == "draft_shield"
            || opt_key == "skirt_distance"
            || opt_key == "min_skirt_length"
            || opt_key == "ooze_prevention"
            || opt_key == "wipe_tower_x"
            || opt_key == "wipe_tower_y"
            || opt_key == "wipe_tower_rotation_angle") {
            steps.emplace_back(psSkirtBrim);
        } else if (
               opt_key == "first_layer_height"
            || opt_key == "nozzle_diameter"
            || opt_key == "resolution"
            // Spiral Vase forces different kind of slicing than the normal model:
            // In Spiral Vase mode, holes are closed and only the largest area contour is kept at each layer.
            // Therefore toggling the Spiral Vase on / off requires complete reslicing.
            || opt_key == "spiral_vase") {
            osteps.emplace_back(posSlice);
        } else if (
               opt_key == "complete_objects"
            || opt_key == "filament_type"
            || opt_key == "first_layer_temperature"
            || opt_key == "filament_loading_speed"
            || opt_key == "filament_loading_speed_start"
            || opt_key == "filament_unloading_speed"
            || opt_key == "filament_unloading_speed_start"
            || opt_key == "filament_toolchange_delay"
            || opt_key == "filament_cooling_moves"
            || opt_key == "filament_minimal_purge_on_wipe_tower"
            || opt_key == "filament_cooling_initial_speed"
            || opt_key == "filament_cooling_final_speed"
            || opt_key == "filament_ramming_parameters"
            || opt_key == "filament_max_volumetric_speed"
            || opt_key == "gcode_flavor"
            || opt_key == "high_current_on_filament_swap"
            || opt_key == "infill_first"
            || opt_key == "single_extruder_multi_material"
            || opt_key == "temperature"
            || opt_key == "idle_temperature"
            || opt_key == "wipe_tower"
            || opt_key == "wipe_tower_width"
            || opt_key == "wipe_tower_brim_width"
            || opt_key == "wipe_tower_cone_angle"
            || opt_key == "wipe_tower_bridging"
            || opt_key == "wipe_tower_extra_spacing"
            || opt_key == "wipe_tower_no_sparse_layers"
            || opt_key == "wipe_tower_extruder"
            || opt_key == "wiping_volumes_matrix"
            || opt_key == "parking_pos_retraction"
            || opt_key == "cooling_tube_retraction"
            || opt_key == "cooling_tube_length"
            || opt_key == "extra_loading_move"
            || opt_key == "travel_speed"
            || opt_key == "travel_speed_z"
            || opt_key == "first_layer_speed"
            || opt_key == "z_offset") {
            steps.emplace_back(psWipeTower);
            steps.emplace_back(psSkirtBrim);
        } else if (opt_key == "filament_soluble") {
            steps.emplace_back(psWipeTower);
            // Soluble support interface / non-soluble base interface produces non-soluble interface layers below soluble interface layers.
            // Thus switching between soluble / non-soluble interface layer material may require recalculation of supports.
            //FIXME Killing supports on any change of "filament_soluble" is rough. We should check for each object whether that is necessary.
            osteps.emplace_back(posSupportMaterial);
        } else if (
               opt_key == "first_layer_extrusion_width" 
            || opt_key == "min_layer_height"
            || opt_key == "max_layer_height"
            || opt_key == "gcode_resolution") {
            osteps.emplace_back(posPerimeters);
            osteps.emplace_back(posInfill);
            osteps.emplace_back(posSupportMaterial);
            steps.emplace_back(psSkirtBrim);
        } else if (opt_key == "avoid_crossing_curled_overhangs") {
            osteps.emplace_back(posEstimateCurledExtrusions);
        } else {
            // for legacy, if we can't handle this option let's invalidate all steps
            //FIXME invalidate all steps of all objects as well?
            invalidated |= this->invalidate_all_steps();
            // Continue with the other opt_keys to possibly invalidate any object specific steps.
        }
    }
 
    sort_remove_duplicates(steps);
    for (PrintStep step : steps)
        invalidated |= this->invalidate_step(step);
    sort_remove_duplicates(osteps);
    for (PrintObjectStep ostep : osteps)
        for (PrintObject *object : m_objects)
            invalidated |= object->invalidate_step(ostep);
    return invalidated;
}

References Slic3r::PrintBaseWithState< PrintStep, psCount >::invalidate_all_steps(), invalidate_step(), m_objects, Slic3r::posEstimateCurledExtrusions, Slic3r::posInfill, Slic3r::posPerimeters, Slic3r::posSlice, Slic3r::posSupportMaterial, Slic3r::psGCodeExport, Slic3r::psSkirtBrim, Slic3r::psWipeTower, and Slic3r::sort_remove_duplicates().

Here is the call graph for this function:

◆ invalidate_step()

bool Slic3r::Print::invalidate_step ( PrintStep step )

protected

{
  bool invalidated = Inherited::invalidate_step(step);
    // Propagate to dependent steps.
    if (step != psGCodeExport)
        invalidated |= Inherited::invalidate_step(psGCodeExport);
    return invalidated;
}

References Slic3r::PrintBaseWithState< PrintStep, psCount >::invalidate_step(), and Slic3r::psGCodeExport.

Referenced by invalidate_state_by_config_options(), and Slic3r::PrintObject::set_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invalidate_steps() [1/2]

bool Slic3r::PrintBaseWithState< PrintStep , 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< PrintStep , COUNT >::invalidate_steps	(	StepTypeIterator	step_begin,
		StepTypeIterator	step_end
	)

inlineprotectedinherited

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

◆ is_shared_print_object_step_valid_unguarded()

bool Slic3r::Print::is_shared_print_object_step_valid_unguarded	(	SpanOfConstPtrs< PrintObject >	print_objects,
		PrintObjectStep	print_object_step
	)

staticprivate

{
    return std::any_of(print_objects.begin(), print_objects.end(), [print_object_step](auto po){ return po->is_step_done_unguarded(print_object_step); });
}

◆ is_step_done() [1/2]

bool Slic3r::Print::is_step_done ( PrintObjectStep step ) const

{
    if (m_objects.empty())
        return false;
    std::scoped_lock<std::mutex> lock(this->state_mutex());
    for (const PrintObject *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() [2/2]

bool Slic3r::Print::is_step_done ( PrintStep step ) const

inline

573{ return Inherited::is_step_done(step); }

Slic3r::PrintBaseWithState< PrintStep, psCount >::is_step_done

bool is_step_done(PrintStepEnum step) const

Definition PrintBase.hpp:583

References Slic3r::PrintBaseWithState< PrintStep, psCount >::is_step_done().

Referenced by Slic3r::GUI::GLCanvas3D::_load_print_toolpaths(), Slic3r::GUI::GLCanvas3D::_load_wipe_tower_toolpaths(), Slic3r::BackgroundSlicingProcess::apply(), finished(), Slic3r::GUI::Preview::load_print_as_fff(), Slic3r::GUI::GCodeViewer::load_shells(), Slic3r::GUI::GLCanvas3D::reload_scene(), and wipe_tower_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_step_done_unguarded()

bool Slic3r::PrintBaseWithState< PrintStep , 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< PrintStep , 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 process().

Here is the caller graph for this function:

◆ max_allowed_layer_height()

double Slic3r::Print::max_allowed_layer_height ( ) const

{
    double nozzle_diameter_max = 0.;
    for (unsigned int extruder_id : this->extruders())
        nozzle_diameter_max = std::max(nozzle_diameter_max, m_config.nozzle_diameter.get_at(extruder_id));
    return nozzle_diameter_max;
}

References extruders(), and m_config.

Here is the call 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(), Slic3r::SLAPrint::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:

◆ num_object_instances()

unsigned int Slic3r::Print::num_object_instances ( ) const

{
  unsigned int instances = 0;
    for (const PrintObject *print_object : m_objects)
        instances += (unsigned int)print_object->instances().size();
    return instances;
}

References m_objects.

Referenced by Slic3r::sort_object_instances_by_model_order().

Here is the caller graph for this function:

◆ num_print_regions()

size_t Slic3r::Print::num_print_regions	(	)	const
throw	(
	)

inline

642{ return m_print_regions.size(); }

References m_print_regions.

Referenced by Slic3r::GCode::_do_export().

Here is the caller graph for this function:

◆ object_extruders()

std::vector< unsigned int > Slic3r::Print::object_extruders ( ) const

{
    std::vector<unsigned int> extruders;
    extruders.reserve(m_print_regions.size() * m_objects.size() * 3);
    for (const PrintObject *object : m_objects)
    for (const PrintRegion &region : object->all_regions())
          region.collect_object_printing_extruders(*this, extruders);
    sort_remove_duplicates(extruders);
    return extruders;
}

References extruders(), m_objects, m_print_regions, and Slic3r::sort_remove_duplicates().

Referenced by Slic3r::ToolOrdering::ToolOrdering(), Slic3r::ToolOrdering::assign_custom_gcodes(), extruders(), and support_material_extruders().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ objects()

SpanOfConstPtrs< PrintObject > Slic3r::Print::objects ( ) const

inline

600{ return SpanOfConstPtrs<PrintObject>(const_cast<const PrintObject* const* const>(m_objects.data()), m_objects.size()); }

References const, and m_objects.

Referenced by Slic3r::ToolOrdering::ToolOrdering(), Slic3r::GCode::_do_export(), Slic3r::GUI::GLCanvas3D::_load_print_toolpaths(), Slic3r::GUI::GLGizmoFdmSupports::apply_data_from_backend(), Slic3r::DoubleSlider::Control::auto_color_change(), Slic3r::DoExport::autospeed_volumetric_limit(), Slic3r::chain_print_object_instances(), Slic3r::GCode::collect_layers_to_print(), Slic3r::WipingExtrusions::ensure_perimeters_infills_order(), Slic3r::fff_tree_support_generate(), Slic3r::get_boundary_external(), Slic3r::get_perimeter_spacing_external(), Slic3r::get_print_bottom_layers_expolygons(), Slic3r::get_top_level_objects_with_brim(), Slic3r::GUI::GLGizmoFdmSupports::has_backend_supports(), Slic3r::has_polygons_nothing_inside(), Slic3r::SeamPlacer::init(), Slic3r::inner_brim_area(), Slic3r::DoubleSlider::Control::IsNewPrint(), Slic3r::GUI::GLCanvas3D::load_preview(), Slic3r::GUI::Preview::load_print_as_fff(), Slic3r::GUI::GCodeViewer::load_shells(), Slic3r::make_brim(), Slic3r::make_inner_brim(), Slic3r::WipingExtrusions::mark_wiping_extrusions(), Slic3r::GCode::process_layer_single_object(), sequential_print_horizontal_clearance_valid(), Slic3r::sort_object_instances_by_model_order(), Slic3r::top_level_outer_brim_area(), and Slic3r::GUI::Preview::update_layers_slider().

Here is the caller graph for this function:

◆ objects_mutable()

PrintObjectPtrs & Slic3r::Print::objects_mutable ( )

inline

620{ return m_objects; }

References m_objects.

◆ output_filename() [1/2]

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

overridevirtual

Implements Slic3r::PrintBase.

{ 
    // Set the placeholders for the data know first after the G-code export is finished.
    // These values will be just propagated into the output file name.
    DynamicConfig config = this->finished() ? this->print_statistics().config() : this->print_statistics().placeholders();
    config.set_key_value("num_extruders", new ConfigOptionInt((int)m_config.nozzle_diameter.size()));
    config.set_key_value("default_output_extension", new ConfigOptionString(".gcode"));
    return this->PrintBase::output_filename(m_config.output_filename_format.value, ".gcode", filename_base, &config);
}

References Slic3r::PrintStatistics::config(), config(), finished(), m_config, Slic3r::PrintBase::output_filename(), Slic3r::PrintStatistics::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 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_object_ids()

std::vector< ObjectID > Slic3r::Print::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 PrintObject *print_object : m_objects)
        out.emplace_back(print_object->id());
    return out;
}

References m_objects.

◆ print_regions_mutable()

PrintRegionPtrs & Slic3r::Print::print_regions_mutable ( )

inline

621{ return m_print_regions; }

References m_print_regions.

◆ print_statistics() [1/2]

PrintStatistics & Slic3r::Print::print_statistics ( )

inline

633{ return m_print_statistics; }

Slic3r::Print::m_print_statistics

PrintStatistics m_print_statistics

Definition Print.hpp:694

References m_print_statistics.

◆ print_statistics() [2/2]

const PrintStatistics & Slic3r::Print::print_statistics ( ) const

inline

632{ return m_print_statistics; }

References m_print_statistics.

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

Here is the caller graph for this function:

◆ process()

void Slic3r::Print::process ( )

overridevirtual

Implements Slic3r::PrintBase.

{
    name_tbb_thread_pool_threads_set_locale();
 
    BOOST_LOG_TRIVIAL(info) << "Starting the slicing process." << log_memory_info();
    for (PrintObject *obj : m_objects)
        obj->make_perimeters();
    for (PrintObject *obj : m_objects)
        obj->infill();
    for (PrintObject *obj : m_objects)
        obj->ironing();
    for (PrintObject *obj : m_objects)
        obj->generate_support_spots();
    // check data from previous step, format the error message(s) and send alert to ui
    alert_when_supports_needed();
    for (PrintObject *obj : m_objects)
        obj->generate_support_material();
    for (PrintObject *obj : m_objects)
        obj->estimate_curled_extrusions();
    if (this->set_started(psWipeTower)) {
        m_wipe_tower_data.clear();
        m_tool_ordering.clear();
        if (this->has_wipe_tower()) {
            //this->set_status(95, _u8L("Generating wipe tower"));
            this->_make_wipe_tower();
        } else if (! this->config().complete_objects.value) {
          // Initialize the tool ordering, so it could be used by the G-code preview slider for planning tool changes and filament switches.
          m_tool_ordering = ToolOrdering(*this, -1, false);
            if (m_tool_ordering.empty() || m_tool_ordering.last_extruder() == unsigned(-1))
                throw Slic3r::SlicingError("The print is empty. The model is not printable with current print settings.");
        }
        this->set_done(psWipeTower);
    }
    if (this->set_started(psSkirtBrim)) {
        this->set_status(88, _u8L("Generating skirt and brim"));
 
        m_skirt.clear();
        m_skirt_convex_hull.clear();
        m_first_layer_convex_hull.points.clear();
        const bool draft_shield = config().draft_shield != dsDisabled;
 
        if (this->has_skirt() && draft_shield) {
            // In case that draft shield is active, generate skirt first so brim
            // can be trimmed to make room for it.
            _make_skirt();
        }
 
        m_brim.clear();
        m_first_layer_convex_hull.points.clear();
        if (this->has_brim()) {
            Polygons islands_area;
            m_brim = make_brim(*this, this->make_try_cancel(), islands_area);
            for (Polygon &poly : union_(this->first_layer_islands(), islands_area))
                append(m_first_layer_convex_hull.points, std::move(poly.points));
        }
 
 
        if (has_skirt() && ! draft_shield) {
            // In case that draft shield is NOT active, generate skirt now.
            // It will be placed around the brim, so brim has to be ready.
            assert(m_skirt.empty());
            _make_skirt();
        }
 
        this->finalize_first_layer_convex_hull();
        this->set_done(psSkirtBrim);
    }
 
    std::optional<const FakeWipeTower*> wipe_tower_opt = {};
    if (this->has_wipe_tower()) {
        m_fake_wipe_tower.set_pos_and_rotation({ m_config.wipe_tower_x, m_config.wipe_tower_y }, m_config.wipe_tower_rotation_angle);
        wipe_tower_opt = std::make_optional<const FakeWipeTower*>(&m_fake_wipe_tower);
    }
    auto conflictRes = ConflictChecker::find_inter_of_lines_in_diff_objs(m_objects, wipe_tower_opt);
 
    m_conflict_result = conflictRes;
    if (conflictRes.has_value())
        BOOST_LOG_TRIVIAL(error) << boost::format("gcode path conflicts found between %1% and %2%") % conflictRes->_objName1 % conflictRes->_objName2;
 
    BOOST_LOG_TRIVIAL(info) << "Slicing process finished." << log_memory_info();
}

References _make_skirt(), _make_wipe_tower(), _u8L, alert_when_supports_needed(), Slic3r::append(), Slic3r::ExtrusionEntityCollection::clear(), Slic3r::ToolOrdering::clear(), Slic3r::WipeTowerData::clear(), config(), Slic3r::dsDisabled, Slic3r::ExtrusionEntityCollection::empty(), Slic3r::ToolOrdering::empty(), error, finalize_first_layer_convex_hull(), Slic3r::ConflictChecker::find_inter_of_lines_in_diff_objs(), first_layer_islands(), has_brim(), has_skirt(), has_wipe_tower(), Slic3r::ToolOrdering::last_extruder(), Slic3r::log_memory_info(), m_brim, m_config, m_conflict_result, m_fake_wipe_tower, m_first_layer_convex_hull, m_objects, m_skirt, m_skirt_convex_hull, m_tool_ordering, m_wipe_tower_data, Slic3r::make_brim(), Slic3r::PrintBase::make_try_cancel(), Slic3r::name_tbb_thread_pool_threads_set_locale(), Slic3r::MultiPoint::points, Slic3r::psSkirtBrim, Slic3r::psWipeTower, Slic3r::PrintBaseWithState< PrintStep, psCount >::set_done(), Slic3r::FakeWipeTower::set_pos_and_rotation(), Slic3r::PrintBaseWithState< PrintStep, psCount >::set_started(), Slic3r::PrintBase::set_status(), and Slic3r::union_().

Here is the call 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:

◆ sequential_print_horizontal_clearance_valid()

bool Slic3r::Print::sequential_print_horizontal_clearance_valid	(	const Print &	print,
		Polygons *	polygons = `nullptr`
	)

static

{
  Polygons convex_hulls_other;
    if (polygons != nullptr)
        polygons->clear();
    std::vector<size_t> intersecting_idxs;
 
  std::map<ObjectID, Polygon> map_model_object_to_convex_hull;
  for (const PrintObject *print_object : print.objects()) {
      assert(! print_object->model_object()->instances.empty());
      assert(! print_object->instances().empty());
      ObjectID model_object_id = print_object->model_object()->id();
      auto it_convex_hull = map_model_object_to_convex_hull.find(model_object_id);
        // Get convex hull of all printable volumes assigned to this print object.
        ModelInstance *model_instance0 = print_object->model_object()->instances.front();
      if (it_convex_hull == map_model_object_to_convex_hull.end()) {
          // Calculate the convex hull of a printable object. 
          // Grow convex hull with the clearance margin.
          // FIXME: Arrangement has different parameters for offsetting (jtMiter, limit 2)
          // which causes that the warning will be showed after arrangement with the
          // appropriate object distance. Even if I set this to jtMiter the warning still shows up.
        Geometry::Transformation trafo = model_instance0->get_transformation();
        trafo.set_offset({ 0.0, 0.0, model_instance0->get_offset().z() });
          it_convex_hull = map_model_object_to_convex_hull.emplace_hint(it_convex_hull, model_object_id,
              offset(print_object->model_object()->convex_hull_2d(trafo.get_matrix()),
                  // Shrink the extruder_clearance_radius a tiny bit, so that if the object arrangement algorithm placed the objects
                  // exactly by satisfying the extruder_clearance_radius, this test will not trigger collision.
                  float(scale_(0.5 * print.config().extruder_clearance_radius.value - BuildVolume::BedEpsilon)),
                  jtRound, scale_(0.1)).front());
      }
      // Make a copy, so it may be rotated for instances.
      Polygon convex_hull0 = it_convex_hull->second;
    const double z_diff = Geometry::rotation_diff_z(model_instance0->get_matrix(), print_object->instances().front().model_instance->get_matrix());
    if (std::abs(z_diff) > EPSILON)
      convex_hull0.rotate(z_diff);
      // Now we check that no instance of convex_hull intersects any of the previously checked object instances.
      for (const PrintInstance &instance : print_object->instances()) {
          Polygon convex_hull = convex_hull0;
          // instance.shift is a position of a centered object, while model object may not be centered.
          // Convert the shift from the PrintObject's coordinates into ModelObject's coordinates by removing the centering offset.
          convex_hull.translate(instance.shift - print_object->center_offset());
            // if output needed, collect indices (inside convex_hulls_other) of intersecting hulls
            for (size_t i = 0; i < convex_hulls_other.size(); ++i) {
                if (! intersection(convex_hulls_other[i], convex_hull).empty()) {
                    if (polygons == nullptr)
                        return false;
                    else {
                        intersecting_idxs.emplace_back(i);
                        intersecting_idxs.emplace_back(convex_hulls_other.size());
                    }
                }
            }
            convex_hulls_other.emplace_back(std::move(convex_hull));
      }
  }
 
    if (!intersecting_idxs.empty()) {
        // use collected indices (inside convex_hulls_other) to update output
        std::sort(intersecting_idxs.begin(), intersecting_idxs.end());
        intersecting_idxs.erase(std::unique(intersecting_idxs.begin(), intersecting_idxs.end()), intersecting_idxs.end());
        for (size_t i : intersecting_idxs) {
            polygons->emplace_back(std::move(convex_hulls_other[i]));
        }
        return false;
    }
    return true;
}

References Slic3r::BuildVolume::BedEpsilon, config(), EPSILON, Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelInstance::get_matrix(), Slic3r::ModelInstance::get_offset(), Slic3r::ModelInstance::get_transformation(), Slic3r::ObjectID::id, Slic3r::intersection(), objects(), Slic3r::offset(), Slic3r::MultiPoint::rotate(), Slic3r::Geometry::rotation_diff_z(), scale_, and Slic3r::Geometry::Transformation::set_offset().

Referenced by validate().

Here is the call graph for this function:

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< PrintStep , 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< PrintStep , 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 alert_when_supports_needed(), export_gcode(), Slic3r::BackgroundSlicingProcess::finalize_gcode(), Slic3r::PrintObject::make_perimeters(), Slic3r::SLAPrint::StatusReporter::operator()(), Slic3r::BackgroundSlicingProcess::prepare_upload(), 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::Print::set_task ( const TaskParams & params )

inlineoverridevirtual

Implements Slic3r::PrintBase.

563{ PrintBaseWithState<PrintStep, psCount>::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

References m_objects, and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl().

Here is the call graph for this function:

◆ set_task_impl()

void Slic3r::PrintBaseWithState< PrintStep , 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);
        }
    }

◆ skirt()

const ExtrusionEntityCollection & Slic3r::Print::skirt ( ) const

inline

623{ return m_skirt; }

References m_skirt.

Referenced by Slic3r::GUI::GLCanvas3D::_load_print_toolpaths(), Slic3r::get_print_extrusions_extents(), Slic3r::Skirt::make_skirt_loops_per_extruder_1st_layer(), Slic3r::Skirt::make_skirt_loops_per_extruder_other_layers(), Slic3r::GCode::process_layer(), and Slic3r::Skirt::skirt_loops_per_extruder_all_printing().

Here is the caller graph for this function:

◆ skirt_first_layer_height()

double Slic3r::Print::skirt_first_layer_height ( ) const

{
    assert(! m_config.first_layer_height.percent);
    return m_config.first_layer_height.value;
}

References m_config.

Referenced by _make_skirt(), and _make_wipe_tower().

Here is the caller graph for this function:

◆ skirt_flow()

Flow Slic3r::Print::skirt_flow ( ) const

{
    ConfigOptionFloatOrPercent width = m_config.first_layer_extrusion_width;
    if (width.value == 0) 
        width = m_print_regions.front()->config().perimeter_extrusion_width;
    if (width.value == 0)
        width = m_objects.front()->config().extrusion_width;
    
    /* We currently use a random object's support material extruder.
       While this works for most cases, we should probably consider all of the support material
       extruders and take the one with, say, the smallest index;
       The same logic should be applied to the code that selects the extruder during G-code
       generation as well. */
    return Flow::new_from_config_width(
        frPerimeter,
    width,
    (float)m_config.nozzle_diameter.get_at(m_objects.front()->config().support_material_extruder-1),
    (float)this->skirt_first_layer_height());
}

References Slic3r::frPerimeter, m_config, m_objects, m_print_regions, and Slic3r::Flow::new_from_config_width().

Referenced by _make_skirt(), and Slic3r::GCode::process_layer().

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< PrintStep , 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< PrintStep , 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

◆ support_material_extruders()

std::vector< unsigned int > Slic3r::Print::support_material_extruders ( ) const

{
    std::vector<unsigned int> extruders;
    bool support_uses_current_extruder = false;
    auto num_extruders = (unsigned int)m_config.nozzle_diameter.size();
 
    for (PrintObject *object : m_objects) {
        if (object->has_support_material()) {
          assert(object->config().support_material_extruder >= 0);
            if (object->config().support_material_extruder == 0)
                support_uses_current_extruder = true;
            else {
              unsigned int i = (unsigned int)object->config().support_material_extruder - 1;
                extruders.emplace_back((i >= num_extruders) ? 0 : i);
            }
          assert(object->config().support_material_interface_extruder >= 0);
            if (object->config().support_material_interface_extruder == 0)
                support_uses_current_extruder = true;
            else {
              unsigned int i = (unsigned int)object->config().support_material_interface_extruder - 1;
                extruders.emplace_back((i >= num_extruders) ? 0 : i);
            }
        }
    }
 
    if (support_uses_current_extruder)
        // Add all object extruders to the support extruders as it is not know which one will be used to print supports.
        append(extruders, this->object_extruders());
    
    sort_remove_duplicates(extruders);
    return extruders;
}

References Slic3r::append(), extruders(), m_config, m_objects, object_extruders(), and Slic3r::sort_remove_duplicates().

Referenced by extruders().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ technology()

PrinterTechnology Slic3r::Print::technology ( ) const

inlineoverridevirtualnoexcept

Implements Slic3r::PrintBase.

550{ return ptFFF; }

Slic3r::ptFFF

@ ptFFF

Definition Config.hpp:207

References Slic3r::ptFFF.

◆ 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(), _make_skirt(), _make_wipe_tower(), Slic3r::SLAPrint::Steps::generate_pad(), Slic3r::SLAPrint::Steps::hollow_model(), Slic3r::PrintObject::make_perimeters(), Slic3r::PrintTryCancel::operator()(), Slic3r::SLAPrint::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:

◆ tool_ordering()

const ToolOrdering & Slic3r::Print::tool_ordering ( ) const

inline

638{ return m_tool_ordering; }

References m_tool_ordering.

Referenced by Slic3r::GCode::_do_export().

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::Print::validate ( std::vector< std::string > * warnings = nullptr ) const

overridevirtual

Reimplemented from Slic3r::PrintBase.

{
    std::vector<unsigned int> extruders = this->extruders();
 
    if (warnings) {
        for (size_t a=0; a<extruders.size(); ++a)
            for (size_t b=a+1; b<extruders.size(); ++b)
                if (std::abs(m_config.bed_temperature.get_at(extruders[a]) - m_config.bed_temperature.get_at(extruders[b])) > 15
                 || std::abs(m_config.first_layer_bed_temperature.get_at(extruders[a]) - m_config.first_layer_bed_temperature.get_at(extruders[b])) > 15) {
                    warnings->emplace_back("_BED_TEMPS_DIFFER");
                    goto DONE;
                }
        DONE:;
    }
 
    if (m_objects.empty())
        return _u8L("All objects are outside of the print volume.");
 
    if (extruders.empty())
        return _u8L("The supplied settings will cause an empty print.");
 
    if (m_config.complete_objects) {
        if (!sequential_print_horizontal_clearance_valid(*this, const_cast<Polygons*>(&m_sequential_print_clearance_contours)))
            return _u8L("Some objects are too close; your extruder will collide with them.");
        if (!sequential_print_vertical_clearance_valid(*this))
            return _u8L("Some objects are too tall and cannot be printed without extruder collisions.");
    }
    else
        const_cast<Polygons*>(&m_sequential_print_clearance_contours)->clear();
 
    if (m_config.avoid_crossing_perimeters && m_config.avoid_crossing_curled_overhangs) {
        return _u8L("Avoid crossing perimeters option and avoid crossing curled overhangs option cannot be both enabled together.");
    }    
 
    if (m_config.spiral_vase) {
        size_t total_copies_count = 0;
        for (const PrintObject *object : m_objects)
            total_copies_count += object->instances().size();
        // #4043
        if (total_copies_count > 1 && ! m_config.complete_objects.value)
            return _u8L("Only a single object may be printed at a time in Spiral Vase mode. "
                     "Either remove all but the last object, or enable sequential mode by \"complete_objects\".");
        assert(m_objects.size() == 1);
        if (m_objects.front()->all_regions().size() > 1)
            return _u8L("The Spiral Vase option can only be used when printing single material objects.");
    }
 
    if (m_config.machine_limits_usage == MachineLimitsUsage::EmitToGCode && m_config.gcode_flavor == gcfKlipper)
        return L("Machine limits cannot be emitted to G-Code when Klipper firmware flavor is used. "
                 "Change the value of machine_limits_usage.");
 
    // Cache of layer height profiles for checking:
    // 1) Whether all layers are synchronized if printing with wipe tower and / or unsynchronized supports.
    // 2) Whether layer height is constant for Organic supports.
    // 3) Whether build volume Z is not violated.
    std::vector<std::vector<coordf_t>> layer_height_profiles;
    auto layer_height_profile = [this, &layer_height_profiles](const size_t print_object_idx) -> const std::vector<coordf_t>& {
        const PrintObject       &print_object = *m_objects[print_object_idx];
        if (layer_height_profiles.empty())
            layer_height_profiles.assign(m_objects.size(), std::vector<coordf_t>());
        std::vector<coordf_t>   &profile      = layer_height_profiles[print_object_idx];
        if (profile.empty())
            PrintObject::update_layer_height_profile(*print_object.model_object(), print_object.slicing_parameters(), profile);
        return profile;
    };
 
    // Checks that the print does not exceed the max print height
    for (size_t print_object_idx = 0; print_object_idx < m_objects.size(); ++ print_object_idx) {
        const PrintObject &print_object = *m_objects[print_object_idx];
        //FIXME It is quite expensive to generate object layers just to get the print height!
        if (auto layers = generate_object_layers(print_object.slicing_parameters(), layer_height_profile(print_object_idx));
            ! layers.empty() && layers.back() > this->config().max_print_height + EPSILON) {
            return
                // Test whether the last slicing plane is below or above the print volume.
                0.5 * (layers[layers.size() - 2] + layers.back()) > this->config().max_print_height + EPSILON ?
                format(_u8L("The object %1% exceeds the maximum build volume height."), print_object.model_object()->name) :
                format(_u8L("While the object %1% itself fits the build volume, its last layer exceeds the maximum build volume height."), print_object.model_object()->name) +
                " " + _u8L("You might want to reduce the size of your model or change current print settings and retry.");
        }
    }
 
    // Some of the objects has variable layer height applied by painting or by a table.
    bool has_custom_layering = std::find_if(m_objects.begin(), m_objects.end(), 
        [](const PrintObject *object) { return object->model_object()->has_custom_layering(); }) 
        != m_objects.end();
 
    // Custom layering is not allowed for tree supports as of now.
    for (size_t print_object_idx = 0; print_object_idx < m_objects.size(); ++ print_object_idx)
        if (const PrintObject &print_object = *m_objects[print_object_idx];
            print_object.has_support_material() && print_object.config().support_material_style.value == smsOrganic &&
            print_object.model_object()->has_custom_layering()) {
            if (const std::vector<coordf_t> &layers = layer_height_profile(print_object_idx); ! layers.empty())
                if (! check_object_layers_fixed(print_object.slicing_parameters(), layers))
                    return _u8L("Variable layer height is not supported with Organic supports.");
        }
 
    if (this->has_wipe_tower() && ! m_objects.empty()) {
        // Make sure all extruders use same diameter filament and have the same nozzle diameter
        // EPSILON comparison is used for nozzles and 10 % tolerance is used for filaments
        double first_nozzle_diam = m_config.nozzle_diameter.get_at(extruders.front());
        double first_filament_diam = m_config.filament_diameter.get_at(extruders.front());
        for (const auto& extruder_idx : extruders) {
            double nozzle_diam = m_config.nozzle_diameter.get_at(extruder_idx);
            double filament_diam = m_config.filament_diameter.get_at(extruder_idx);
            if (nozzle_diam - EPSILON > first_nozzle_diam || nozzle_diam + EPSILON < first_nozzle_diam
             || std::abs((filament_diam-first_filament_diam)/first_filament_diam) > 0.1)
                 return _u8L("The wipe tower is only supported if all extruders have the same nozzle diameter "
                          "and use filaments of the same diameter.");
        }
 
        if (m_config.gcode_flavor != gcfRepRapSprinter && m_config.gcode_flavor != gcfRepRapFirmware &&
            m_config.gcode_flavor != gcfRepetier && m_config.gcode_flavor != gcfMarlinLegacy &&
            m_config.gcode_flavor != gcfMarlinFirmware && m_config.gcode_flavor != gcfKlipper)
            return _u8L("The Wipe Tower is currently only supported for the Marlin, Klipper, RepRap/Sprinter, RepRapFirmware and Repetier G-code flavors.");
        if (! m_config.use_relative_e_distances)
            return _u8L("The Wipe Tower is currently only supported with the relative extruder addressing (use_relative_e_distances=1).");
        if (m_config.ooze_prevention && m_config.single_extruder_multi_material)
            return _u8L("Ooze prevention is only supported with the wipe tower when 'single_extruder_multi_material' is off.");
        if (m_config.use_volumetric_e)
            return _u8L("The Wipe Tower currently does not support volumetric E (use_volumetric_e=0).");
        if (m_config.complete_objects && extruders.size() > 1)
            return _u8L("The Wipe Tower is currently not supported for multimaterial sequential prints.");
        
        if (m_objects.size() > 1) {
            const SlicingParameters     &slicing_params0       = m_objects.front()->slicing_parameters();
            size_t                       tallest_object_idx    = 0;
            for (size_t i = 1; i < m_objects.size(); ++ i) {
                const PrintObject       *object         = m_objects[i];
                const SlicingParameters &slicing_params = object->slicing_parameters();
                if (std::abs(slicing_params.first_print_layer_height - slicing_params0.first_print_layer_height) > EPSILON ||
                    std::abs(slicing_params.layer_height             - slicing_params0.layer_height            ) > EPSILON)
                    return _u8L("The Wipe Tower is only supported for multiple objects if they have equal layer heights");
                if (slicing_params.raft_layers() != slicing_params0.raft_layers())
                    return _u8L("The Wipe Tower is only supported for multiple objects if they are printed over an equal number of raft layers");
                if (slicing_params0.gap_object_support != slicing_params.gap_object_support ||
                    slicing_params0.gap_support_object != slicing_params.gap_support_object)
                    return _u8L("The Wipe Tower is only supported for multiple objects if they are printed with the same support_material_contact_distance");
                if (! equal_layering(slicing_params, slicing_params0))
                    return _u8L("The Wipe Tower is only supported for multiple objects if they are sliced equally.");
                if (has_custom_layering) {
                    auto &lh         = layer_height_profile(i);
                    auto &lh_tallest = layer_height_profile(tallest_object_idx);
                    if (*(lh.end()-2) > *(lh_tallest.end()-2))
                        tallest_object_idx = i;
                }
           }
 
            if (has_custom_layering) {
                for (size_t idx_object = 0; idx_object < m_objects.size(); ++ idx_object) {
                    if (idx_object == tallest_object_idx)
                        continue;
                    // Check that the layer height profiles are equal. This will happen when one object is
                    // a copy of another, or when a layer height modifier is used the same way on both objects.
                    // The latter case might create a floating point inaccuracy mismatch, so compare
                    // element-wise using an epsilon check.
                    size_t i = 0;
                    const coordf_t eps = 0.5 * EPSILON; // layers closer than EPSILON will be merged later. Let's make
                    // this check a bit more sensitive to make sure we never consider two different layers as one.
                    while (i < layer_height_profiles[idx_object].size()
                        && i < layer_height_profiles[tallest_object_idx].size()) {
                        if (i%2 == 0 && layer_height_profiles[tallest_object_idx][i] > layer_height_profiles[idx_object][layer_height_profiles[idx_object].size() - 2 ])
                            break;
                        if (std::abs(layer_height_profiles[idx_object][i] - layer_height_profiles[tallest_object_idx][i]) > eps)
                            return _u8L("The Wipe tower is only supported if all objects have the same variable layer height");
                        ++i;
                    }
                }
            }
        }
    }
    
  {
    // Find the smallest used nozzle diameter and the number of unique nozzle diameters.
    double min_nozzle_diameter = std::numeric_limits<double>::max();
    double max_nozzle_diameter = 0;
    for (unsigned int extruder_id : extruders) {
      double dmr = m_config.nozzle_diameter.get_at(extruder_id);
      min_nozzle_diameter = std::min(min_nozzle_diameter, dmr);
      max_nozzle_diameter = std::max(max_nozzle_diameter, dmr);
    }
 
#if 0
        // We currently allow one to assign extruders with a higher index than the number
        // of physical extruders the machine is equipped with, as the Printer::apply() clamps them.
        unsigned int total_extruders_count = m_config.nozzle_diameter.size();
        for (const auto& extruder_idx : extruders)
            if ( extruder_idx >= total_extruders_count )
                return _u8L("One or more object were assigned an extruder that the printer does not have.");
#endif
 
        auto validate_extrusion_width = [/*min_nozzle_diameter,*/ max_nozzle_diameter](const ConfigBase &config, const char *opt_key, double layer_height, std::string &err_msg) -> bool {
            // This may change in the future, if we switch to "extrusion width wrt. nozzle diameter"
            // instead of currently used logic "extrusion width wrt. layer height", see GH issues #1923 #2829.
//          double extrusion_width_min = config.get_abs_value(opt_key, min_nozzle_diameter);
//          double extrusion_width_max = config.get_abs_value(opt_key, max_nozzle_diameter);
            double extrusion_width_min = config.get_abs_value(opt_key, layer_height);
            double extrusion_width_max = config.get_abs_value(opt_key, layer_height);
          if (extrusion_width_min == 0) {
            // Default "auto-generated" extrusion width is always valid.
          } else if (extrusion_width_min <= layer_height) {
            err_msg = (boost::format(_u8L("%1%=%2% mm is too low to be printable at a layer height %3% mm")) % opt_key % extrusion_width_min % layer_height).str();
        return false;
      } else if (extrusion_width_max >= max_nozzle_diameter * 3.) {
        err_msg = (boost::format(_u8L("Excessive %1%=%2% mm to be printable with a nozzle diameter %3% mm")) % opt_key % extrusion_width_max % max_nozzle_diameter).str();
        return false;
      }
      return true;
    };
        for (PrintObject *object : m_objects) {
            if (object->has_support_material()) {
        if ((object->config().support_material_extruder == 0 || object->config().support_material_interface_extruder == 0) && max_nozzle_diameter - min_nozzle_diameter > EPSILON) {
                    // The object has some form of support and either support_material_extruder or support_material_interface_extruder
                    // will be printed with the current tool without a forced tool change. Play safe, assert that all object nozzles
                    // are of the same diameter.
                    return _u8L("Printing with multiple extruders of differing nozzle diameters. "
                           "If support is to be printed with the current extruder (support_material_extruder == 0 or support_material_interface_extruder == 0), "
                           "all nozzles have to be of the same diameter.");
                }
                if (this->has_wipe_tower() && object->config().support_material_style != smsOrganic) {
            if (object->config().support_material_contact_distance == 0) {
              // Soluble interface
              if (! object->config().support_material_synchronize_layers)
                return _u8L("For the Wipe Tower to work with the soluble supports, the support layers need to be synchronized with the object layers.");
            } else {
              // Non-soluble interface
              if (object->config().support_material_extruder != 0 || object->config().support_material_interface_extruder != 0)
                return _u8L("The Wipe Tower currently supports the non-soluble supports only if they are printed with the current extruder without triggering a tool change. "
                       "(both support_material_extruder and support_material_interface_extruder need to be set to 0).");
            }
                }
            }
 
            // Do we have custom support data that would not be used?
            // Notify the user in that case.
            if (! object->has_support() && warnings) {
                for (const ModelVolume* mv : object->model_object()->volumes) {
                    bool has_enforcers = mv->is_support_enforcer() || 
                        (mv->is_model_part() && mv->supported_facets.has_facets(*mv, EnforcerBlockerType::ENFORCER));
                    if (has_enforcers) {
                        warnings->emplace_back("_SUPPORTS_OFF");
                        break;
                    }
                }
            }
 
            // validate first_layer_height
            assert(! m_config.first_layer_height.percent);
            double first_layer_height = m_config.first_layer_height.value;
            double first_layer_min_nozzle_diameter;
            if (object->has_raft()) {
                // if we have raft layers, only support material extruder is used on first layer
                size_t first_layer_extruder = object->config().raft_layers == 1
                    ? object->config().support_material_interface_extruder-1
                    : object->config().support_material_extruder-1;
                first_layer_min_nozzle_diameter = (first_layer_extruder == size_t(-1)) ? 
                    min_nozzle_diameter : 
                    m_config.nozzle_diameter.get_at(first_layer_extruder);
            } else {
                // if we don't have raft layers, any nozzle diameter is potentially used in first layer
                first_layer_min_nozzle_diameter = min_nozzle_diameter;
            }
            if (first_layer_height > first_layer_min_nozzle_diameter)
                return _u8L("First layer height can't be greater than nozzle diameter");
            
            // validate layer_height
            double layer_height = object->config().layer_height.value;
            if (layer_height > min_nozzle_diameter)
                return _u8L("Layer height can't be greater than nozzle diameter");
 
            // Validate extrusion widths.
            std::string err_msg;
            if (! validate_extrusion_width(object->config(), "extrusion_width", layer_height, err_msg))
              return err_msg;
            if ((object->has_support() || object->has_raft()) && ! validate_extrusion_width(object->config(), "support_material_extrusion_width", layer_height, err_msg))
              return err_msg;
            for (const char *opt_key : { "perimeter_extrusion_width", "external_perimeter_extrusion_width", "infill_extrusion_width", "solid_infill_extrusion_width", "top_infill_extrusion_width" })
        for (const PrintRegion &region : object->all_regions())
                if (! validate_extrusion_width(region.config(), opt_key, layer_height, err_msg))
                  return err_msg;
        }
    }
    {
        bool before_layer_gcode_resets_extruder = boost::regex_search(m_config.before_layer_gcode.value, regex_g92e0);
        bool layer_gcode_resets_extruder        = boost::regex_search(m_config.layer_gcode.value, regex_g92e0);
        if (m_config.use_relative_e_distances) {
            // See GH issues #6336 #5073
            if ((m_config.gcode_flavor == gcfMarlinLegacy || m_config.gcode_flavor == gcfMarlinFirmware) &&
                ! before_layer_gcode_resets_extruder && ! layer_gcode_resets_extruder)
                return _u8L("Relative extruder addressing requires resetting the extruder position at each layer to prevent loss of floating point accuracy. Add \"G92 E0\" to layer_gcode.");
        } else if (before_layer_gcode_resets_extruder)
            return _u8L("\"G92 E0\" was found in before_layer_gcode, which is incompatible with absolute extruder addressing.");
        else if (layer_gcode_resets_extruder)
                return _u8L("\"G92 E0\" was found in layer_gcode, which is incompatible with absolute extruder addressing.");
    }
 
    return std::string();
}

References _u8L, Slic3r::check_object_layers_fixed(), clear(), Slic3r::PrintObject::config(), config(), Slic3r::EmitToGCode, Slic3r::ENFORCER, EPSILON, Slic3r::equal_layering(), extruders(), Slic3r::SlicingParameters::first_print_layer_height, Slic3r::format(), Slic3r::SlicingParameters::gap_object_support, Slic3r::SlicingParameters::gap_support_object, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, Slic3r::generate_object_layers(), Slic3r::PrintObject::has_raft(), Slic3r::PrintObject::has_support(), Slic3r::PrintObject::has_support_material(), has_wipe_tower(), L, Slic3r::layer_height(), Slic3r::SlicingParameters::layer_height, m_config, m_objects, m_sequential_print_clearance_contours, Slic3r::PrintObjectBase::model_object(), Slic3r::ModelObject::name, Slic3r::SlicingParameters::raft_layers(), Slic3r::regex_g92e0, sequential_print_horizontal_clearance_valid(), Slic3r::sequential_print_vertical_clearance_valid(), Slic3r::PrintObject::slicing_parameters(), Slic3r::smsOrganic, and Slic3r::PrintObject::update_layer_height_profile().

Here is the call graph for this function:

◆ wipe_tower_data()

const WipeTowerData & Slic3r::Print::wipe_tower_data ( size_t extruders_cnt = 0 ) const

{
    // If the wipe tower wasn't created yet, make sure the depth and brim_width members are set to default.
    if (! is_step_done(psWipeTower) && extruders_cnt !=0) {
        const_cast<Print*>(this)->m_wipe_tower_data.brim_width = m_config.wipe_tower_brim_width;
 
        // Calculating depth should take into account currently set wiping volumes.
        // For a long time, the initial preview would just use 900/width per toolchange (15mm on a 60mm wide tower)
        // and it worked well enough. Let's try to do slightly better by accounting for the purging volumes.
        std::vector<std::vector<float>> wipe_volumes = WipeTower::extract_wipe_volumes(m_config);
        std::vector<float> max_wipe_volumes;
        for (const std::vector<float>& v : wipe_volumes)
            max_wipe_volumes.emplace_back(*std::max_element(v.begin(), v.end()));
        float maximum = std::accumulate(max_wipe_volumes.begin(), max_wipe_volumes.end(), 0.f);
        maximum = maximum * extruders_cnt / max_wipe_volumes.size();
 
        float width = float(m_config.wipe_tower_width);
        float layer_height = 0.2f; // just assume fixed value, it will still be better than before.
 
        const_cast<Print*>(this)->m_wipe_tower_data.depth = (maximum/layer_height)/width;
        const_cast<Print*>(this)->m_wipe_tower_data.height = -1.f; // unknown yet
    }
 
    return m_wipe_tower_data;
}

References Slic3r::WipeTowerData::brim_width, Slic3r::WipeTowerData::depth, Slic3r::WipeTower::extract_wipe_volumes(), Slic3r::WipeTowerData::height, is_step_done(), Slic3r::layer_height(), m_config, m_wipe_tower_data, and Slic3r::psWipeTower.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GUI::GLCanvas3D::_load_wipe_tower_toolpaths(), Slic3r::get_wipe_tower_extrusions_extents(), Slic3r::get_wipe_tower_priming_extrusions_extents(), Slic3r::GUI::GCodeViewer::load_shells(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ GCode

friend class GCode

friend

◆ GCodeProcessor

friend class GCodeProcessor

friend

◆ PrintObject

friend class PrintObject

friend

Member Data Documentation

◆ m_brim

ExtrusionEntityCollection Slic3r::Print::m_brim

private

Referenced by brim(), and process().

◆ 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_config

PrintConfig Slic3r::Print::m_config

private

Referenced by _make_skirt(), _make_wipe_tower(), brim_flow(), config(), first_layer_wipe_tower_corners(), has_infinite_skirt(), has_skirt(), has_wipe_tower(), max_allowed_layer_height(), output_filename(), process(), skirt_first_layer_height(), skirt_flow(), support_material_extruders(), validate(), and wipe_tower_data().

◆ m_conflict_result

ConflictResultOpt Slic3r::Print::m_conflict_result

private

Referenced by export_gcode(), and process().

◆ m_default_object_config

PrintObjectConfig Slic3r::Print::m_default_object_config

private

Referenced by default_object_config().

◆ m_default_region_config

PrintRegionConfig Slic3r::Print::m_default_region_config

private

Referenced by default_region_config().

◆ m_fake_wipe_tower

FakeWipeTower Slic3r::Print::m_fake_wipe_tower

private

Referenced by _make_wipe_tower(), and process().

◆ m_first_layer_convex_hull

Polygon Slic3r::Print::m_first_layer_convex_hull

private

Referenced by _make_skirt(), finalize_first_layer_convex_hull(), first_layer_convex_hull(), and process().

◆ m_full_print_config

DynamicPrintConfig Slic3r::PrintBase::m_full_print_config

protectedinherited

Referenced by Slic3r::SLAPrint::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_model

Model Slic3r::PrintBase::m_model

protectedinherited

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

◆ m_objects

◆ m_placeholder_parser

PlaceholderParser Slic3r::PrintBase::m_placeholder_parser

protectedinherited

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

◆ m_print_regions

PrintRegionPtrs Slic3r::Print::m_print_regions

private

Referenced by brim_flow(), clear(), get_print_region(), num_print_regions(), object_extruders(), print_regions_mutable(), and skirt_flow().

◆ m_print_statistics

PrintStatistics Slic3r::Print::m_print_statistics

private

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::do_export(), print_statistics(), and print_statistics().

◆ m_sequential_print_clearance_contours

Polygons Slic3r::Print::m_sequential_print_clearance_contours

private

Referenced by get_sequential_print_clearance_contours(), and validate().

◆ m_skirt

ExtrusionEntityCollection Slic3r::Print::m_skirt

private

Referenced by _make_skirt(), process(), and skirt().

◆ m_skirt_convex_hull

Points Slic3r::Print::m_skirt_convex_hull

private

Referenced by _make_skirt(), finalize_first_layer_convex_hull(), and process().

◆ m_state

PrintState<PrintStepEnum, COUNT> Slic3r::PrintBaseWithState< PrintStep , 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().

◆ m_tool_ordering

ToolOrdering Slic3r::Print::m_tool_ordering

private

Referenced by process(), and tool_ordering().

◆ m_wipe_tower_data

WipeTowerData Slic3r::Print::m_wipe_tower_data {m_tool_ordering}

private

Referenced by _make_wipe_tower(), first_layer_wipe_tower_corners(), get_tool_ordering(), process(), and wipe_tower_data().

◆ PrintStepEnumSize

constexpr const size_t Slic3r::PrintBaseWithState< PrintStep , 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().

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

src/libslic3r/Print.hpp
src/libslic3r/Print.cpp
src/libslic3r/PrintApply.cpp

Private Attributes
PrintConfig	m_config

PrintObjectConfig	m_default_object_config

PrintRegionConfig	m_default_region_config

PrintObjectPtrs	m_objects

PrintRegionPtrs	m_print_regions

ExtrusionEntityCollection	m_skirt

ExtrusionEntityCollection	m_brim

Polygon	m_first_layer_convex_hull

Points	m_skirt_convex_hull

ToolOrdering	m_tool_ordering

WipeTowerData	m_wipe_tower_data {m_tool_ordering}

PrintStatistics	m_print_statistics

Polygons	m_sequential_print_clearance_contours

ConflictResultOpt	m_conflict_result

FakeWipeTower	m_fake_wipe_tower

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

Public Types

Public Member Functions

Static 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

Friends

Detailed Description

Member Typedef Documentation

◆ cancel_callback_type

◆ Inherited

◆ PrintObjectInfo

◆ PrintStepEnum

◆ status_callback_type

◆ Timestamp

Member Enumeration Documentation

◆ ApplyStatus

◆ CancelStatus

Constructor & Destructor Documentation

◆ Print()

◆ ~Print()

Member Function Documentation

◆ _make_skirt()

◆ _make_wipe_tower()

◆ active_step_add_warning()

◆ alert_when_supports_needed()

◆ apply()

◆ assign_new_unique_ids_recursive()

◆ auto_assign_extruders()

◆ brim()

◆ brim_flow()

◆ call_cancel_callback()

◆ cancel()

◆ cancel_callback()

◆ cancel_internal()

◆ cancel_status()

◆ canceled()

◆ cleanup()

◆ clear()

◆ config()

◆ copy_id()

◆ default_object_config()

◆ default_region_config()

◆ empty()

◆ export_gcode()

◆ extruders()

◆ finalize()

◆ finalize_first_layer_convex_hull()

◆ finalize_impl()

◆ finished()

◆ first_layer_convex_hull()

◆ first_layer_islands()

◆ first_layer_wipe_tower_corners()

◆ full_print_config()

◆ generate_new_id()

◆ get_object() [1/3]

◆ get_object() [2/3]

◆ get_object() [3/3]

◆ get_print_object_by_model_object_id()

◆ get_print_region()

◆ get_sequential_print_clearance_contours()

◆ get_tool_ordering()

◆ has_brim()

◆ has_infinite_skirt()

◆ has_skirt()

◆ has_support_material()

◆ has_wipe_tower()

◆ id()

◆ invalidate_all_steps()

◆ invalidate_state_by_config_options()

◆ invalidate_step()

◆ invalidate_steps() [1/2]

◆ invalidate_steps() [2/2]

◆ is_shared_print_object_step_valid_unguarded()

◆ is_step_done() [1/2]