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

Inheritance diagram for Slic3r::Print:

Collaboration diagram for Slic3r::Print:

Classes
struct	SkirtBrimGroup
struct	FilamentIndexKey
struct	PrintIndexKey
struct	FilamentIndexKeyHash
struct	PrintIndexKeyHash

Public Types
using	SlicingPipelineHookFn = std::function<void(Print&, const PrintObject*, SlicingPipelineStepPlugin)>
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, bool extruder_applied=false) override
void	process (long long *time_cost_with_cache=nullptr, bool use_cache=false) override
std::string	export_gcode (const std::string &path_template, GCodeProcessorResult *result, ThumbnailsGeneratorCallback thumbnail_cb=nullptr)
int	export_cached_data (const std::string &dir_path, bool with_space=false) override
int	load_cached_data (const std::string &directory) override
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
bool	has_tilted_belt () const
bool	has_belt_brim () const
bool	has_auto_brim () const
StringObjectException	validate (std::vector< StringObjectException > warnings=nullptr, Polygons collison_polygons=nullptr, std::vector< std::pair< Polygon, float > > *height_polygons=nullptr) const override
std::string	slicing_errors_message (const SlicingErrors &errors) const
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 (bool conside_custom_gcode=false) 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
ConstPrintObjectPtrsAdaptor	objects () const
PrintObject *	get_object (size_t idx)
const PrintObject *	get_object (size_t idx) const
const PrintObject *	get_object (ObjectID object_id) const
std::map< ObjectID, ExtrusionEntityCollection > &	get_brimMap ()
unsigned int	num_object_instances () const
PrintObjectPtrs &	objects_mutable ()
PrintRegionPtrs &	print_regions_mutable ()
std::vector< size_t >	layers_sorted_for_object (float start, float end, std::vector< LayerPtrs > &layers_of_objects, std::vector< BoundingBox > &boundingBox_for_objects, VecOfPoints &objects_instances_shift)
const ExtrusionEntityCollection &	skirt () const
const std::vector< SkirtBrimGroup > &	skirt_brim_groups () const
bool	has_shared_per_object_skirt () const
const Polygon &	first_layer_convex_hull () const
const PrintStatistics &	print_statistics () const
PrintStatistics &	print_statistics ()
const StatisticsByExtruderCount	statistics_by_extruder () const
StatisticsByExtruderCount &	statistics_by_extruder ()
bool	has_wipe_tower () const
bool	has_belt_purge_tower () const
const WipeTowerData &	wipe_tower_data (size_t filaments_cnt=0) const
const ToolOrdering &	tool_ordering () const
void	update_filament_maps_to_config (std::vector< int > f_maps, std::vector< int > f_volume_maps=std::vector< int >{}, std::vector< int > f_nozzle_maps=std::vector< int >{})
void	update_to_config_by_nozzle_group_result (const MultiNozzleUtils::LayeredNozzleGroupResult &group_result)
void	apply_config_for_render (const DynamicConfig &config)
std::vector< int >	get_filament_maps () const
FilamentMapMode	get_filament_map_mode () const
std::vector< int >	get_filament_volume_maps () const
std::vector< int >	get_filament_nozzle_maps () const
size_t	get_extruder_id (unsigned int filament_id) const
Polygons	get_extruder_shared_printable_polygon () const
void	set_nozzle_group_result (std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase > result)
std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase >	get_nozzle_group_result () const
std::shared_ptr< MultiNozzleUtils::LayeredNozzleGroupResult >	get_layered_nozzle_group_result () const
bool	is_dynamic_group_reorder () const
const std::map< const PrintObject *, ToolOrdering > &	sequential_dynamic_orderings () const
const std::vector< std::vector< DynamicPrintConfig > > &	get_extruder_filament_info () const
void	set_extruder_filament_info (const std::vector< std::vector< DynamicPrintConfig > > &filament_info)
void	set_geometric_unprintable_filaments (const std::vector< std::set< int > > &unprintables_filament_ids)
std::vector< std::set< int > >	get_geometric_unprintable_filaments () const
void	set_slice_used_filaments (const std::vector< unsigned int > &first_layer_used_filaments, const std::vector< unsigned int > &used_filaments)
std::vector< unsigned int >	get_slice_used_filaments (bool first_layer) const
void	set_slice_used_mixed_filaments (const std::vector< unsigned int > &used_mixed_filaments)
const std::vector< unsigned int > &	get_slice_used_mixed_filaments () const
std::vector< std::set< int > >	get_physical_unprintable_filaments (const std::vector< unsigned int > &used_filaments) const
	Determines the unprintable filaments for each extruder based on its physical attributes.
std::map< int, std::set< NozzleVolumeType > >	get_filament_unprintable_flow (const std::vector< unsigned int > &used_filaments) const
	Determines the forbidden nozzle volume types for each used filament.
std::vector< double >	get_extruder_printable_height () const
std::vector< Polygons >	get_extruder_printable_polygons () const
std::vector< Polygons >	get_extruder_unprintable_polygons () const
bool	enable_timelapse_print () const
std::string	output_filename (const std::string &filename_base=std::string()) const override
std::string	get_model_name () const
std::string	get_plate_number_formatted () const
size_t	num_print_regions () const throw ()
const PrintRegion &	get_print_region (size_t idx) const
const ToolOrdering &	get_tool_ordering () const
void	set_plate_origin (Vec3d origin)
const Vec3d	get_plate_origin () const
void	update_imex_slice_offset ()
Vec2d	get_imex_slice_offset () const
void	set_gcode_file_ready ()
void	set_gcode_file_invalidated ()
void	export_gcode_from_previous_file (const std::string &file, GCodeProcessorResult *result, ThumbnailsGeneratorCallback thumbnail_cb=nullptr)
void	reload_gcode_moves (GCodeProcessorResult *result) const
int	get_modified_count () const
bool	is_support_used () const
std::string	get_conflict_string () const
ConflictResultOpt	get_conflict_result () const
Points	first_layer_wipe_tower_corners (bool check_wipe_tower_existance=true) const
bool &	is_BBL_printer ()
const bool	is_BBL_printer () const
WipeTowerType	wipe_tower_type () const
CalibMode &	calib_mode ()
const CalibMode	calib_mode () const
void	set_calib_params (const Calib_Params &params)
const Calib_Params &	calib_params () const
Vec2d	translate_to_print_space (const Vec2d &point) const
void	validate_compacted_wipe_tower_clearance () const
float	get_wipe_tower_depth () const
BoundingBoxf	get_wipe_tower_bbx () const
Vec2f	get_rib_offset () const
const FakeWipeTower &	get_fake_wipe_tower () const
void	set_check_multi_filaments_compatibility (bool check)
bool	need_check_multi_filaments_compatibility () const
Vec2d	translate_to_print_space (const Point &point) const
bool	is_all_objects_are_short () const
int	get_filament_config_indx (int filament_id, int layer_id, bool use_cache=true)
int	get_nozzle_config_index (int filament_id, int layer_id)
size_t	config_index_generation () const
bool	has_same_shrinkage_compensations () const
Vec3d	shrinkage_compensation () const
std::tuple< float, float >	object_skirt_offset (double margin_height=0) const
PrintStateBase::StateWithTimeStamp	step_state_with_timestamp (PrintStep step) const
PrintStateBase::StateWithWarnings	step_state_with_warnings (PrintStep step) const
void	active_step_add_warning (PrintStateBase::WarningLevel warning_level, const std::string &message, PrintStateBase::SlicingNotificationType message_id=PrintStateBase::SlicingDefaultNotification)
const Model &	model () const
virtual void	set_task (const TaskParams &params)
virtual void	finalize ()
void	set_status_default ()
void	set_status_silent ()
void	set_status_callback (status_callback_type cb)
void	set_status (int percent, const std::string &message, unsigned int flags=SlicingStatus::DEFAULT, int warning_step=-1) const
void	set_cancel_callback (cancel_callback_type cancel_callback)
CancelStatus	cancel_status () const
bool	canceled () const
void	cancel ()
void	cancel_internal ()
void	restart ()
const PlaceholderParser &	placeholder_parser () const
const DynamicPrintConfig &	full_print_config () const
std::string	output_filepath (const std::string &path, const std::string &filename_base=std::string()) const
int	get_plate_index () const
void	set_plate_index (int index)
bool	get_no_check_flag () const
void	set_no_check_flag (bool no_check)
std::string	get_plate_name () const
void	set_plate_name (const std::string &name)
ObjectID	id () const
virtual Timestamp	timestamp () const

Static Public Member Functions
static void	set_slicing_pipeline_hook_fn (SlicingPipelineHookFn fn)
static StringObjectException	sequential_print_clearance_valid (const Print &print, Polygons polygons=nullptr, std::vector< std::pair< Polygon, float > > height_polygons=nullptr)
static StringObjectException	compacted_wipe_tower_clearance_valid (const Print &print, Polygons polygons=nullptr, std::vector< std::pair< Polygon, float > > height_polygons=nullptr)
static FilamentTempType	get_filament_temp_type (const std::string &filament_type)
static int	get_hrc_by_nozzle_type (const NozzleType &type)
static std::vector< std::string >	get_incompatible_filaments_by_nozzle (const float nozzle_diameter, const std::optional< NozzleVolumeType > nozzle_volume_type=std::nullopt)
static FilamentCompatibilityType	check_multi_filaments_compatibility (const std::vector< std::string > &filament_types, const std::vector< int > &nozzle_temperatures, const std::vector< int > &nozzle_temperature_range_lows, const std::vector< int > &nozzle_temperature_range_highs)
static bool	is_filaments_compatible (const std::vector< int > &types)
static int	get_compatible_filament_type (const std::set< int > &types)

Protected Types
using	FilamentIndexMap = std::unordered_map<FilamentIndexKey, int, FilamentIndexKeyHash>
using	PrintIndexMap = std::unordered_map<PrintIndexKey, int, PrintIndexKeyHash>

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

Protected Attributes
Model	m_model
DynamicPrintConfig	m_full_print_config
DynamicPrintConfig	m_ori_full_print_config
PlaceholderParser	m_placeholder_parser
int	m_plate_index { 0 }
bool	m_no_check = false
std::string	m_plate_name
status_callback_type	m_status_callback

Private Types
typedef PrintBaseWithState< PrintStep, psCount >	Inherited
typedef std::pair< PrintObject *, bool >	PrintObjectInfo

Private Member Functions
bool	has_tpu_filament () const
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	_plan_belt_purge ()
void	_align_belt_purge_layers ()
void	finalize_first_layer_convex_hull ()
void	update_filament_self_index_cache ()
bool	collect_filament_variant_uses (const MultiNozzleUtils::LayeredNozzleGroupResult &group_result, const DynamicPrintConfig &config, std::unordered_map< int, std::vector< FilamentVariantUse > > &uses) const
Polygons	first_layer_islands () const
void	run_pipeline_hook (SlicingPipelineStepPlugin step, const PrintObject *object)
void	append_tool_change_extruders (std::vector< unsigned int > &extruders) const
void	append_wipe_tower_extruder (std::vector< unsigned int > &extruders) const
void	update_shrinkage_compensation (size_t num_extruders, std::vector< int > &variant_index)
template<class Archive>
void	serialize (Archive &ar)

Static Private Member Functions
static StringObjectException	check_multi_filament_valid (const Print &print)
static void	append_model_object_extruders (const ModelObject &mo, std::vector< unsigned int > &extruders)
static bool	append_support_extruders (const PrintObjectConfig &config, unsigned int num_extruders, std::vector< unsigned int > &extruders)
static ObjectID	generate_new_id ()
template<class Archive>
static void	load_and_construct (Archive &ar, cereal::construct< ObjectBase > &construct)

Private Attributes
bool	m_pipeline_plugin_active { false }
PrintConfig	m_config
PrintObjectConfig	m_default_object_config
PrintRegionConfig	m_default_region_config
PrintObjectPtrs	m_objects
PrintRegionPtrs	m_print_regions
bool	m_same_shrinkage_compensations { false }
Vec3d	m_shrinkage_compensation { Vec3d::Ones() }
bool	m_isBBLPrinter = false
ExtrusionEntityCollection	m_skirt
std::vector< SkirtBrimGroup >	m_skirt_brim_groups
bool	m_has_shared_per_object_skirt { false }
std::map< ObjectID, ExtrusionEntityCollection >	m_brimMap
std::map< ObjectID, unsigned int >	m_brimFilamentMap
std::map< ObjectInstanceID, ExtrusionEntityCollection >	m_brimMapByInstance
std::map< ObjectInstanceID, ExPolygons >	m_objectBrimAreasByInstance
Polygon	m_first_layer_convex_hull
Points	m_skirt_convex_hull
std::vector< std::vector< DynamicPrintConfig > >	m_extruder_filament_info
std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase >	m_nozzle_group_result
std::shared_ptr< MultiNozzleUtils::LayeredNozzleGroupResult >	m_layered_nozzle_group_result
std::map< const PrintObject *, ToolOrdering >	m_sequential_dynamic_orderings
FilamentIndexMap	m_filament_index_map
PrintIndexMap	m_nozzle_index_map
size_t	m_config_index_generation {0}
std::set< int >	m_missing_nozzle_group_logged
std::vector< int >	m_filament_self_index
ToolOrdering	m_tool_ordering
WipeTowerData	m_wipe_tower_data {m_tool_ordering}
PrintStatistics	m_print_statistics
bool	m_support_used {false}
StatisticsByExtruderCount	m_statistics_by_extruder_count
std::vector< unsigned int >	m_slice_used_filaments
std::vector< unsigned int >	m_slice_used_filaments_first_layer
std::vector< unsigned int >	m_slice_used_mixed_filaments
Vec3d	m_origin {0, 0, 0}
Vec2d	m_imex_slice_offset { Vec2d::Zero() }
int	m_modified_count {0}
ConflictResultOpt	m_conflict_result
FakeWipeTower	m_fake_wipe_tower
bool	m_has_auto_filament_map_result {false}
std::vector< std::set< int > >	m_geometric_unprintable_filaments
Calib_Params	m_calib_params
bool	m_need_check_multi_filaments_compatibility {true}
PrintState< PrintStep, COUNT >	m_state
std::atomic< CancelStatus >	m_cancel_status
cancel_callback_type	m_cancel_callback = [](){}
std::mutex	m_state_mutex
friend	PrintTryCancel
ObjectID	m_id

Static Private Attributes
static SlicingPipelineHookFn	s_slicing_pipeline_hook_fn = nullptr
static size_t	s_last_id = 0

Friends
class	GCode
class	PrintObject

Detailed Description

Class Documentation

◆ Slic3r::Print::SkirtBrimGroup

struct Slic3r::Print::SkirtBrimGroup

Collaboration diagram for Slic3r::Print::SkirtBrimGroup:

Class Members
vector< Brim >	brims
vector< ObjectInstanceID >	instances
ExtrusionEntityCollection	skirt

Member Typedef Documentation

◆ cancel_callback_type

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

inherited

◆ FilamentIndexMap

using Slic3r::Print::FilamentIndexMap = std::unordered_map<FilamentIndexKey, int, FilamentIndexKeyHash>

protected

◆ Inherited

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

private

◆ PrintIndexMap

using Slic3r::Print::PrintIndexMap = std::unordered_map<PrintIndexKey, int, PrintIndexKeyHash>

protected

◆ PrintObjectInfo

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

private

◆ SlicingPipelineHookFn

using Slic3r::Print::SlicingPipelineHookFn = std::function<void(Print&, const PrintObject*, SlicingPipelineStepPlugin)>

◆ 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

Referenced by check_multi_filament_valid(), compacted_wipe_tower_clearance_valid(), sequential_print_clearance_valid(), and wipe_tower_data().

Here is the caller graph for this function:

◆ ~Print()

virtual Slic3r::Print::~Print ( )

inlinevirtual

1067{ this->clear(); }

Slic3r::Print::clear

void clear() override

Definition Print.cpp:235

References clear().

Here is the call graph for this function:

Member Function Documentation

◆ _align_belt_purge_layers()

void Slic3r::Print::_align_belt_purge_layers ( )

private

{
    PrintObject *prism = nullptr;
    for (PrintObject *po : m_objects)
        if (po->config().belt_purge_tower_object.value && !po->layers().empty()) {
            prism = po;
            break;
        }
    if (prism == nullptr || prism->layers().empty())
        return;
 
    const double h = prism->config().layer_height.value;
    if (h <= EPSILON)
        return;
 
    // Grid residue of an object's layer grid: identical for all of an object's
    // layers above the first since they step by h.
    auto grid_offset = [h](const PrintObject *po) -> double {
        if (po->layers().empty())
            return 0.;
        const double z = po->layers().front()->print_z;
        return z - std::floor(z / h) * h; // in [0, h)
    };
 
    // Reference grid: the tallest non-prism object (proxy for the object with
    // the most toolchange layers — minimizes how far the rest must move).
    const PrintObject *ref     = nullptr;
    double             ref_top = -std::numeric_limits<double>::max();
    for (const PrintObject *po : m_objects) {
        if (po->config().belt_purge_tower_object.value || po->layers().empty())
            continue;
        const double top = po->layers().back()->print_z;
        if (top > ref_top) {
            ref_top = top;
            ref     = po;
        }
    }
    if (ref == nullptr)
        return;
 
    const double ref_offset = grid_offset(ref);
 
    // Snap every object (printed objects AND the prism) onto the reference grid.
    for (PrintObject *po : m_objects) {
        if (po->layers().empty())
            continue;
        double delta = ref_offset - grid_offset(po);
        if (delta > 0.5 * h)
            delta -= h;
        else if (delta <= -0.5 * h)
            delta += h;
        po->belt_shift_layer_grid(delta); // no-op for the reference object (delta ~ 0)
    }
}

References Slic3r::PrintObject::config(), Slic3r::ConstVectorOfPtrsAdaptor< T >::empty(), EPSILON, Slic3r::PrintObject::layers(), m_objects, and PrintObject.

Referenced by _plan_belt_purge().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _make_skirt()

void Slic3r::Print::_make_skirt ( )

private

{
    // Belt printer: skirt is not compatible.
    if (m_config.belt_printer.value)
        return;
  
    const bool generate_skirt = this->has_skirt() || this->has_infinite_skirt();
 
    // 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.;
    if (generate_skirt) {
        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);
        }
    }
 
    struct ObjectSkirtHull {
        PrintObject* object;
        Polygon      hull;
    };
 
    // Orca: Build one local occupied hull per object from object/support
    // geometry up to skirt height. Instances translate this hull later.
    std::vector<ObjectSkirtHull> object_convex_hulls;
    for (PrintObject *object : m_objects) {
        Points object_points;
        // Get object layers up to skirt_height_z.
        for (const Layer *layer : object->m_layers) {
            if (generate_skirt && 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 (generate_skirt && layer->print_z > skirt_height_z)
                break;
            layer->support_fills.collect_points(object_points);
        }
 
        object_convex_hulls.push_back({ object, Slic3r::Geometry::convex_hull(object_points) });
    }
 
    if (object_convex_hulls.empty())
        return;
 
    this->throw_if_canceled();
 
    // 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 initial_layer_print_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, m_config.single_extruder_multi_material).e_per_mm(mm3_per_mm));
        }
    }
 
    // Initial skirt centerline offset from the occupied outline.
    // The skirt will touch the occupied outline if skirt_distance is zero.
    // Generate loops inward to outward; callers reverse them before G-code export.
    // Loop while we have less skirts than required or any extruder hasn't reached the min length if any.
    auto append_skirt_loops_for_hull = [&](const Polygon& hull, ExtrusionEntityCollection& dst, bool collect_skirt_hull) {
        float distance = float(scale_(m_config.skirt_distance.value - spacing/2.));
        std::vector<coordf_t> extruded_length(extruders.size(), 0.);
        for (size_t i = m_config.skirt_loops, extruder_idx = 0; i > 0; -- i) {
            this->throw_if_canceled();
            // Offset the skirt outside.
            distance += float(scale_(spacing));
            // Generate the skirt centerline.
            Polygon loop;
            {
                // Orca: the hull already represents the occupied outline used for this skirt.
                Polygons loops = offset(hull, distance, 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(
                    erSkirt,
                    (float)mm3_per_mm,         // this will be overridden at G-code export time
                    flow.width(),
            (float)initial_layer_print_height  // this will be overridden at G-code export time
                )));
            eloop.paths.back().polyline = Polyline3(loop.split_at_first_point());
            dst.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 length is not limited, extrude the skirt with the 1st extruder only.
            }
        }
 
        if (collect_skirt_hull)
            for (Polygon &poly : offset(hull, distance + 0.5f * float(scale_(spacing)), jtRound, float(scale_(0.1))))
                append(m_skirt_convex_hull, std::move(poly.points));
    };
 
    m_skirt.clear();
    m_skirt_brim_groups.clear();
    m_has_shared_per_object_skirt = false;
    for (const ObjectSkirtHull& object_hull : object_convex_hulls)
        object_hull.object->m_skirt.clear();
 
    if (m_config.skirt_type == stCombined || m_config.skirt_type == stPerObject) {
        struct SkirtBrimGroupItem {
            Points       occupied_points;
            ObjectID     object_id;
            size_t       instance_id;
            bool         emits_skirt;
        };
 
        // Orca: Each object instance can emit skirt/brim. Wipe tower is only an
        // obstacle here; it may merge nearby items, but does not emit anything.
        std::vector<SkirtBrimGroupItem> group_items;
        const coord_t grouping_offset = scale_(m_config.skirt_distance.value + m_config.skirt_loops.value * spacing);
        for (const ObjectSkirtHull& object_hull : object_convex_hulls) {
            PrintObject* object = object_hull.object;
            std::vector<size_t> object_item_indices;
            object_item_indices.reserve(object->instances().size());
            for (size_t instance_idx = 0; instance_idx < object->instances().size(); ++instance_idx) {
                const PrintInstance &instance = object->instances()[instance_idx];
                Points copy_points = object_hull.hull.points;
                for (Point &pt : copy_points)
                    pt += instance.shift;
                if (copy_points.size() < 3)
                    continue;
 
                object_item_indices.push_back(group_items.size());
                group_items.push_back({ std::move(copy_points), object->id(), instance_idx, true });
            }
 
            for (size_t item_idx : object_item_indices) {
                const ObjectInstanceID key{ object->id(), group_items[item_idx].instance_id };
                if (auto instance_brim_it = m_objectBrimAreasByInstance.find(key); instance_brim_it != m_objectBrimAreasByInstance.end())
                    for (const ExPolygon& area : instance_brim_it->second)
                        append(group_items[item_idx].occupied_points, area.contour.points);
            }
        }
 
        // Orca: the wipe tower contributes occupied area, but does not emit a skirt by itself.
        Points wipe_tower_points = this->first_layer_wipe_tower_corners();
        if (wipe_tower_points.size() >= 3)
            group_items.push_back({ std::move(wipe_tower_points), ObjectID(), size_t(-1), false });
 
        std::vector<size_t> parent(group_items.size());
        std::iota(parent.begin(), parent.end(), 0);
        // Orca: Use union-find so touching items can be merged while scanning.
        auto find_parent = [&parent](size_t idx) {
            while (parent[idx] != idx) {
                parent[idx] = parent[parent[idx]];
                idx = parent[idx];
            }
            return idx;
        };
        auto unite = [&parent, &find_parent](size_t a, size_t b) {
            a = find_parent(a);
            b = find_parent(b);
            if (a != b)
                parent[b] = a;
        };
 
        // Orca: Combined skirt starts with all items in the same group.
        if (m_config.skirt_type == stCombined && !group_items.empty())
            for (size_t i = 1; i < group_items.size(); ++i)
                unite(0, i);
 
        auto build_skirt_brim_groups = [&]() {
            struct SkirtBrimGroupData {
                Points                                           points;
                std::vector<ObjectInstanceID>                    instances;
                bool                                             emits_skirt = false;
            };
 
            std::map<size_t, SkirtBrimGroupData> grouped;
            for (size_t i = 0; i < group_items.size(); ++i) {
                SkirtBrimGroupData& group = grouped[find_parent(i)];
                append(group.points, group_items[i].occupied_points);
                if (group_items[i].object_id.valid())
                    group.instances.push_back({ group_items[i].object_id, group_items[i].instance_id });
                group.emits_skirt = group.emits_skirt || group_items[i].emits_skirt;
            }
            return grouped;
        };
 
        bool groups_changed = m_config.skirt_type == stPerObject;
        while (groups_changed) {
            groups_changed = false;
            auto grouped_points = build_skirt_brim_groups();
            std::vector<std::pair<size_t, Polygon>> group_envelopes;
            for (const auto& [root, group] : grouped_points) {
                if (group.points.size() < 3)
                    continue;
 
                // Orca: Only skirt-emitting groups are expanded by skirt distance;
                // obstacle-only groups stay at their occupied outline.
                Polygon envelope = Geometry::convex_hull(group.points);
                if (group.emits_skirt) {
                    // Orca: If the expanded skirt outline touches another group
                    // or obstacle, merge them and run the pass again.
                    Polygons envelopes = offset(envelope, grouping_offset, jtRound, float(scale_(0.1)));
                    if (envelopes.empty())
                        continue;
                    envelope = std::move(envelopes.front());
                }
                group_envelopes.emplace_back(root, std::move(envelope));
            }
 
            for (size_t i = 0; i < group_envelopes.size(); ++i) {
                for (size_t j = i + 1; j < group_envelopes.size(); ++j) {
                    const size_t root_i = find_parent(group_envelopes[i].first);
                    const size_t root_j = find_parent(group_envelopes[j].first);
                    if (root_i != root_j && !intersection(group_envelopes[i].second, group_envelopes[j].second).empty()) {
                        unite(root_i, root_j);
                        groups_changed = true;
                    }
                }
            }
        }
 
        std::vector<std::vector<BedExcludeRegion>> brim_exclusion_regions;
        if (has_bed_exclude_volumes(m_config)) {
            brim_exclusion_regions = translated_bed_exclusion_volumes_by_extruder(*this);
            for (std::vector<BedExcludeRegion> &regions : brim_exclusion_regions)
                regions.erase(std::remove_if(regions.begin(), regions.end(),
                    [](const BedExcludeRegion &region) { return !region.is_collision_volume(); }), regions.end());
        }
        const bool has_brim_exclusions = std::any_of(
            brim_exclusion_regions.begin(), brim_exclusion_regions.end(),
            [](const std::vector<BedExcludeRegion> &regions) { return !regions.empty(); });
        const bool has_nozzle_specific_brim_exclusions = has_brim_exclusions &&
            active_bed_exclude_volume_mode(m_config) != BedExcludeVolumeMode::Shared;
 
        auto make_brims_for_skirt_brim_group =
            [this, &brim_exclusion_regions, has_nozzle_specific_brim_exclusions]
            (const std::vector<ObjectInstanceID>& group_instances) {
            std::vector<SkirtBrimGroup::Brim> brims;
            std::vector<ObjectInstanceID> brim_instances;
            for (const ObjectInstanceID& instance : group_instances) {
                const auto brim_it = m_brimMapByInstance.find(instance);
                if (brim_it != m_brimMapByInstance.end() && !brim_it->second.empty())
                    brim_instances.push_back(instance);
            }
 
            auto brim_filament = [this](const ObjectInstanceID& instance) -> std::optional<unsigned int> {
                const auto it = m_brimFilamentMap.find(instance.object_id);
                return it == m_brimFilamentMap.end() ? std::nullopt :
                    std::optional<unsigned int>(it->second);
            };
            auto compatible_brim_nozzles =
                [this, &brim_filament, &brim_exclusion_regions, has_nozzle_specific_brim_exclusions]
                (const ObjectInstanceID& first, const ObjectInstanceID& second) {
                    if (!has_nozzle_specific_brim_exclusions)
                        return true;
                    const std::optional<unsigned int> first_filament = brim_filament(first);
                    const std::optional<unsigned int> second_filament = brim_filament(second);
                    return first_filament.has_value() && second_filament.has_value() &&
                        bed_exclusion_physical_extruders(
                            *this, { *first_filament, *second_filament },
                            brim_exclusion_regions.size(), 0).size() == 1;
                };
 
            const bool combine_group_brims = m_config.combine_brims && brim_instances.size() > 1;
            if (!combine_group_brims) {
                for (const ObjectInstanceID& instance : brim_instances) {
                    const std::optional<unsigned int> filament = brim_filament(instance);
                    if (filament.has_value())
                        brims.push_back({ m_brimMapByInstance.at(instance), { instance }, *filament });
                }
                return brims;
            }
 
            std::vector<size_t> brim_parent(brim_instances.size());
            std::iota(brim_parent.begin(), brim_parent.end(), 0);
            auto find_brim_parent = [&brim_parent](size_t idx) {
                while (brim_parent[idx] != idx) {
                    brim_parent[idx] = brim_parent[brim_parent[idx]];
                    idx = brim_parent[idx];
                }
                return idx;
            };
            auto unite_brims = [&brim_parent, &find_brim_parent](size_t a, size_t b) {
                a = find_brim_parent(a);
                b = find_brim_parent(b);
                if (a != b)
                    brim_parent[b] = a;
            };
 
            const coord_t brim_contact_distance = coord_t(brim_flow().scaled_spacing() * 2.);
            for (size_t i = 0; i < brim_instances.size(); ++i) {
                const auto area_i = m_objectBrimAreasByInstance.find(brim_instances[i]);
                if (area_i == m_objectBrimAreasByInstance.end())
                    continue;
                for (size_t j = i + 1; j < brim_instances.size(); ++j) {
                    const auto area_j = m_objectBrimAreasByInstance.find(brim_instances[j]);
                    if (area_j != m_objectBrimAreasByInstance.end() &&
                        compatible_brim_nozzles(brim_instances[i], brim_instances[j]) &&
                        !intersection_ex(offset_ex(area_i->second, brim_contact_distance, jtRound, SCALED_RESOLUTION), area_j->second).empty())
                        unite_brims(i, j);
                }
            }
 
            std::map<size_t, std::vector<ObjectInstanceID>> combined_brim_ids;
            for (size_t i = 0; i < brim_instances.size(); ++i)
                combined_brim_ids[find_brim_parent(i)].push_back(brim_instances[i]);
 
            for (const auto& [_, instances] : combined_brim_ids) {
                const std::optional<unsigned int> filament = brim_filament(instances.front());
                if (!filament.has_value())
                    continue;
                if (instances.size() == 1) {
                    const ObjectInstanceID& instance = instances.front();
                    brims.push_back({ m_brimMapByInstance.at(instance), { instance }, *filament });
                    continue;
                }
 
                ExPolygons combined_area;
                for (const ObjectInstanceID& instance : instances)
                    expolygons_append(combined_area, m_objectBrimAreasByInstance.at(instance));
                combined_area = union_ex(combined_area);
                const float scaled_resolution  = float(scaled(m_config.resolution.value));
                const float brim_cleanup_delta = std::max(scaled_resolution, float(SCALED_EPSILON));
                combined_area = offset2_ex(combined_area, brim_cleanup_delta, -brim_cleanup_delta, jtRound, scaled_resolution);
 
                // The group has one known physical nozzle. Clip after union and
                // cleanup so the geometry consumed by path generation remains
                // valid for the exact filament recorded on the combined brim.
                const std::vector<size_t> physical_extruders = bed_exclusion_physical_extruders(
                    *this, { *filament }, brim_exclusion_regions.size(), 0);
                const coord_t width_spacing_delta = std::max<coord_t>(
                    0, brim_flow().scaled_width() - brim_flow().scaled_spacing());
                const coord_t exclusion_clearance =
                    (width_spacing_delta + 1) / 2 + coord_t(SCALED_EPSILON);
                const ExPolygons exclusions = active_bed_exclusion_footprints(
                    brim_exclusion_regions, physical_extruders, 0.0,
                    std::max(0.0, skirt_first_layer_height()), Point(0, 0), exclusion_clearance);
                if (!exclusions.empty())
                    combined_area = diff_ex(combined_area, exclusions);
                if (combined_area.empty())
                    continue;
 
                Polygons islands_area;
                brims.push_back({ makeBrimInfillFromPlateCoordinates(combined_area, *this, islands_area),
                                  instances, *filament });
            }
 
            return brims;
        };
 
        auto grouped_points = build_skirt_brim_groups();
        for (auto& [_, group] : grouped_points) {
            if (!group.emits_skirt || group.points.size() < 3)
                continue;
            if (generate_skirt && m_config.skirt_type == stPerObject && group.instances.size() > 1)
                m_has_shared_per_object_skirt = true;
            // Orca: Group points already include the occupied outline, so don't
            // add skirt distance here again.
            ExtrusionEntityCollection group_skirt;
            if (generate_skirt)
                append_skirt_loops_for_hull(Geometry::convex_hull(group.points), group_skirt, true);
            std::vector<SkirtBrimGroup::Brim> group_brims = make_brims_for_skirt_brim_group(group.instances);
            if (!group_skirt.empty()) {
                group_skirt.reverse();
                // Orca: Keep m_skirt filled for code that still reads a flat
                // skirt collection.
                m_skirt.append(group_skirt.entities);
            }
            if (!group_skirt.empty() || !group_brims.empty())
                m_skirt_brim_groups.push_back({ std::move(group_skirt), std::move(group.instances), std::move(group_brims) });
        }
    }
}

References _, _make_skirt(), Slic3r::active_bed_exclude_volume_mode(), Slic3r::active_bed_exclusion_footprints(), Slic3r::append(), Slic3r::area(), Slic3r::bed_exclusion_physical_extruders(), brim_flow(), Slic3r::ExPolygon::contour, Slic3r::Geometry::convex_hull(), Slic3r::diff_ex(), Slic3r::Extruder::e_per_mm(), Slic3r::elrSkirt, Slic3r::ExtrusionEntityCollection::empty(), empty(), Slic3r::ExtrusionEntityCollection::entities, Slic3r::erSkirt, Slic3r::expolygons_append(), extruders(), first_layer_wipe_tower_corners(), Slic3r::has_bed_exclude_volumes(), has_infinite_skirt(), has_skirt(), Slic3r::initial_layer_print_height(), Slic3r::PrintObject::instances(), Slic3r::intersection(), Slic3r::intersection_ex(), Slic3r::jtRound, Slic3r::Polygon::length(), Slic3r::Layer::lslices, m_brimFilamentMap, m_brimMapByInstance, m_config, m_has_shared_per_object_skirt, m_objectBrimAreasByInstance, m_objects, m_skirt, m_skirt_brim_groups, m_skirt_convex_hull, Slic3r::makeBrimInfillFromPlateCoordinates(), Slic3r::Flow::mm3_per_mm(), Slic3r::offset(), Slic3r::offset2_ex(), Slic3r::offset_ex(), Slic3r::ExtrusionLoop::paths, Slic3r::MultiPoint::points, Slic3r::Layer::print_z, PrintObject, Slic3r::ExtrusionEntityCollection::reverse(), scale_, Slic3r::scaled(), SCALED_EPSILON, SCALED_RESOLUTION, Slic3r::Shared, Slic3r::PrintInstance::shift, Slic3r::Geometry::simplify_polygons(), skirt_first_layer_height(), skirt_flow(), Slic3r::Flow::spacing(), Slic3r::Polygon::split_at_first_point(), Slic3r::stCombined, Slic3r::stPerObject, Slic3r::PrintBaseWithState< PrintStep, psCount >::throw_if_canceled(), Slic3r::translated_bed_exclusion_volumes_by_extruder(), Slic3r::union_ex(), Slic3r::unscale(), and Slic3r::Flow::width().

Referenced by _make_skirt().

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();
 
    // BBS
    const unsigned int number_of_extruders = (unsigned int)(m_config.filament_colour.values.size());
 
    const bool is_wipe_tower_type2 = this->wipe_tower_type() == WipeTowerType::Type2;
    // 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, is_wipe_tower_type2);
    m_wipe_tower_data.tool_ordering.sort_and_build_data(*this, (unsigned int)-1, is_wipe_tower_type2);
 
    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. Each such layer needs a virtual support layer
    // counterpart in m_objects.front() so that GCode::collect_layers_to_print picks it up and the
    // wipe tower G-code is actually emitted for that z. Such layers appear in two scenarios:
    //   - above the raft, between raft top and the first real object layer
    //     (see https://github.com/prusa3d/PrusaSlicer/issues/607);
    //   - between two real wipe-tower layers, when one object is fully floating above another and
    //     the support_top_z_distance / support_bottom_z_distance gap leaves interior z values with
    //     neither object nor support (continuity fill in ToolOrdering::fill_wipe_tower_partitions).
    // The previous implementation only handled the first contiguous run starting at the first
    // virtual layer, which made the second scenario silently produce empty wipe-tower layers.
    {
        auto &support_layers = m_objects.front()->support_layers();
        auto it_layer = support_layers.begin();
        const size_t idx_end = m_wipe_tower_data.tool_ordering.layer_tools().size();
        for (size_t i = 0; 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))
                continue;
            while (it_layer != support_layers.end() && (*it_layer)->print_z + EPSILON < lt.print_z)
                ++ it_layer;
            if (it_layer != support_layers.end() && std::abs((*it_layer)->print_z - lt.print_z) < EPSILON) {
                lt.has_support = true;
                ++ it_layer;
                continue;
            }
            lt.has_support = true;
            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();
 
    if (!is_wipe_tower_type2) {
        // in BBL machine, wipe tower is only use to prime extruder. So just use a global wipe volume.
        WipeTower wipe_tower(m_config, m_plate_index, m_origin, m_wipe_tower_data.tool_ordering.first_extruder(),
                             m_wipe_tower_data.tool_ordering.empty() ? 0.f : m_wipe_tower_data.tool_ordering.back().print_z, m_wipe_tower_data.tool_ordering.all_extruders());
        // Orca: the tower's first-layer flow follows the user's first-layer flow ratio (BBS reads
        // its initial_layer_flow_ratio here — STUDIO-14254; first_layer_flow_ratio is Orca's analog,
        // default 1.0 in both). Honor the set_other_flow_ratios gate that governs the option
        // everywhere else.
        wipe_tower.set_first_layer_flow_ratio(m_default_object_config.set_other_flow_ratios
                                                  ? float(m_default_region_config.first_layer_flow_ratio)
                                                  : 1.f);
        wipe_tower.set_has_tpu_filament(this->has_tpu_filament());
        // Per-layer filament->nozzle grouping. sort_and_build_data() above publishes it on the Print
        // for by-layer prints; by-object prints publish only later (psSkirtBrim), so fall back to the
        // ToolOrdering's own copy there. set_extruder() below dereferences it, so it must be set first.
        auto print_group_result = get_layered_nozzle_group_result();
        const MultiNozzleUtils::LayeredNozzleGroupResult &nozzle_group_result =
            print_group_result ? *print_group_result : m_wipe_tower_data.tool_ordering.get_layered_nozzle_group_result();
        wipe_tower.set_nozzle_group_result(nozzle_group_result);
        {
            // Orca: acceleration options are object-scope (PrintConfig members in BBS), so resolve
            // the per-variant columns here; initial_layer_travel_acceleration is FloatOrPercent
            // over travel_acceleration and needs the full config to resolve.
            std::vector<double> first_layer_travel_accels;
            for (size_t i = 0; i < m_config.initial_layer_travel_acceleration.values.size(); ++i)
                first_layer_travel_accels.emplace_back(m_full_print_config.get_abs_value_at("initial_layer_travel_acceleration", i));
            wipe_tower.set_accelerations(m_default_object_config.default_acceleration.values,
                                         m_default_object_config.initial_layer_acceleration.values,
                                         m_default_object_config.travel_acceleration.values,
                                         first_layer_travel_accels);
        }
        // Feed the has_filament_switcher device flag (develop-only dynamic key, read defensively from
        // the full config — no shipping profile sets it) and the shared printable bed used by the PETG
        // pre-extrusion offset clamp. Both are inert unless has_filament_switcher is set.
        {
            const ConfigOptionBool* hfs = m_full_print_config.option<ConfigOptionBool>("has_filament_switcher");
            wipe_tower.set_has_filament_switcher(hfs && hfs->value);
        }
        wipe_tower.set_shared_print_bed(this->get_extruder_shared_printable_polygon());
        // Set the extruder & material properties at the wipe tower object.
        for (size_t i = 0; i < number_of_extruders; ++i)
            wipe_tower.set_extruder(i, m_config);
 
        // BBS: remove priming logic
        // 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));
 
        std::set<int> used_filament_ids;
 
        // 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)
        {
        // Get wiping matrix to get number of extruders and convert vector<double> to vector<float>:
        bool               is_mutli_extruder = m_config.nozzle_diameter.values.size() > 1;
        size_t nozzle_nums = m_config.nozzle_diameter.values.size();
        using FlushMatrix = std::vector<std::vector<float>>;
        std::vector<FlushMatrix> multi_extruder_flush;
        for (size_t nozzle_id = 0; nozzle_id < nozzle_nums; ++nozzle_id) {
            std::vector<float> flush_matrix(cast<float>(get_flush_volumes_matrix(m_config.flush_volumes_matrix.values, nozzle_id, nozzle_nums)));
            std::vector<std::vector<float>> wipe_volumes;
            for (unsigned int i = 0; i < number_of_extruders; ++i)
                wipe_volumes.push_back(std::vector<float>(flush_matrix.begin() + i * number_of_extruders, flush_matrix.begin() + (i + 1) * number_of_extruders));
 
            multi_extruder_flush.emplace_back(wipe_volumes);
        }
 
        // Per-carousel-slot purge tracking via NozzleStatusRecorder (BBS pattern); the layered
        // group result set on the tower above resolves each filament to its nozzle slot per layer.
        MultiNozzleUtils::NozzleStatusRecorder nozzle_recorder;
 
        std::vector<int>filament_maps = get_filament_maps();
        int layer_idx = -1;
 
        unsigned int current_filament_id = m_wipe_tower_data.tool_ordering.first_extruder();
        // Initialize NozzleStatusRecorder with the first filament's carousel slot
        {
            auto nozzle = nozzle_group_result.get_nozzle_for_filament(current_filament_id, layer_idx);
            if (nozzle)
                nozzle_recorder.set_nozzle_status(nozzle->group_id, current_filament_id, nozzle->extruder_id);
        }
 
        for (auto& layer_tools : m_wipe_tower_data.tool_ordering.layer_tools()) { // for all layers
            ++layer_idx;
 
            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_filament_id, current_filament_id);
 
            used_filament_ids.insert(layer_tools.extruders.begin(), layer_tools.extruders.end());
 
            for (const auto filament_id : layer_tools.extruders) {
                if (filament_id == current_filament_id)
                    continue;
 
                float volume_to_purge = 0;
 
                // Per-carousel-slot purge tracking via NozzleStatusRecorder
                {
                    auto nozzle_info = nozzle_group_result.get_nozzle_for_filament(filament_id, layer_idx);
                    if (nozzle_info) {
                        int extruder_id = nozzle_info->extruder_id;
                        int nozzle_id   = nozzle_info->group_id;
                        int prev_nozzle_filament = nozzle_recorder.get_filament_in_nozzle(nozzle_id);
 
                        if (!nozzle_recorder.is_nozzle_empty(nozzle_id) &&
                            static_cast<int>(filament_id) != prev_nozzle_filament) {
                            volume_to_purge = multi_extruder_flush[extruder_id][prev_nozzle_filament][filament_id];
                            // Fast purge mode uses flush_multiplier_fast; Default is inert.
                            float flush_multiplier = (m_config.prime_volume_mode == PrimeVolumeMode::pvmFast)
                                ? m_config.flush_multiplier_fast.get_at(extruder_id)
                                : m_config.flush_multiplier.get_at(extruder_id);
                            volume_to_purge *= flush_multiplier;
                            volume_to_purge = layer_tools.wiping_extrusions().mark_wiping_extrusions(
                                *this, current_filament_id, filament_id, volume_to_purge);
                        }
                        nozzle_recorder.set_nozzle_status(nozzle_id, filament_id, extruder_id);
                    }
                }
 
                //During the filament change, the extruder will extrude an extra length of grab_length for the corresponding detection, so the purge can reduce this length.
                int grab_extruder_id = filament_maps[filament_id] - 1;
                float grab_purge_volume = m_config.grab_length.get_at(grab_extruder_id) * 2.4; //(diameter/2)^2*PI=2.4
                volume_to_purge = std::max(0.f, volume_to_purge - grab_purge_volume);
 
                // Prime volume per-filament: the tower now picks extruder-change vs nozzle-change
                // (carousel) internally per plan layer, so pass both candidates (BBS pattern).
                float wipe_volume_ec = filament_id < m_config.filament_prime_volume.values.size()
                    ? m_config.filament_prime_volume.values[filament_id]
                    : (float) m_config.prime_volume;
                float wipe_volume_nc = filament_id < m_config.filament_prime_volume_nc.values.size()
                    ? m_config.filament_prime_volume_nc.values[filament_id]
                    : (float) m_config.prime_volume;
                if (m_config.prime_volume_mode == PrimeVolumeMode::pvmSaving) {
                    wipe_volume_ec = 15.f;
                    wipe_volume_nc = 15.f;
                }
 
                wipe_tower.plan_toolchange((float)layer_tools.print_z, (float)layer_tools.wipe_tower_layer_height, current_filament_id, filament_id,
                    wipe_volume_ec, wipe_volume_nc, volume_to_purge);
                current_filament_id = filament_id;
            }
            layer_tools.wiping_extrusions().ensure_perimeters_infills_order(*this);
 
            // if enable timelapse, slice all layer
            if (m_config.enable_wrapping_detection || enable_timelapse_print()) {
                if (layer_tools.wipe_tower_partitions == 0) wipe_tower.set_last_layer_extruder_fill(false);
                continue;
            }
 
            if (&layer_tools == &m_wipe_tower_data.tool_ordering.back() || (&layer_tools + 1)->wipe_tower_partitions == 0)
                break;
        }
        }
 
        wipe_tower.set_used_filament_ids(std::vector<int>(used_filament_ids.begin(), used_filament_ids.end()));
 
        std::vector<int> categories;
        for (size_t i = 0; i < m_config.filament_adhesiveness_category.values.size(); ++i) {
            categories.push_back(m_config.filament_adhesiveness_category.get_at(i));
        }
        wipe_tower.set_filament_categories(categories);
 
        // Generate the wipe tower layers.
        m_wipe_tower_data.tool_changes.reserve(m_wipe_tower_data.tool_ordering.layer_tools().size());
        wipe_tower.generate_new(m_wipe_tower_data.tool_changes);
        m_wipe_tower_data.depth      = wipe_tower.get_depth();
        m_wipe_tower_data.width      = wipe_tower.width();
        m_wipe_tower_data.brim_width = wipe_tower.get_brim_width();
        m_wipe_tower_data.bbx = wipe_tower.get_bbx();
        m_wipe_tower_data.rib_offset = wipe_tower.get_rib_offset();
 
        // Unload the current filament over the purge tower.
        coordf_t layer_height = m_objects.front()->config().layer_height.value;
        bool generate_final_purge = true;
        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.
            // Skip final purge to avoid generating purge lines in mid-air.
            assert(m_wipe_tower_data.tool_ordering.back().wipe_tower_partitions == 0);
            generate_final_purge = false;
        }
        m_wipe_tower_data.final_purge = generate_final_purge
            ? Slic3r::make_unique<WipeTower::ToolChangeResult>(wipe_tower.tool_change((unsigned int)(-1)))
            : Slic3r::make_unique<WipeTower::ToolChangeResult>();
 
        m_wipe_tower_data.used_filament         = wipe_tower.get_used_filament();
        m_wipe_tower_data.number_of_toolchanges = wipe_tower.get_number_of_toolchanges();
        m_wipe_tower_data.construct_mesh(wipe_tower.width(), wipe_tower.get_depth(), wipe_tower.get_height(), wipe_tower.get_brim_width(), config().wipe_tower_wall_type.value == WipeTowerWallType::wtwRib,
                                         wipe_tower.get_rib_width(), wipe_tower.get_rib_length(), config().wipe_tower_fillet_wall.value);
        const Vec3d origin                      = this->get_plate_origin();
        m_fake_wipe_tower.rib_offset = wipe_tower.get_rib_offset();
        m_fake_wipe_tower.set_fake_extrusion_data(wipe_tower.position() + m_fake_wipe_tower.rib_offset, wipe_tower.width(), wipe_tower.get_height(), wipe_tower.get_layer_height(),
                                                  m_wipe_tower_data.depth,
                                                  m_wipe_tower_data.brim_width, {scale_(origin.x()), scale_(origin.y())});
        m_fake_wipe_tower.outer_wall = wipe_tower.get_outer_wall();
    } else {
        // Get wiping matrix to get number of extruders and convert vector<double> to vector<float>:
        std::vector<float> flush_matrix(cast<float>(m_config.flush_volumes_matrix.values));
        // Extract purging volumes for each extruder pair:
        std::vector<std::vector<float>> wipe_volumes;
        for (unsigned int i = 0; i<number_of_extruders; ++i)
            wipe_volumes.push_back(std::vector<float>(flush_matrix.begin()+i*number_of_extruders, flush_matrix.begin()+(i+1)*number_of_extruders));
 
        // Orca: itertate over wipe_volumes and change the non-zero values to the prime_volume
        if ((!m_config.purge_in_prime_tower || !m_config.single_extruder_multi_material) && is_wipe_tower_type2) {
            for (unsigned int i = 0; i < number_of_extruders; ++i) {
                for (unsigned int j = 0; j < number_of_extruders; ++j) {
                    if (wipe_volumes[i][j] > 0) {
                        wipe_volumes[i][j] = m_config.prime_volume;
                    }
                }
            }
        }
        // Initialize the wipe tower.
        WipeTower2 wipe_tower(m_config, m_default_region_config, m_plate_index, m_origin, 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 < number_of_extruders; ++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 = m_config.prime_volume;
                        if (m_config.purge_in_prime_tower && m_config.single_extruder_multi_material) {
                            volume_to_wipe = wipe_volumes[current_extruder_id][extruder_id]; // total volume to wipe after this toolchange
                            volume_to_wipe *= m_config.flush_multiplier.get_at(0);
                            // 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().mark_wiping_extrusions(*this, 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().ensure_perimeters_infills_order(*this);
                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.width             = wipe_tower.width();
        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();
        m_wipe_tower_data.bbx               = wipe_tower.get_bbx();
        m_wipe_tower_data.rib_offset        = wipe_tower.get_rib_offset();
 
        // Unload the current filament over the purge tower.
        coordf_t layer_height = m_objects.front()->config().layer_height.value;
        bool generate_final_purge = true;
        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.
            // Skip final purge to avoid generating purge lines in mid-air.
            assert(m_wipe_tower_data.tool_ordering.back().wipe_tower_partitions == 0);
            generate_final_purge = false;
        }
        m_wipe_tower_data.final_purge = generate_final_purge
            ? Slic3r::make_unique<WipeTower::ToolChangeResult>(wipe_tower.tool_change((unsigned int)(-1)))
            : Slic3r::make_unique<WipeTower::ToolChangeResult>();
 
        m_wipe_tower_data.used_filament         = wipe_tower.get_used_filament();
        m_wipe_tower_data.number_of_toolchanges = wipe_tower.get_number_of_toolchanges();
        // Only a cone wall prints the stabilization cone, whatever cone angle the config holds.
        const float cone_angle = config().wipe_tower_wall_type.value == WipeTowerWallType::wtwCone ?
                                     static_cast<float>(config().wipe_tower_cone_angle.value) : 0.f;
        m_wipe_tower_data.construct_mesh(wipe_tower.width(), wipe_tower.get_depth(),
                                         wipe_tower.get_wipe_tower_height(), wipe_tower.get_brim_width(),
                                         config().wipe_tower_wall_type.value == WipeTowerWallType::wtwRib,
                                         wipe_tower.get_rib_width(), wipe_tower.get_rib_length(),
                                         config().wipe_tower_fillet_wall.value, cone_angle);
        const Vec3d origin                      = Vec3d::Zero();
        // FakeWipeTower::pos is a bed-frame translation applied after rotation
        // (getFakeExtrusionPathsFromWipeTower2 rotates about the local origin), so the
        // tower-local rib offset must be rotated into the bed frame first.
        m_fake_wipe_tower.rib_offset = Eigen::Rotation2Df(Geometry::deg2rad((float)config().wipe_tower_rotation_angle.value)) *
                                       wipe_tower.get_rib_offset();
        m_fake_wipe_tower.set_fake_extrusion_data(wipe_tower.position() + m_fake_wipe_tower.rib_offset, wipe_tower.width(), wipe_tower.get_wipe_tower_height(),
                                                  config().initial_layer_print_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, cone_angle,
                                                  {scale_(origin.x()), scale_(origin.y())});
    }
 
    // The clamps and checks above work from estimates; re-test the exact generated footprint
    // so an off-plate tower fails with a clear error instead of exporting unprintable G-code
    // (validate() only sees the mesh on its next run).
    if (m_wipe_tower_data.wipe_tower_mesh_data) {
        Polygon footprint = m_wipe_tower_data.wipe_tower_mesh_data->bottom; // includes brim and rib offset
        footprint.rotate(Geometry::deg2rad(m_config.wipe_tower_rotation_angle.value));
        footprint.translate(Point(scale_(m_config.wipe_tower_x.get_at(m_plate_index)),
                                  scale_(m_config.wipe_tower_y.get_at(m_plate_index))));
        const Polygons printable_polys = this->get_extruder_shared_printable_polygon();
        if (!printable_polys.empty() && !diff(Polygons{footprint}, printable_polys).empty()) {
            const BoundingBox fp = get_extents(footprint);
            const BoundingBox pr = get_extents(printable_polys);
            BOOST_LOG_TRIVIAL(error) << boost::format("wipe tower footprint [%1%,%2%]-[%3%,%4%] leaves printable [%5%,%6%]-[%7%,%8%]") %
                unscaled(fp.min.x()) % unscaled(fp.min.y()) % unscaled(fp.max.x()) % unscaled(fp.max.y()) %
                unscaled(pr.min.x()) % unscaled(pr.min.y()) % unscaled(pr.max.x()) % unscaled(pr.max.y());
            throw Slic3r::SlicingError(L("Prime tower is partially outside the printable area, and it cannot be printed.\n"));
        }
        // The cutter/purge corner is a physical obstacle — the brim must stay out like the body.
        if (!intersection(get_bed_excluded_area(m_config), Polygons{footprint}).empty())
            throw Slic3r::SlicingError(L("Prime tower is too close to an exclusion area, and collisions will be caused.\n"));
    }
}

Referenced by _make_wipe_tower().

Here is the caller graph for this function:

◆ _plan_belt_purge()

void Slic3r::Print::_plan_belt_purge ( )

private

{
    m_wipe_tower_data.clear();
 
    // psWipeTower may be invalidated without posSlice (for example after a
    // filament-map or tool-ordering change). Restore a prism shortened by the
    // previous plan so a newly higher toolchange can use its original layers.
    for (PrintObject *po : m_objects)
        if (po->config().belt_purge_tower_object.value)
            po->belt_undo_purge_plan();
 
    // Must run before ToolOrdering is built: LayerTools merge per-object layer
    // print_z values, and the prism only absorbs purge where its (snapped)
    // layers coincide with the toolchange layers.
    this->_align_belt_purge_layers();
 
    const unsigned int number_of_extruders = (unsigned int) m_config.filament_colour.values.size();
 
    // No initial priming extrusions: there is no tower to prime on.
    m_wipe_tower_data.tool_ordering = ToolOrdering(*this, (unsigned int) -1, false);
    m_wipe_tower_data.tool_ordering.sort_and_build_data(*this, (unsigned int) -1, false);
 
    if (m_wipe_tower_data.tool_ordering.empty() || m_wipe_tower_data.tool_ordering.last_extruder() == unsigned(-1))
        throw Slic3r::SlicingError(_u8L("The print is empty. The model is not printable with current print settings."));
 
    // Is there any filament change at all? Not ToolOrdering::has_wipe_tower(): that reads the
    // FIRST layer's flag, and on a belt the first layer may be a brim apron band, which carries
    // neither object nor support and so never gets the flag even when the print changes filament.
    {
        bool         any_change = false;
        unsigned int cur        = m_wipe_tower_data.tool_ordering.first_extruder();
        for (const auto &lt : m_wipe_tower_data.tool_ordering.layer_tools())
            for (const unsigned int e : lt.extruders)
                if (e != cur) { any_change = true; cur = e; }
        if (! any_change)
            return;
    }
 
    this->throw_if_canceled();
 
    // Flush volumes per filament pair, mirroring the generic wipe tower path:
    // full flush matrix for single extruder multi material with purging enabled,
    // plain prime volume otherwise.
    std::vector<float> flush_matrix(cast<float>(
        get_flush_volumes_matrix(m_config.flush_volumes_matrix.values, 0, m_config.nozzle_diameter.values.size())));
    std::vector<std::vector<float>> wipe_volumes;
    for (unsigned int i = 0; i < number_of_extruders; ++i)
        wipe_volumes.push_back(std::vector<float>(flush_matrix.begin() + i * number_of_extruders,
                                                  flush_matrix.begin() + (i + 1) * number_of_extruders));
    const bool  use_flush_matrix = m_config.purge_in_prime_tower && m_config.single_extruder_multi_material;
    const float flush_multiplier = (float) m_config.flush_multiplier.get_at(0);
 
    // Cancel the purge prism early: pre-scan the tool ordering for the highest
    // print_z that actually has a toolchange, then drop the prism's layers above
    // it so the tower stops at the last color swap (saves filament/time). This
    // MUST happen before the marking loop below: ensure_perimeters_infills_order
    // force-overrides the prism's extrusions on every layer (it is a dedicated
    // flush object), so truncating afterwards would leave dangling overrides
    // pointing into deleted layers.
    {
        // The tool ordering covers the WHOLE print, and the prism is a printed
        // object in it. Left unbounded, the scan below sees the prism's own
        // toolchanges on layers above every model object -- the prism runs past
        // them by design (ramp/height compensation at the tilted ends) -- so
        // last_tc_z lands at the prism's own top and the truncation cancels
        // nothing. The tower ends up justifying its own existence.
        //
        // Nothing above the tallest printed object can require a color change,
        // so bound the scan there. On MCTEST5 that is 197 toolchanges spanning
        // z=154.00..193.20 with the tallest object topping out at 153.80, i.e.
        // 39.4 mm of tower that no swap ever needed.
        // Support layers count too: on a belt they can extend above the object's
        // own top, and a toolchange there is a real one.
        double obj_top_z = -1.;
        for (const PrintObject *po : m_objects) {
            if (po->config().belt_purge_tower_object.value)
                continue;
            if (!po->layers().empty())
                obj_top_z = std::max(obj_top_z, po->layers().back()->print_z);
            if (!po->support_layers().empty())
                obj_top_z = std::max(obj_top_z, po->support_layers().back()->print_z);
        }
 
        double       last_tc_z   = -1.;
        unsigned int cur_ext     = m_wipe_tower_data.tool_ordering.first_extruder();
        for (const auto &lt : m_wipe_tower_data.tool_ordering.layer_tools()) {
            // layer_tools() is ordered by print_z ascending.
            if (obj_top_z >= 0. && lt.print_z > obj_top_z + EPSILON)
                break;
            for (const unsigned int e : lt.extruders)
                if (e != cur_ext) { last_tc_z = lt.print_z; cur_ext = e; }
        }
        // Deliberately NOT cancelling the prism outright when no object toolchange
        // exists: belt_truncate_layers_above(0.) empties m_layers, and an object
        // with zero layers is not something the rest of the pipeline expects. The
        // GUI already declines to create a prism unless more than one filament is
        // in use, so this case is a stale prism, not a hot path -- leave it whole
        // rather than risk a zero-layer object.
        if (last_tc_z >= 0.)
            for (PrintObject *po : m_objects)
                if (po->config().belt_purge_tower_object.value && !po->layers().empty()) {
                    po->belt_truncate_layers_above(last_tc_z);
                    break;
                }
    }
 
    // The prism only absorbs purge at toolchange layers whose print_z coincides
    // with one of its own layers.
    PrintObject *prism_po = nullptr;
    for (PrintObject *po : m_objects)
        if (po->config().belt_purge_tower_object.value && !po->layers().empty()) { prism_po = po; break; }
 
    float  total_leftover      = 0.f;
    float  worst_layer_leftover = 0.f;
    double worst_layer_z       = 0.;
 
    unsigned int current_extruder_id = m_wipe_tower_data.tool_ordering.first_extruder();
    for (auto &layer_tools : m_wipe_tower_data.tool_ordering.layer_tools()) {
        float layer_leftover = 0.f;
        for (const unsigned int extruder_id : layer_tools.extruders) {
            if (extruder_id == current_extruder_id)
                continue;
            float volume_to_wipe = use_flush_matrix ?
                wipe_volumes[current_extruder_id][extruder_id] * flush_multiplier :
                (float) m_config.prime_volume;
            float leftover = layer_tools.wiping_extrusions().mark_wiping_extrusions(*this, current_extruder_id, extruder_id,
                                                                                    volume_to_wipe);
            layer_leftover += leftover;
            current_extruder_id = extruder_id;
        }
 
        // Plastic saving: drop the prism's fills that no toolchange on this layer
        // claimed. At this point the prism's OVERRIDDEN fills are exactly the
        // purge; the rest would print as solid infill in the prism's own filament
        // for nothing -- which is the whole prism on a layer with no toolchange
        // (141 of 692 layers on MCTEST5 before the truncation fix). Perimeters are
        // left alone so the bar keeps a continuous wall along the belt.
        //
        // Non-destructive: the entities are stashed with their positions and put
        // back by belt_restore_dropped_fills() at the top of the next plan. An
        // earlier version deleted them outright, which broke replanning when a
        // later tool ordering needed what this one had not claimed -- that is why
        // it was removed rather than kept.
        if (prism_po != nullptr) {
            const auto &we = layer_tools.wiping_extrusions();
            prism_po->belt_drop_unclaimed_fills(
                prism_po->get_layer_at_printz(layer_tools.print_z, EPSILON),
                [&we, prism_po](const ExtrusionEntity *e) { return we.is_entity_overridden(e, prism_po, 0); });
        }
 
        layer_tools.wiping_extrusions().ensure_perimeters_infills_order(*this);
        if (layer_leftover > 0.f) {
            total_leftover += layer_leftover;
            if (layer_leftover > worst_layer_leftover) {
                worst_layer_leftover = layer_leftover;
                worst_layer_z        = layer_tools.print_z;
            }
        }
        this->throw_if_canceled();
    }
 
    if (total_leftover > 1.f) {
        this->active_step_add_warning(
            PrintStateBase::WarningLevel::CRITICAL,
            Slic3r::format(_u8L("The belt purge tower cannot absorb the full purge volume: %1% mm³ in total could not "
                                "be purged (worst layer: %2% mm³ at height %3%). The print may show color bleeding. "
                                "Increase the belt purge tower width, or reduce flushing volumes."),
                           int(std::ceil(total_leftover)), int(std::ceil(worst_layer_leftover)),
                           Slic3r::float_to_string_decimal_point(worst_layer_z, 2)));
    }
}

References _align_belt_purge_layers(), _u8L, Slic3r::PrintBaseWithState< PrintStep, psCount >::active_step_add_warning(), Slic3r::PrintObject::belt_drop_unclaimed_fills(), Slic3r::cast(), Slic3r::PrintStateBase::CRITICAL, EPSILON, Slic3r::float_to_string_decimal_point(), Slic3r::flush_multiplier(), Slic3r::format(), Slic3r::get_flush_volumes_matrix(), Slic3r::PrintObject::get_layer_at_printz(), m_config, m_objects, m_wipe_tower_data, PrintObject, and Slic3r::PrintBaseWithState< PrintStep, psCount >::throw_if_canceled().

Here is the call 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,
		PrintStateBase::SlicingNotificationType	message_id = PrintStateBase::SlicingDefaultNotification )

inlineinherited

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

References m_state, Slic3r::PrintStateBase::SlicingDefaultNotification, Slic3r::PrintBase::state_mutex(), and Slic3r::PrintBase::status_update_warnings().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ append_model_object_extruders()

void Slic3r::Print::append_model_object_extruders	(	const ModelObject &	mo,
		std::vector< unsigned int > &	extruders )

staticprivate

{
    for (const ModelVolume* mv : mo.volumes) {
        std::vector<int> volume_extruders = mv->get_extruders();
        for (int extruder : volume_extruders) {
            assert(extruder > 0);
            extruders.push_back(extruder - 1);
        }
    }
 
    // layer range
    for (auto layer_range : mo.layer_config_ranges) {
        if (layer_range.second.has("extruder")) {
            //BBS: actually when user doesn't change filament by height range(value is default 0), height range should not save key "extruder".
            //Don't know why height range always save key "extruder" because of no change(should only save difference)...
            //Add protection here to avoid overflow
            auto value = layer_range.second.option("extruder")->getInt();
            if (value > 0)
                extruders.push_back(value - 1);
        }
    }
}

References extruders(), Slic3r::ModelVolume::get_extruders(), Slic3r::ModelObject::layer_config_ranges, and Slic3r::ModelObject::volumes.

Referenced by object_extruders(), and update_shrinkage_compensation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ append_support_extruders()

bool Slic3r::Print::append_support_extruders	(	const PrintObjectConfig &	config,
		unsigned int	num_extruders,
		std::vector< unsigned int > &	extruders )

staticprivate

{
    bool uses_current_extruder = false;
    assert(config.support_filament >= 0);
    if (config.support_filament == 0)
        uses_current_extruder = true;
    else {
        unsigned int i = (unsigned int)config.support_filament - 1;
        extruders.emplace_back((i >= num_extruders) ? 0 : i);
    }
    assert(config.support_interface_filament >= 0);
    if (config.support_interface_filament == 0)
        uses_current_extruder = true;
    else {
        unsigned int i = (unsigned int)config.support_interface_filament - 1;
        extruders.emplace_back((i >= num_extruders) ? 0 : i);
    }
    return uses_current_extruder;
}

References config(), extruders(), and Slic3r::PrintObjectConfig.

Referenced by support_material_extruders(), and update_shrinkage_compensation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ append_tool_change_extruders()

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

private

{
    //BBS
    int num_extruders = m_config.filament_colour.size();
    if (m_model.plates_custom_gcodes.find(m_model.curr_plate_index) != m_model.plates_custom_gcodes.end()) {
        for (auto item : m_model.plates_custom_gcodes.at(m_model.curr_plate_index).gcodes) {
            if (item.type == CustomGCode::Type::ToolChange && item.extruder <= num_extruders)
                extruders.push_back((unsigned int)(item.extruder - 1));
        }
    }
}

References extruders(), m_config, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_model, and Slic3r::CustomGCode::ToolChange.

Referenced by extruders(), and update_shrinkage_compensation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ append_wipe_tower_extruder()

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

private

{
    // If a wipe tower filament is explicitly set, ensure it participates in tool ordering.
    if (has_wipe_tower() && config().wipe_tower_filament != 0 && extruders.size() > 1) {
        assert(config().wipe_tower_filament > 0 && config().wipe_tower_filament <= int(config().filament_diameter.size()));
        extruders.emplace_back(config().wipe_tower_filament - 1); // config value is 1-based
    }
}

References config(), extruders(), and has_wipe_tower().

Referenced by extruders(), and update_shrinkage_compensation().

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,
		bool	extruder_applied = false )

overridevirtual

Implements Slic3r::PrintBase.

{
#ifdef _DEBUG
    check_model_ids_validity(model);
#endif /* _DEBUG */
 
    //BBS: add more logs
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", Line %1%: enter")%__LINE__;
    // 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);
 
    // BBS
    std::vector <unsigned int> used_filaments = this->extruders(true);
    std::unordered_set <unsigned int> used_filament_set(used_filaments.begin(), used_filaments.end());
 
    // A mixed slot is virtual: the filaments actually consumed are its components, so add them
    // to the used set or they would be treated as unused and stripped from the config.
    {
        auto* is_mixed_opt  = new_full_config.option<ConfigOptionBools>("filament_is_mixed");
        auto* comp_strs_opt = new_full_config.option<ConfigOptionStrings>("filament_mixed_components");
        if (is_mixed_opt && comp_strs_opt && has_any_mixed_filament(is_mixed_opt->values)) {
            auto expanded = expand_mixed_filaments(used_filaments, is_mixed_opt->values, comp_strs_opt->values);
            used_filament_set.insert(expanded.begin(), expanded.end());
        }
    }
 
    //new_full_config.normalize_fdm(used_filaments);
    new_full_config.normalize_fdm_1();
    t_config_option_keys changed_keys = new_full_config.normalize_fdm_2(objects().size(), used_filaments.size());
    if (changed_keys.size() > 0) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", got changed_keys, size=%1%")%changed_keys.size();
        for (int i = 0; i < changed_keys.size(); i++)
        {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", i=%1%, key=%2%")%i %changed_keys[i];
        }
    }
    // On belt printers the support tilt follows the slicing rotation. The GUI keeps the two in
    // sync, but a CLI or 3MF edit of the rotation alone would otherwise leave supports on a stale tilt.
    if (const auto *belt_opt = new_full_config.option<ConfigOptionBool>("belt_printer"); belt_opt && belt_opt->value) {
        const auto *axis_opt  = new_full_config.option<ConfigOptionEnum<BeltRotationAxis>>("belt_slice_rotation");
        const auto *angle_opt = new_full_config.option<ConfigOptionFloat>("belt_slice_rotation_angle");
        if (axis_opt && angle_opt) {
            const auto tilt = BeltTransformPipeline::physical_tilt(axis_opt->value, angle_opt->value);
            new_full_config.set_key_value("build_plate_tilt_x", new ConfigOptionFloat(tilt.tilt_x_deg));
            new_full_config.set_key_value("build_plate_tilt_y", new ConfigOptionFloat(tilt.tilt_y_deg));
        }
    }
    const ConfigOption* enable_support_option = new_full_config.option("enable_support");
    if (enable_support_option && enable_support_option->getBool())
        m_support_used = true;
    else
        m_support_used = false;
 
    {
        const auto& o = model.objects;
        const auto opt_has_scarf_joint_seam = [](const DynamicConfig& c) {
            return c.has("seam_slope_type") && c.opt_enum<SeamScarfType>("seam_slope_type") != SeamScarfType::None;
        };
        const bool has_scarf_joint_seam = std::any_of(o.begin(), o.end(), [&new_full_config, &opt_has_scarf_joint_seam](ModelObject* obj) {
            return obj->get_config_value<ConfigOptionEnum<SeamScarfType>>(new_full_config, "seam_slope_type")->value != SeamScarfType::None ||
                   std::any_of(obj->volumes.begin(), obj->volumes.end(), [&opt_has_scarf_joint_seam](const ModelVolume* v) { return opt_has_scarf_joint_seam(v->config.get());}) ||
                   std::any_of(obj->layer_config_ranges.begin(), obj->layer_config_ranges.end(), [&opt_has_scarf_joint_seam](const auto& r) { return opt_has_scarf_joint_seam(r.second.get());});
        });
 
        if (has_scarf_joint_seam) {
            new_full_config.set("has_scarf_joint_seam", true);
        }
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", has_scarf_joint_seam:" << has_scarf_joint_seam;
    }
 
    //apply extruder related values
    std::vector<int> print_variant_index;
    std::vector<std::vector<NozzleVolumeType>> nozzle_volume_types;
    int extruder_count = 1, extruder_volume_type_count = 1;
    bool different_extruder = false;
    // Filled only when the filament arrays are rebuilt from a persisted selector result below;
    // print_config_diffs then keys the retract overrides per expanded slot.
    std::vector<int> dynamic_slot_indices;
 
    different_extruder = new_full_config.support_different_extruders(extruder_count);
    extruder_volume_type_count = new_full_config.get_extruder_nozzle_volume_count(extruder_count, nozzle_volume_types);
    if (!extruder_applied) {
        if ((extruder_count > 1) || different_extruder) {
            // variant_2 must be processed first, because variant_1 will make `printer_extruder_id` and `printer_extruder_variant` half of the size that makes `get_index_for_extruder` no longer work properly
            new_full_config.update_values_to_printer_extruders(new_full_config, extruder_count, extruder_volume_type_count, nozzle_volume_types, printer_options_with_variant_2, "printer_extruder_id", "printer_extruder_variant", 2);
            new_full_config.update_values_to_printer_extruders(new_full_config, extruder_count, extruder_volume_type_count, nozzle_volume_types, printer_options_with_variant_1, "printer_extruder_id", "printer_extruder_variant");
            //update print config related with variants
            print_variant_index = new_full_config.update_values_to_printer_extruders(new_full_config, extruder_count, extruder_volume_type_count, nozzle_volume_types, print_options_with_variant, "print_extruder_id", "print_extruder_variant");
        }
        else
            print_variant_index.resize(1, 0);
 
        m_ori_full_print_config = new_full_config;
 
        std::set<std::string> filament_keys = filament_options_with_variant;
        filament_keys.insert("filament_self_index");
        // A persisted selector result with an actual migration means the last slice rebuilt the
        // per-slot filament arrays from it (one slot per variant a filament prints through).
        // Reproduce that exact expansion here so an unchanged config diffs empty — the expanded
        // keys invalidate the wipe tower / g-code export, and the placeholder parser aliases
        // the full config — instead of trimming back to one slot per filament.
        auto group_result = this->get_layered_nozzle_group_result();
        std::unordered_map<int, std::vector<FilamentVariantUse>> filament_variant_uses;
        if (group_result && group_result->is_support_dynamic_nozzle_map()
            && collect_filament_variant_uses(*group_result, m_ori_full_print_config, filament_variant_uses))
            new_full_config.update_filament_config_values_for_multiple_extruders(m_ori_full_print_config, filament_variant_uses,
                                                                                 extruder_count, extruder_volume_type_count, filament_keys,
                                                                                 "filament_self_index", "filament_extruder_variant",
                                                                                 &dynamic_slot_indices);
        // Orca: also on a printer with a single extruder variant once a filament defines several
        // (e.g. Standard and High Flow), so each filament takes its variant for that extruder.
        else if ((extruder_count > 1) || different_extruder || new_full_config.has_multi_variant_filament())
            new_full_config.update_values_to_printer_extruders_for_multiple_filaments(m_ori_full_print_config, extruder_count, extruder_volume_type_count, filament_keys,
                                                                                      "filament_self_index", "filament_extruder_variant");
    }
    else {
        //should not come here, we can not get the result of print_variant, for the values have been updated
        //we just use the default values here
        auto variant_opt = dynamic_cast<const ConfigOptionStrings *>(new_full_config.option("printer_extruder_variant"));
        print_variant_index.resize(variant_opt->values.size());
        for (int e_index = 0; e_index < variant_opt->values.size(); e_index++)
        {
            print_variant_index[e_index] = e_index;
        }
    }
 
    // Fill in physical_extruder_map when the printer profile has not authored one. It has one
    // entry per logical extruder, so it is sized from the nozzle count -- not from
    // printer_extruder_id, which is indexed by variant slot.
    //
    // IMEX printers only. physical_extruder_map carries two readings in this tree (see
    // IMEXHelpers.hpp): the IMEX paths need one entry per logical extruder, the inherited BBL
    // paths read it through the clamping get_at(), which collapses every logical extruder to
    // physical 0 while the profile default is the single-element {0}. Deriving the identity
    // unconditionally would impose the IMEX reading on printers that mean the other one and
    // change what they emit -- {first_tools}/{first_filaments}/{first_non_support_*} and
    // {most_used_physical_extruder_id}/{curr_physical_extruder_id} in custom start G-code, plus
    // the `; physical_extruder_map =` line in the G-code config block -- for every multi-nozzle
    // profile that never authored a map. Non-IMEX printers therefore keep the config value
    // exactly as it arrives, which is what upstream slices with.
    const auto* is_imex_opt = new_full_config.option<ConfigOptionBool>("is_imex");
    if (is_imex_opt && is_imex_opt->value) {
        auto* pem = new_full_config.option<ConfigOptionInts>("physical_extruder_map", true);
        if (pem) {
            pem->values = effective_physical_extruder_map(pem, extruder_count).values;
            // m_ori_full_print_config was snapshotted above, before this derivation, and the
            // selector write-back path rebuilds m_full_print_config from that snapshot. Without
            // mirroring the derived map into it, m_full_print_config keeps the unexpanded default
            // while every later apply re-derives the expanded one, so an unchanged config diffs
            // on physical_extruder_map forever and invalidates all steps on every re-apply.
            if (auto* ori_pem = m_ori_full_print_config.option<ConfigOptionInts>("physical_extruder_map", true))
                ori_pem->values = pem->values;
        }
    }
 
    auto opt_filament_map = new_full_config.option<ConfigOptionInts>("filament_map");
    std::vector<int> filament_maps = opt_filament_map ? opt_filament_map->values : std::vector<int>();
 
    // Find modified keys of the various configs. Resolve overrides extruder retract values by filament profiles.
    DynamicPrintConfig   filament_overrides;
    //BBS: add plate index
    t_config_option_keys print_diff       = print_config_diffs(m_config, new_full_config, filament_overrides, this->m_plate_index, filament_maps,
                                                                dynamic_slot_indices.empty() ? nullptr : &dynamic_slot_indices);
    // Orca: filament_map_2 is engine-derived state, never a user input: the rebuild below
    // recomputes it from filament_map/filament_volume_map/the variant slots on every apply
    // (all of which are diffed and invalidation-listed on their own), and the grouping
    // write-back overwrites it during process(). The incoming full config only ever carries
    // the ConfigDef default, so diffing it would invalidate every print step on each apply
    // for any multi-extruder printer and permanently invalidate fresh slice results.
    print_diff.erase(std::remove(print_diff.begin(), print_diff.end(), "filament_map_2"), print_diff.end());
    t_config_option_keys full_config_diff = full_print_config_diffs(m_full_print_config, new_full_config, this->m_plate_index);
    // 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);
 
    //BBS: process the filament_map related logic
    std::unordered_set<std::string> print_diff_set(print_diff.begin(), print_diff.end());
    if (!print_diff_set.empty() && print_diff_set.find("filament_map_mode") == print_diff_set.end())
    {
        FilamentMapMode map_mode = new_full_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode", true)->value;
        if (is_auto_filament_map_mode(map_mode)) {
            if (print_diff_set.find("filament_map") != print_diff_set.end()) {
                print_diff_set.erase("filament_map");
                //full_config_diff.erase("filament_map");
                ConfigOptionInts* old_opt = m_full_print_config.option<ConfigOptionInts>("filament_map", true);
                ConfigOptionInts* new_opt = new_full_config.option<ConfigOptionInts>("filament_map", true);
                old_opt->set(new_opt);
                m_config.filament_map = *new_opt;
            }
            if (print_diff_set.find("filament_volume_map") != print_diff_set.end()) {
                print_diff_set.erase("filament_volume_map");
                //full_config_diff.erase("filament_volume_map");
                ConfigOptionInts* old_opt = m_full_print_config.option<ConfigOptionInts>("filament_volume_map", true);
                ConfigOptionInts* new_opt = new_full_config.option<ConfigOptionInts>("filament_volume_map", true);
                old_opt->set(new_opt);
                m_config.filament_volume_map = *new_opt;
            }
            if (print_diff_set.find("filament_nozzle_map") != print_diff_set.end()) {
                print_diff_set.erase("filament_nozzle_map");
                //full_config_diff.erase("filament_nozzle_map");
                ConfigOptionInts* old_opt = m_full_print_config.option<ConfigOptionInts>("filament_nozzle_map", true);
                ConfigOptionInts* new_opt = new_full_config.option<ConfigOptionInts>("filament_nozzle_map", true);
                old_opt->set(new_opt);
                m_config.filament_nozzle_map = *new_opt;
            }
        }
        else {
            print_diff_set.erase("extruder_ams_count");
            if (map_mode == fmmManual) {
                // filament_nozzle_map is an engine output, not a GUI input, in manual mode
                print_diff_set.erase("filament_nozzle_map");
            }
            std::vector<int> old_filament_map = m_config.filament_map.values;
            std::vector<int> new_filament_map = new_full_config.option<ConfigOptionInts>("filament_map", true)->values;
 
            if (old_filament_map.size() == new_filament_map.size())
            {
                bool same_map = true;
                for (size_t index = 0; index < old_filament_map.size(); index++)
                {
                    if ((old_filament_map[index] == new_filament_map[index])
                        || (used_filament_set.find(index) == used_filament_set.end()))
                        continue;
                    else {
                        same_map = false;
                        break;
                    }
                }
                if (same_map) {
                    print_diff_set.erase("filament_map");
 
                    // The extruder retract overrides are keyed by the (unchanged) filament map;
                    // recompute them and drop diffs whose recomputed value matches the current
                    // config, so a cosmetic reordering of unused filaments does not invalidate.
                    const auto& retract_keys = print_config_def.extruder_retract_keys();
                    const std::string filament_prefix = "filament_";
                    std::vector<int> old_f_map_indices(old_filament_map.size(), 0);
                    for (size_t i = 0; i < old_filament_map.size(); i++)
                        old_f_map_indices[i] = old_filament_map[i] - 1;
 
                    for (const auto& rk : retract_keys) {
                        if (print_diff_set.find(rk) == print_diff_set.end())
                            continue;
                        const ConfigOption* opt_old   = m_config.option(rk);
                        const ConfigOption* opt_new_m = new_full_config.option(rk);
                        const ConfigOption* opt_new_f = new_full_config.option(filament_prefix + rk);
                        if (opt_old && opt_new_m && opt_new_f) {
                            std::unique_ptr<ConfigOption> opt_recomputed(opt_new_m->clone());
                            opt_recomputed->apply_override(opt_new_f, old_f_map_indices);
                            if (*opt_old == *opt_recomputed)
                                print_diff_set.erase(rk);
                        }
                    }
                }
            }
        }
        if (print_diff_set.size() != print_diff.size())
            print_diff.assign(print_diff_set.begin(), print_diff_set.end());
    }
 
    //filament_map_2
    // Orca: seed with 0-based extruder indices so the copy stays a valid slot map even when the
    // variant options are absent below and the rebuild loop is skipped (unit tests, degenerate
    // presets); the loop overwrites every entry when it runs.
    m_config.filament_map_2.values = filament_maps;
    for (auto& v : m_config.filament_map_2.values)
        --v;
    auto opt_extruder_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(new_full_config.option("extruder_type"));
    auto opt_filament_volume_maps = dynamic_cast<const ConfigOptionInts*>(new_full_config.option("filament_volume_map"));
    auto opt_nozzle_volume_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(new_full_config.option("nozzle_volume_type"));
    for (int index = 0; opt_extruder_type && opt_nozzle_volume_type && index < filament_maps.size(); index++)
    {
        ExtruderType extruder_type = (ExtruderType)(opt_extruder_type->get_at(filament_maps[index] - 1));
        NozzleVolumeType nozzle_volume_type = (NozzleVolumeType)(opt_nozzle_volume_type->get_at(filament_maps[index] - 1));
        // Orca: honour the per-filament volume map only when a producer sized it to the filament
        // count; mis-sized maps (stale project values, CLI runs until the per-filament synthesis
        // lands there) must not be indexed per filament (see
        // update_values_to_printer_extruders_for_multiple_filaments for the same guard).
        if ((extruder_volume_type_count > extruder_count) && opt_filament_volume_maps
            && opt_filament_volume_maps->values.size() == filament_maps.size())
            nozzle_volume_type = (NozzleVolumeType)(opt_filament_volume_maps->values[index]);
        // Orca: when the process variant columns cannot be matched (degenerate
        // print_extruder_id), key the override by plain extruder index like the seeding
        // above instead of poisoning the map with -1.
        int slot_index = new_full_config.get_index_for_extruder(filament_maps[index], "print_extruder_id", extruder_type, nozzle_volume_type, "print_extruder_variant");
        m_config.filament_map_2.values[index] = slot_index >= 0 ? slot_index : filament_maps[index] - 1;
    }
 
    // 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);
        //BBS: add more logs
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", got print_diff %1%, object_diff %2%, region_diff %3%, set status to APPLY_STATUS_CHANGED")%print_diff.size() %object_diff.size() %region_diff.size();
    }
 
    // 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.filament_diameter.size();
    bool   num_extruders_changed  = false;
    if (! full_config_diff.empty()) {
        //BBS: add more logs
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: found full_config_diff changed.")%__LINE__;
        update_apply_status(this->invalidate_step(psGCodeExport));
        m_placeholder_parser.clear_config();
        // clear_config() wiped the constructor-set "version"; restore it for custom G-code.
        m_placeholder_parser.set("version", std::string(SoftFever_VERSION));
        // 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());
    // 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);
        m_full_print_config = new_full_config;
        update_filament_self_index_cache();
        if (num_extruders  != m_config.filament_diameter.size()) {
            num_extruders  = m_config.filament_diameter.size();
            num_extruders_changed  = true;
        }
    }
    else if (! print_diff.empty()) {
        // Orca: m_config can diverge from an unchanged full config (e.g. the in-slice retract
        // override recompute writing different values than the apply-time computation). The
        // invalidation above already fired for print_diff, so repair m_config here as well;
        // otherwise the divergence is never corrected and every subsequent apply of the same
        // config invalidates the result again, forever.
        m_placeholder_parser.apply_config(filament_overrides);
        m_config.apply_only(new_full_config, print_diff, true);
        m_config.apply(filament_overrides);
    }
 
    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 {
        //BBS: replace model custom gcode with current plate custom gcode
        m_model.curr_plate_index = model.curr_plate_index;
        if (m_model.get_curr_plate_custom_gcodes() != model.get_curr_plate_custom_gcodes()) {
            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.get_curr_plate_custom_gcodes().gcodes, model.get_curr_plate_custom_gcodes().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.plates_custom_gcodes[m_model.curr_plate_index] = model.get_curr_plate_custom_gcodes();
        }
        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.
            //BBS: we don't need to set invalid here, we judge it by comparing the print_object list
            //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);
            }
            //BBS: add more logs
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: new model objects added.")%__LINE__;
        } else {
            //BBS: add more logs
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: model object changed.")%__LINE__;
            // Reorder the objects, add new objects.
            // First stop background processing before shuffling or deleting the PrintObjects in the object list.
            this->call_cancel_callback();
            //BBS: we don't need to set invalid here, we judge it by comparing the print_object list
            //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 };
    const std::initializer_list<ModelVolumeType> precise_seam_types {
        ModelVolumeType::PRECISE_SEAM_CENTER, ModelVolumeType::PRECISE_SEAM_LEFT,
        ModelVolumeType::PRECISE_SEAM_RIGHT,  ModelVolumeType::PRECISE_SEAM_ENFORCED,
        ModelVolumeType::PRECISE_SEAM_BLOCKED, ModelVolumeType::PRECISE_SEAM_NEUTRAL
    };
    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) ||
                                          model_fuzzy_skin_data_changed(model_object, model_object_new);
        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 precise_seam_differ        = model_volume_list_changed(model_object, model_object_new, precise_seam_types);
        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;
        bool brim_points_differ = model_brim_points_data_changed(model_object, model_object_new);
        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 (precise_seam_differ) {
                // First stop background processing before shuffling or deleting the ModelVolumes in the ModelObject's list.
                this->call_cancel_callback();
                update_apply_status(false);
                // Invalidate seam placement (affects G-code export).
                update_apply_status(this->invalidate_step(psGCodeExport));
            } else if (model_custom_seam_data_changed(model_object, model_object_new)) {
                update_apply_status(this->invalidate_step(psGCodeExport));
            }
            // Synchronize both families once, after cancellation and all affected-step invalidations.
            // This also handles type changes between supports and Precise Seam before copying configs below.
            if (supports_differ || precise_seam_differ)
                model_volume_list_update_supports_and_seams(model_object, model_object_new);
            if (brim_points_differ) {
                model_object.brim_points = model_object_new.brim_points;
                update_apply_status(this->invalidate_all_steps());
            }
        }
        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, print_variant_index);
                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);
      // Synchronize Precise Seam modifier volumes
      model_volume_list_copy_configs(model_object /* dst */, model_object_new /* src */, precise_seam_types);
            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.
        model_object.invalidate_bounding_box();
            // 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) {
                    if (is_printable_filament_changed(new_full_config, (*old_instance)->convex_hull_2d(), (*new_instance)->convex_hull_2d())) {
                        update_apply_status(this->invalidate_steps({psWipeTower, psGCodeExport}));
                    }
                    (*old_instance)->set_transformation((*new_instance)->get_transformation());
                    (*old_instance)->print_volume_state = (*new_instance)->print_volume_state;
                    (*old_instance)->printable        = (*new_instance)->printable;
          }
          }
        }
    }
 
    // 4) Generate PrintObjects from ModelObjects and their instances.
    {
        this->update_shrinkage_compensation(num_extruders, print_variant_index);
        PrintObjectPtrs print_objects_new;
        print_objects_new.reserve(std::max(m_objects.size(), m_model.objects.size()));
        bool new_objects = false;
        bool belt_instances_shifted = 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));
            // Orca: Updated for XYZ filament shrink compensation
            // Belt printers: force each instance into its own PrintObject so each
            // gets independent layer Z values (its bed position is folded into them).
            bool belt_force_separate = m_config.belt_printer.value;
            model_object_status.print_instances = print_objects_from_model_object(*model_object, this->shrinkage_compensation(), belt_force_separate);
            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, &print_variant_index](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_variant_index));
                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) {
                        size_t extruder_num = new_full_config.option<ConfigOptionFloats>("nozzle_diameter")->size();
                        update_apply_status(status == PrintBase::APPLY_STATUS_INVALIDATED);
                        belt_instances_shifted = true;
                    }
          print_objects_new.emplace_back((*it_old)->print_object);
          const_cast<PrintObjectStatus*>(*it_old)->status = PrintObjectStatus::Reused;
        }
            }
        }
        if (m_objects != print_objects_new) {
            //BBS: add more logs
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: found print object changed.")%__LINE__;
            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({ psSkirtBrim, psWipeTower, psGCodeExport }));
            // A belt brim is clipped against the other objects on the plate (BeltBrim.cpp,
            // belt_brim_obstacles), and it is rebuilt with its object's support step: an
            // object that arrived or left changes every other brim owner's brim.
            if ((new_objects || deleted_objects) && m_config.belt_printer.value)
                for (PrintObject *object : m_objects)
                    if (object->has_belt_brim())
                        update_apply_status(object->invalidate_step(posSupportMaterial));
      if (new_objects)
              update_apply_status(false);
            print_regions_reshuffled = true;
        }
        print_object_status_db.clear();
 
        // BBS
        for (PrintObject* object : m_objects) {
            auto ept_iter = std::find(print_diff.begin(), print_diff.end(), "enable_prime_tower");
            if (/*object->config().adaptive_layer_height &&*/ ept_iter != print_diff.end()) {
                update_apply_status(object->invalidate_step(posSlice));
            }
        }
 
        // Belt printer: when any object's instances shifted, re-slice every object.
        // The global Z offset follows each object's position along the belt, and the
        // belt brims are clipped against the other objects.
        if (belt_instances_shifted && m_config.belt_printer.value) {
            for (PrintObject *object : m_objects)
                update_apply_status(object->invalidate_step(posSlice));
        }
    }
 
    //BBS: check the config again
    int new_used_filaments = this->extruders(true).size();
    t_config_option_keys new_changed_keys = new_full_config.normalize_fdm_2(objects().size(), new_used_filaments);
    if (new_changed_keys.size() > 0) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", got new_changed_keys, size=%1%")%new_changed_keys.size();
        for (int i = 0; i < new_changed_keys.size(); i++)
        {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", i=%1%, key=%2%")%i %new_changed_keys[i];
        }
 
        update_apply_status(false);
 
        // The following call may stop the background processing.
        update_apply_status(this->invalidate_state_by_config_options(new_full_config, new_changed_keys));
 
        update_apply_status(this->invalidate_step(psGCodeExport));
 
        if (full_config_diff.empty()) {
            //BBS: previous empty
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: full_config_diff previous empty, need to apply now.")%__LINE__;
 
            m_placeholder_parser.clear_config();
            // clear_config() wiped the constructor-set "version"; restore it for custom G-code.
            m_placeholder_parser.set("version", std::string(SoftFever_VERSION));
            // 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.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, new_changed_keys, true);
        // Handle changes to object config defaults
        m_default_object_config.apply_only(new_full_config, new_changed_keys, true);
        // Handle changes to regions config defaults
        m_default_region_config.apply_only(new_full_config, new_changed_keys, true);
        // Orca: keep the pre-expansion snapshot in sync with this late normalization pass.
        // The engine map write-back rebuilds m_full_print_config from m_ori_full_print_config
        // after slicing; a stale snapshot would resurrect the un-normalized values (e.g.
        // enable_prime_tower on a single-filament print) in the dumped config and spuriously
        // re-invalidate the g-code on the next apply.
        m_ori_full_print_config.apply_only(new_full_config, new_changed_keys, true);
        m_full_print_config = std::move(new_full_config);
        update_filament_self_index_cache();
    }
 
    // Per-part gradient: compute the per-slot enable bit vector once for this Print::apply pass.
    // Used by generate_print_object_regions to decide which volumes deserve their own PrintRegion.
    std::vector<bool> slot_per_part_enabled;
    {
        const auto &is_mixed_vec   = m_config.filament_is_mixed.values;
        const auto &grad_vec       = m_config.filament_mixed_gradient.values;
        const auto &per_part_vec   = m_config.filament_mixed_gradient_per_part.values;
        const auto &components_vec = m_config.filament_mixed_components.values;
        slot_per_part_enabled.assign(is_mixed_vec.size(), false);
        for (size_t i = 0; i < is_mixed_vec.size(); ++i) {
            if (! is_mixed_vec[i])
                continue;
            std::vector<unsigned int> comps = parse_mixed_components(i < components_vec.size() ? components_vec[i] : "");
            if (comps.size() != 2)
                continue;
            if (i >= grad_vec.size() || ! grad_vec[i])
                continue;
            if (i >= per_part_vec.size() || ! per_part_vec[i])
                continue;
            slot_per_part_enabled[i] = true;
        }
    }
 
    // 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()) {
 
            std::array<bool, static_cast<size_t>(EnforcerBlockerType::ExtruderMax) + 1> used_facet_states{};
            for (const ModelVolume *volume : volumes) {
                const std::vector<bool> &volume_used_facet_states = volume->mmu_segmentation_facets.get_data().used_states;
 
                // Paint data saved before the painted state range was extended deserializes a
                // shorter used_states vector, so merge over the common prefix.
                for (size_t state_idx = 0; state_idx < std::min(volume_used_facet_states.size(), used_facet_states.size()); ++state_idx)
                    used_facet_states[state_idx] |= volume_used_facet_states[state_idx];
            }
 
            for (size_t state_idx = static_cast<size_t>(EnforcerBlockerType::Extruder1); state_idx < used_facet_states.size(); ++state_idx) {
                if (used_facet_states[state_idx])
                    painting_extruders.emplace_back(state_idx);
            }
        }
        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,
                    *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));
                    },
                    print_variant_index)) {
                // Per-part gradient: PrintRegionConfig alone cannot reveal a change in which slots
                // have per-part enabled, so compare against the snapshot taken when these regions
                // were generated and regenerate on any difference (slot toggled, per-part moved
                // between slots, eligibility changed via components / gradient / is_mixed).
                if (print_object_regions->last_slot_per_part_enabled != slot_per_part_enabled) {
                    invalidate();
                    model_object_status.print_object_regions_status = ModelObjectStatus::PrintObjectRegionsStatus::PartiallyValid;
                    print_regions_reshuffled = true;
                }
                // 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_contour_compensation.value),
                painting_extruders,
                print_variant_index,
                print_object.is_fuzzy_skin_painted(),
                slot_per_part_enabled);
        }
        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();
        m_support_used |= object->config().enable_support;
    }
 
#ifdef _DEBUG
    check_model_ids_equal(m_model, model);
#endif /* _DEBUG */
 
  //BBS: add timestamp logic
  if (apply_status != APPLY_STATUS_UNCHANGED)
    m_modified_count++;
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: finished,  this %2%, m_modified_count %3%, apply_status %4%, m_support_used %5%")%__LINE__ %this %m_modified_count %apply_status %m_support_used;
  return static_cast<ApplyStatus>(apply_status);
}

References apply(), Slic3r::check_model_ids_validity(), Slic3r::expand_mixed_filaments(), extruders(), Slic3r::ConfigOption::getBool(), Slic3r::has_any_mixed_filament(), Slic3r::has_scarf_joint_seam(), Slic3r::ModelObject::layer_config_ranges, m_support_used, Slic3r::PrintBaseWithState< PrintStep, psCount >::model(), Slic3r::None, Slic3r::DynamicPrintConfig::normalize_fdm_1(), Slic3r::DynamicPrintConfig::normalize_fdm_2(), objects(), Slic3r::ConfigBase::option(), Slic3r::BeltTransformPipeline::physical_tilt(), Slic3r::ConfigBase::set(), Slic3r::DynamicConfig::set_key_value(), Slic3r::ConfigOptionSingle< T >::value, and Slic3r::ConfigOptionVector< unsigned char >::values.

Referenced by apply(), Slic3r::GUI::Plater::load_gcode(), and anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_config_for_render()

void Slic3r::Print::apply_config_for_render ( const DynamicConfig & config )

{
    m_config.apply(config);
}

References apply_config_for_render(), config(), and m_config.

Referenced by apply_config_for_render(), and Slic3r::GUI::Plater::load_gcode().

Here is the call graph for this function:

Here is the caller 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.

95{ this->set_new_unique_id(); }

Slic3r::ObjectBase::set_new_unique_id

void set_new_unique_id()

Definition ObjectID.hpp:89

References 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::ModelVolume::config, Slic3r::ModelConfig::has(), Slic3r::ModelVolume::is_model_part(), Slic3r::ModelVolume::is_modifier(), Slic3r::ModelVolume::material_id(), Slic3r::ModelConfig::set(), and Slic3r::ModelObject::volumes.

Referenced by anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ brim_flow()

Flow Slic3r::Print::brim_flow ( ) const

{
    ConfigOptionFloatOrPercent width = m_config.initial_layer_line_width;
    if (width.value <= 0)
        width = m_print_regions.front()->config().inner_wall_line_width;
    if (width.value <= 0)
        width = m_objects.front()->config().line_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,
        // Flow::new_from_config_width takes care of the percent to value substitution
    width,
        (float)nozzle_diameter_for_filament(m_config, m_print_regions.front()->config().outer_wall_filament_id, this->is_BBL_printer()),
    (float)this->skirt_first_layer_height());
}

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

Referenced by _make_skirt(), Slic3r::make_belt_brim(), Slic3r::make_brim(), Slic3r::makeBrimInfillImpl(), Slic3r::outer_inner_brim_area(), and Slic3r::tryExPolygonOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calib_mode() [1/2]

CalibMode & Slic3r::Print::calib_mode ( )

inline

1344{ return m_calib_params.mode; }

Slic3r::Print::m_calib_params

Calib_Params m_calib_params

Definition Print.hpp:1584

References m_calib_params.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::process_layer(), and Slic3r::GCode::set_object_info().

Here is the caller graph for this function:

◆ calib_mode() [2/2]

const CalibMode Slic3r::Print::calib_mode ( ) const

inline

1345{ return m_calib_params.mode; }

References m_calib_params.

◆ calib_params()

const Calib_Params & Slic3r::Print::calib_params ( ) const

inline

1347{ return m_calib_params; }

References m_calib_params.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::generate_timelapse_gcode(), and Slic3r::GCode::process_layer().

Here is the caller graph for this function:

◆ call_cancel_callback()

void Slic3r::PrintBase::call_cancel_callback ( )

inlineprotectedinherited

540{ m_cancel_callback(); }

Slic3r::PrintBase::m_cancel_callback

cancel_callback_type m_cancel_callback

Definition PrintBase.hpp:580

References m_cancel_callback.

◆ cancel()

void Slic3r::PrintBase::cancel ( )

inlineinherited

510{ m_cancel_status = CANCELED_BY_USER; }

Slic3r::PrintBase::m_cancel_status

std::atomic< CancelStatus > m_cancel_status

Definition PrintBase.hpp:577

References CANCELED_BY_USER, and m_cancel_status.

Referenced by Slic3r::GUI::GLGizmoFdmSupports::invalid_support_volumes(), and Slic3r::GUI::GLGizmoFdmSupports::on_shutdown().

Here is the caller graph for this function:

◆ cancel_callback()

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

inlineprotectedinherited

539{ return m_cancel_callback; }

References m_cancel_callback.

Referenced by Slic3r::PrintObjectBase::cancel_callback(), Slic3r::PrintBaseWithState< PrintStep, psCount >::invalidate_all_steps(), Slic3r::PrintBaseWithState< PrintStep, psCount >::invalidate_step(), Slic3r::PrintBaseWithState< PrintStep, psCount >::invalidate_steps(), and set_cancel_callback().

Here is the caller graph for this function:

◆ cancel_internal()

void Slic3r::PrintBase::cancel_internal ( )

inlineinherited

511{ m_cancel_status = CANCELED_INTERNAL; }

References CANCELED_INTERNAL, and m_cancel_status.

◆ cancel_status()

CancelStatus Slic3r::PrintBase::cancel_status ( ) const

inlineinherited

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

References m_cancel_status.

◆ canceled()

bool Slic3r::PrintBase::canceled ( ) const

inlineinherited

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

References m_cancel_status, and NOT_CANCELED.

Referenced by Slic3r::GCode::do_export(), and Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_slicing_pipeline_hook().

Here is the caller graph for this function:

◆ check_multi_filament_valid()

StringObjectException Slic3r::Print::check_multi_filament_valid ( const Print & print )

staticprivate

{
    auto print_config = print.config();
    const std::string incompatible_temp_msg = L("Selected nozzle temperatures are incompatible. Each filament's nozzle temperature must fall within the recommended nozzle temperature range of the other filaments. Otherwise, nozzle clogging or printer damage may occur.");
    const std::string invalid_temp_range_msg = L("Invalid recommended nozzle temperature range. The lower bound must be lower than the upper bound.");
    const std::string incompatible_temp_msg_preferences_enable = L("If you still want to print, you can enable the option in Preferences / Control / Slicing / Remove mixed temperature restriction.");
    if(print_config.print_sequence == PrintSequence::ByObject) {// use ByObject valid under ByObject print sequence
        bool has_incompatible_object = false;
        bool enable_mix_printing = !print.need_check_multi_filaments_compatibility();
        StringObjectException ret;
 
        for (const auto &objectID_t : print.print_object_ids()) {
            std::set<int> obj_used_extruder_ids;
            auto                     print_object = print.get_object(objectID_t);// current object
            if (print_object){
                auto object_extruders_t = print_object->object_extruders(); // object used extruder
                for (unsigned int extruder : object_extruders_t) {
                    obj_used_extruder_ids.insert(static_cast<int>(extruder));
                }
            }
 
            if (print_object->has_support_material()) { // extruder used by supports
                auto num_extruders                 = (unsigned int) print_config.filament_diameter.size();
                assert(print_object->config().support_filament >= 0);
                if (print_object->config().support_filament >= 1 && (unsigned int)print_object->config().support_filament < num_extruders + 1)
                    obj_used_extruder_ids.insert((unsigned int) print_object->config().support_filament - 1);//0-based extruder id
                assert(print_object->config().support_interface_filament >= 0);
                if (print_object->config().support_interface_filament >= 1 && (unsigned int)print_object->config().support_interface_filament < num_extruders + 1)
                    obj_used_extruder_ids.insert((unsigned int) print_object->config().support_interface_filament - 1);
            }
            std::vector<std::string> filament_types;
            std::vector<int> nozzle_temperatures;
            std::vector<int> nozzle_temperature_range_lows;
            std::vector<int> nozzle_temperature_range_highs;
            filament_types.reserve(obj_used_extruder_ids.size());
            nozzle_temperatures.reserve(obj_used_extruder_ids.size());
            nozzle_temperature_range_lows.reserve(obj_used_extruder_ids.size());
            nozzle_temperature_range_highs.reserve(obj_used_extruder_ids.size());
 
            for (const auto &extruder_idx : obj_used_extruder_ids) {
                filament_types.push_back(print_config.filament_type.get_at(extruder_idx));
                nozzle_temperatures.push_back(print_config.nozzle_temperature.get_at(extruder_idx));
                nozzle_temperature_range_lows.push_back(print_config.nozzle_temperature_range_low.get_at(extruder_idx));
                nozzle_temperature_range_highs.push_back(print_config.nozzle_temperature_range_high.get_at(extruder_idx));
            }
 
            auto compatibility = check_multi_filaments_compatibility(
                filament_types,
                nozzle_temperatures,
                nozzle_temperature_range_lows,
                nozzle_temperature_range_highs); // check for each object
            if (compatibility == FilamentCompatibilityType::InvalidTemperatureRange) {
                ret.string = invalid_temp_range_msg;
                return ret;
            }
            if (compatibility != FilamentCompatibilityType::Compatible) {
                has_incompatible_object = true;
                break;
            }
        }
        if (has_incompatible_object){
            if (enable_mix_printing) {
                ret.string     = incompatible_temp_msg;
                ret.is_warning = true;
            } else
                ret.string = incompatible_temp_msg + " " + incompatible_temp_msg_preferences_enable;
        }
        return ret;
    }
    std::vector<unsigned int> extruders = print.extruders();
    std::vector<std::string> filament_types;
    std::vector<int> nozzle_temperatures;
    std::vector<int> nozzle_temperature_range_lows;
    std::vector<int> nozzle_temperature_range_highs;
    filament_types.reserve(extruders.size());
    nozzle_temperatures.reserve(extruders.size());
    nozzle_temperature_range_lows.reserve(extruders.size());
    nozzle_temperature_range_highs.reserve(extruders.size());
    for (const auto& extruder_idx : extruders) {
        filament_types.push_back(print_config.filament_type.get_at(extruder_idx));
        nozzle_temperatures.push_back(print_config.nozzle_temperature.get_at(extruder_idx));
        nozzle_temperature_range_lows.push_back(print_config.nozzle_temperature_range_low.get_at(extruder_idx));
        nozzle_temperature_range_highs.push_back(print_config.nozzle_temperature_range_high.get_at(extruder_idx));
    }
 
    auto compatibility = check_multi_filaments_compatibility(
        filament_types,
        nozzle_temperatures,
        nozzle_temperature_range_lows,
        nozzle_temperature_range_highs);
    bool enable_mix_printing = !print.need_check_multi_filaments_compatibility();
 
    StringObjectException ret;
 
    if (compatibility == FilamentCompatibilityType::InvalidTemperatureRange) {
        ret.string = invalid_temp_range_msg;
        return ret;
    }
 
    if(compatibility != FilamentCompatibilityType::Compatible){
        if(enable_mix_printing){
            ret.string = incompatible_temp_msg;
            ret.is_warning = true;
        }
        else{
            ret.string = incompatible_temp_msg + " " + incompatible_temp_msg_preferences_enable;
        }
    }
 
    return ret;
}

References Print(), Slic3r::ByObject, check_multi_filaments_compatibility(), Slic3r::Compatible, config(), extruders(), get_object(), Slic3r::InvalidTemperatureRange, Slic3r::StringObjectException::is_warning, L, need_check_multi_filaments_compatibility(), print_object_ids(), and Slic3r::StringObjectException::string.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_multi_filaments_compatibility()

FilamentCompatibilityType Slic3r::Print::check_multi_filaments_compatibility	(	const std::vector< std::string > &	filament_types,
		const std::vector< int > &	nozzle_temperatures,
		const std::vector< int > &	nozzle_temperature_range_lows,
		const std::vector< int > &	nozzle_temperature_range_highs )

static

{
    const size_t filament_count = filament_types.size();
    if (filament_count < 2)
        return FilamentCompatibilityType::Compatible;
 
    std::vector<int> resolved_temperatures(filament_count, 0);
    std::vector<int> resolved_range_lows(filament_count, 0);
    std::vector<int> resolved_range_highs(filament_count, 0);
    for (size_t i = 0; i < filament_count; ++i) {
        int range_low = (i < nozzle_temperature_range_lows.size()) ? nozzle_temperature_range_lows[i] : 0;
        int range_high = (i < nozzle_temperature_range_highs.size()) ? nozzle_temperature_range_highs[i] : 0;
 
        if (range_low == 0 || range_high == 0) {
            int default_low = range_low;
            int default_high = range_high;
            MaterialType::get_temperature_range(filament_types[i], default_low, default_high);
            if (range_low == 0)
                range_low = default_low;
            if (range_high == 0)
                range_high = default_high;
        }
 
        if (range_low >= range_high)
            return FilamentCompatibilityType::InvalidTemperatureRange;
 
        int print_temperature = (i < nozzle_temperatures.size()) ? nozzle_temperatures[i] : 0;
 
        resolved_temperatures[i] = print_temperature;
        resolved_range_lows[i] = range_low;
        resolved_range_highs[i] = range_high;
    }
 
    for (size_t i = 0; i < filament_count; ++i) {
        for (size_t j = i + 1; j < filament_count; ++j) {
            const bool i_temp_is_compatible_with_j =
                resolved_temperatures[i] >= resolved_range_lows[j] &&
                resolved_temperatures[i] <= resolved_range_highs[j];
            const bool j_temp_is_compatible_with_i =
                resolved_temperatures[j] >= resolved_range_lows[i] &&
                resolved_temperatures[j] <= resolved_range_highs[i];
 
            if (i_temp_is_compatible_with_j && j_temp_is_compatible_with_i)
                continue;
 
            // Range-only rule: any pair outside mutual recommended ranges is incompatible.
            return FilamentCompatibilityType::HighLowMixed;
        }
    }
 
    return FilamentCompatibilityType::Compatible;
}

References Slic3r::Compatible, Slic3r::MaterialType::get_temperature_range(), Slic3r::HighLowMixed, and Slic3r::InvalidTemperatureRange.

Referenced by check_multi_filament_valid(), and Slic3r::GUI::CalibrationPresetPage::is_filaments_compatiable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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();
    m_statistics_by_extruder_count.clear();
    m_same_shrinkage_compensations = false;
    m_shrinkage_compensation = Vec3d::Ones();
}

References Slic3r::PrintBaseWithState< PrintStep, psCount >::invalidate_all_steps(), Slic3r::PrintBaseWithState< PrintStep, psCount >::m_model, m_objects, m_print_regions, m_same_shrinkage_compensations, m_shrinkage_compensation, m_statistics_by_extruder_count, PrintObject, and Slic3r::PrintBaseWithState< PrintStep, psCount >::state_mutex().

Referenced by ~Print().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_filament_variant_uses()

bool Slic3r::Print::collect_filament_variant_uses	(	const MultiNozzleUtils::LayeredNozzleGroupResult &	group_result,
		const DynamicPrintConfig &	config,
		std::unordered_map< int, std::vector< FilamentVariantUse > > &	uses ) const

private

{
    auto opt_filament_type = config.option<ConfigOptionStrings>("filament_type");
    auto opt_extruder_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(config.option("extruder_type"));
    if (!opt_filament_type || !opt_extruder_type)
        return false;
 
    const size_t filament_count = opt_filament_type->values.size();
    const size_t extruder_count = opt_extruder_type->values.size();
    auto add_use = [&](std::set<FilamentVariantUse> &variant_set, const MultiNozzleUtils::NozzleInfo &nozzle) {
        // Orca: a persisted result can outlive a printer swap; never index the extruder
        // arrays with a stale nozzle record.
        if (nozzle.extruder_id < 0 || static_cast<size_t>(nozzle.extruder_id) >= extruder_count)
            return;
        FilamentVariantUse use;
        use.extruder_type      = static_cast<ExtruderType>(opt_extruder_type->get_at(nozzle.extruder_id));
        use.nozzle_volume_type = nozzle.volume_type;
        use.extruder_id        = nozzle.extruder_id;
        variant_set.insert(use);
    };
    for (size_t f_index = 0; f_index < filament_count; ++f_index) {
        std::set<FilamentVariantUse> variant_set;
        for (const MultiNozzleUtils::NozzleInfo &nozzle : group_result.get_nozzles_for_filament(static_cast<int>(f_index)))
            add_use(variant_set, nozzle);
        // A filament the plan never routes (not printed) still needs a deterministic slot: take
        // its default-map assignment from the result itself, so both the slice-time write-back
        // and the apply-time reproduction resolve the same slot even when the surrounding
        // filament_map has not round-tripped through the plate config in between.
        if (variant_set.empty()) {
            if (auto default_nozzle = group_result.get_nozzle_for_filament(static_cast<int>(f_index), -1); default_nozzle.has_value())
                add_use(variant_set, *default_nozzle);
        }
        // Filaments still without a variant stay absent from the map: the slot rebuild then
        // resolves them from their static filament_map / filament_volume_map assignment.
        if (!variant_set.empty())
            uses[static_cast<int>(f_index)] = std::vector<FilamentVariantUse>(variant_set.begin(), variant_set.end());
    }
    return true;
}

References collect_filament_variant_uses(), config(), Slic3r::FilamentVariantUse::extruder_id, Slic3r::FilamentVariantUse::extruder_type, Slic3r::ConfigOptionVector< T >::get_at(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzle_for_filament(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzles_for_filament(), Slic3r::FilamentVariantUse::nozzle_volume_type, and Slic3r::ConfigOptionVector< T >::values.

Referenced by collect_filament_variant_uses(), and update_to_config_by_nozzle_group_result().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compacted_wipe_tower_clearance_valid()

StringObjectException Slic3r::Print::compacted_wipe_tower_clearance_valid	(	const Print &	print,
		Polygons *	polygons = nullptr,
		std::vector< std::pair< Polygon, float > > *	height_polygons = nullptr )

static

{
    const PrintConfig &config = print.config();
    if (! wipe_tower_sparse_layers_skipped(config) || config.print_sequence != PrintSequence::ByLayer || ! print.has_wipe_tower())
        return {};
 
    const CompactedTowerZone zone = compacted_wipe_tower_zone(config, estimated_wipe_tower_footprint(print));
    if (zone.empty())
        return {};
 
    StringObjectException exception;
    Polygons              offenders;
    bool                  body_tier_used = false;
    for (const PrintObject *object : print.objects()) {
        const double object_top = unscaled<double>(object->max_z());
        for (const PrintInstance &instance : object->instances()) {
            const Polygon inst_hull = compacted_tower_print_instance_hull(*object, instance);
            if (inst_hull.points.empty())
                continue;
            const CompactedTowerClearance clearance = compacted_wipe_tower_clearance(config, zone, inst_hull, object_top);
            body_tier_used                          = body_tier_used || compacted_tower_body_tier(clearance);
            // Every tier the precise check applies is applied here too, otherwise an object standing
            // within the toolhead radius would pass here and then be rejected mid-slice, which is the
            // one outcome this check exists to prevent. The compacted tower base is unknown before
            // slicing, so the rise is measured from the plate rather than from the tower top; that
            // overstates it by the tower's own height and makes this check err strict, never lax.
            if (object_top <= clearance.allowed_rise + EPSILON)
                continue;
 
            // Height-limit and too-close cases share one user-facing message: both mean the layout
            // violates the "No sparse layers" clearance rule, and the remedies are the same.
            const std::string msg = compacted_wipe_tower_clearance_error();
            if (exception.string.empty()) {
                exception.string = msg;
                exception.object = instance.model_instance;
            } else {
                // Same wording for every offender; keep a single copy and drop the object pointer.
                exception.object = nullptr;
            }
            const Polygon outline = compacted_wipe_tower_offender_outline(inst_hull, clearance.body_clearance);
            offenders.emplace_back(outline);
            if (height_polygons)
                height_polygons->emplace_back(outline, float(clearance.allowed_rise));
        }
    }
 
    // Draw the tower's keep-out ring alongside the offending objects, so the collision area reads as
    // "this object reaches into the space the toolhead needs around the tower" rather than as a lone
    // highlighted object. Emitted only on a real collision; the plater discards polygons otherwise.
    // Only the rings some object on this plate is actually measured against are drawn, so that a ring
    // and an object outline touching always means that object is over its limit.
    if (polygons && ! offenders.empty()) {
        append(*polygons, compacted_wipe_tower_rings(zone, body_tier_used));
        append(*polygons, offenders);
    }
    return exception;
}

References Print(), Slic3r::CompactedTowerClearance::allowed_rise, Slic3r::append(), Slic3r::CompactedTowerClearance::body_clearance, Slic3r::ByLayer, Slic3r::compacted_tower_body_tier(), Slic3r::compacted_tower_print_instance_hull(), Slic3r::compacted_wipe_tower_clearance(), Slic3r::compacted_wipe_tower_clearance_error(), Slic3r::compacted_wipe_tower_offender_outline(), Slic3r::compacted_wipe_tower_rings(), Slic3r::compacted_wipe_tower_zone(), config(), Slic3r::CompactedTowerZone::empty(), EPSILON, Slic3r::estimated_wipe_tower_footprint(), has_wipe_tower(), Slic3r::StringObjectException::object, objects(), Slic3r::MultiPoint::points, PrintObject, Slic3r::StringObjectException::string, Slic3r::unscaled(), and Slic3r::wipe_tower_sparse_layers_skipped().

Referenced by 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

1131{ return m_config; }

References m_config.

Referenced by Slic3r::FillLightning::Generator::Generator(), Slic3r::FillLightning::Generator::Generator(), Slic3r::ToolOrdering::ToolOrdering(), Slic3r::TreeSupport3D::TreeModelVolumes::TreeModelVolumes(), Slic3r::TreeSupport3D::TreeSupportMeshGroupSettings::TreeSupportMeshGroupSettings(), Slic3r::GCode::_do_export(), _make_wipe_tower(), Slic3r::GCode::_print_first_layer_bed_temperature(), Slic3r::GCode::_print_first_layer_extruder_temperatures(), Slic3r::GUI::GLCanvas3D::_render_overlays(), Slic3r::FillAdaptive::adaptive_fill_line_spacing(), Slic3r::SeamPlacer::align_seam_points(), Slic3r::GCode::append_full_config(), append_support_extruders(), append_wipe_tower_extruder(), apply_config_for_render(), Slic3r::ToolOrdering::assign_custom_gcodes(), Slic3r::LayerRegion::bridging_flow(), Slic3r::build_filament_group_context(), check_multi_filament_valid(), collect_filament_variant_uses(), Slic3r::GCode::collect_layers_to_print(), Slic3r::PrintRegion::collect_object_printing_extruders(), Slic3r::combine_object_brims(), compacted_wipe_tower_clearance_valid(), libvgcode::convert_brim_skirt_to_vertices(), Slic3r::GCode::do_export(), Slic3r::TreeSupport::draw_circles(), Slic3r::WipingExtrusions::ensure_perimeters_infills_order(), Slic3r::estimated_wipe_tower_footprint(), export_gcode_from_previous_file(), Slic3r::ToolOrdering::generate_first_layer_tool_order(), Slic3r::GCode::generate_object_skirt_group(), Slic3r::GCode::generate_timelapse_gcode(), Slic3r::get_default_perimeter_spacing(), Slic3r::get_imex_active_tools(), Slic3r::get_path_of_change_filament(), Slic3r::ToolOrdering::get_recommended_filament_maps(), Slic3r::get_wipe_tower_extrusions_extents(), Slic3r::getObjectExtruderMap(), Slic3r::group_fills(), Slic3r::groupingVolumesForBrim(), Slic3r::TimelapsePosPicker::init(), Slic3r::BeltGCode::init_belt_writer(), Slic3r::DoExport::init_ooze_prevention(), Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_slicing_pipeline_hook(), is_all_objects_are_short(), Slic3r::layered_print_cleareance_valid(), Slic3r::GUI::GCodeViewer::load_as_gcode(), Slic3r::make_belt_brim(), Slic3r::make_brim(), Slic3r::LayerRegion::make_perimeters(), Slic3r::Skirt::make_skirt_loops_per_extruder_other_layers(), Slic3r::WipingExtrusions::mark_wiping_extrusions(), Slic3r::GCode::mass_load_limited_machine_acceleration(), Slic3r::multi_material_segmentation_by_painting(), object_skirt_offset(), Slic3r::outer_inner_brim_area(), output_filename(), Slic3r::GCode::print_machine_envelope(), process(), Slic3r::GCode::process_belt_brim_layer(), Slic3r::GCode::process_layer(), Slic3r::GCode::process_layer_change_gcode(), Slic3r::GCode::process_layers(), Slic3r::GCode::process_layers(), Slic3r::CLI::run(), Slic3r::segmentation_top_and_bottom_layers(), sequential_print_clearance_valid(), Slic3r::GCode::set_object_info(), Slic3r::Layer::simplify_support_loop(), Slic3r::Layer::simplify_support_multi_path(), Slic3r::Layer::simplify_support_path(), Slic3r::ToolOrdering::sort_and_build_data(), Slic3r::support_exclusion_areas_for_layers(), Slic3r::support_material_flow(), Slic3r::support_material_interface_flow(), Slic3r::support_transition_flow(), Slic3r::translated_bed_exclusion_volumes(), Slic3r::translated_bed_exclusion_volumes_by_extruder(), Slic3r::tryExPolygonOffset(), Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance(), Slic3r::GUI::GLCanvas3D::update_sequential_clearance(), update_shrinkage_compensation(), validate(), Slic3r::DoExport::validate_custom_gcode(), and Slic3r::BeltGCode::write_belt_header().

◆ config_index_generation()

size_t Slic3r::Print::config_index_generation ( ) const

inline

1391{ return m_config_index_generation; }

Slic3r::Print::m_config_index_generation

size_t m_config_index_generation

Definition Print.hpp:1547

References m_config_index_generation.

◆ copy_id()

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

inlineprotectedinherited

92{ m_id = rhs.id(); }

Slic3r::ObjectBase::m_id

ObjectID m_id

Definition ObjectID.hpp:98

References ObjectBase(), id(), and 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

1132{ return m_default_object_config; }

References m_default_object_config, and Slic3r::PrintObjectConfig.

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

Here is the caller graph for this function:

◆ default_region_config()

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

inline

1133{ return m_default_region_config; }

References m_default_region_config, and Slic3r::PrintRegionConfig.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::emit_belt_brim_bands(), Slic3r::GCode::generate_object_brim(), and Slic3r::get_outer_wall_volumetric_speed().

Here is the caller graph for this function:

◆ empty()

bool Slic3r::Print::empty ( ) const

inlineoverridevirtual

Implements Slic3r::PrintBase.

1077{ return m_objects.empty(); }

References m_objects.

Referenced by _make_skirt(), Slic3r::ToolOrdering::get_recommended_filament_maps(), sequential_print_clearance_valid(), and validate_compacted_wipe_tower_clearance().

Here is the caller graph for this function:

◆ enable_timelapse_print()

bool Slic3r::Print::enable_timelapse_print ( ) const

{
    return m_config.timelapse_type.value == TimelapseType::tlSmooth;
}

References enable_timelapse_print(), m_config, and Slic3r::tlSmooth.

Referenced by _make_wipe_tower(), enable_timelapse_print(), and has_wipe_tower().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ export_cached_data()

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

overridevirtual

Reimplemented from Slic3r::PrintBase.

{
    int ret = 0;
    boost::filesystem::path directory_path(directory);
 
    auto convert_layer_to_json = [](json& layer_json, const Layer* layer) {
        json slice_polygons_json = json::array(), slice_bboxs_json = json::array(), overhang_polygons_json = json::array(), layer_regions_json = json::array();
        layer_json[JSON_LAYER_PRINT_Z] = layer->print_z;
        layer_json[JSON_LAYER_HEIGHT] = layer->height;
        layer_json[JSON_LAYER_SLICE_Z] = layer->slice_z;
        layer_json[JSON_LAYER_ID] = layer->id();
        //layer_json["slicing_errors"] = layer->slicing_errors;
 
        //sliced_polygons
        for (const ExPolygon& slice_polygon : layer->lslices) {
            json slice_polygon_json = slice_polygon;
            slice_polygons_json.push_back(std::move(slice_polygon_json));
        }
        layer_json[JSON_LAYER_SLICED_POLYGONS] = std::move(slice_polygons_json);
 
        //sliced_bbox
        for (const BoundingBox& slice_bbox : layer->lslices_bboxes) {
            json bbox_json = json::array();
 
            bbox_json = slice_bbox;
            slice_bboxs_json.push_back(std::move(bbox_json));
        }
        layer_json[JSON_LAYER_SLLICED_BBOXES] = std::move(slice_bboxs_json);
 
        //overhang_polygons
        for (const ExPolygon& overhang_polygon : layer->loverhangs) {
            json overhang_polygon_json = overhang_polygon;
            overhang_polygons_json.push_back(std::move(overhang_polygon_json));
        }
        layer_json[JSON_LAYER_OVERHANG_POLYGONS] = std::move(overhang_polygons_json);
 
        //overhang_box
        layer_json[JSON_LAYER_OVERHANG_BBOX] = layer->loverhangs_bbox;
 
        for (const LayerRegion *layer_region : layer->regions()) {
            json region_json = *layer_region;
 
            layer_regions_json.push_back(std::move(region_json));
        }
        layer_json[JSON_LAYER_REGIONS] = std::move(layer_regions_json);
 
        return;
    };
 
    //firstly clear this directory
    if (fs::exists(directory_path)) {
        fs::remove_all(directory_path);
    }
    try {
        if (!fs::create_directory(directory_path)) {
            BOOST_LOG_TRIVIAL(error) << boost::format("create directory %1% failed")%directory;
            return CLI_EXPORT_CACHE_DIRECTORY_CREATE_FAILED;
        }
    }
    catch (...)
    {
        BOOST_LOG_TRIVIAL(error) << boost::format("create directory %1% failed")%directory;
        return CLI_EXPORT_CACHE_DIRECTORY_CREATE_FAILED;
    }
 
    int count = 0;
    std::vector<std::string> filename_vector;
    std::vector<json> json_vector;
    for (PrintObject *obj : m_objects) {
        const ModelObject* model_obj = obj->model_object();
        if (obj->get_shared_object()) {
            BOOST_LOG_TRIVIAL(info) << boost::format("shared object %1%, skip directly")%model_obj->name;
            continue;
        }
 
        const PrintInstance &print_instance = obj->instances()[0];
        const ModelInstance *model_instance = print_instance.model_instance;
        size_t identify_id = (model_instance->loaded_id > 0)?model_instance->loaded_id: model_instance->id().id;
        std::string file_name = directory +"/obj_"+std::to_string(identify_id)+".json";
 
        BOOST_LOG_TRIVIAL(info) << boost::format("begin to dump object %1%, identify_id %2% to %3%")%model_obj->name %identify_id %file_name;
 
        try {
            json root_json, layers_json = json::array(), support_layers_json = json::array(), first_layer_groups = json::array();
 
            root_json[JSON_OBJECT_NAME] = model_obj->name;
            root_json[JSON_IDENTIFY_ID] = identify_id;
 
            //export the layers
            std::vector<json> layers_json_vector(obj->layer_count());
            tbb::parallel_for(
                tbb::blocked_range<size_t>(0, obj->layer_count()),
                [&layers_json_vector, obj, convert_layer_to_json](const tbb::blocked_range<size_t>& layer_range) {
                    for (size_t layer_index = layer_range.begin(); layer_index < layer_range.end(); ++ layer_index) {
                        const Layer *layer = obj->get_layer(layer_index);
                        json layer_json;
                        convert_layer_to_json(layer_json, layer);
                        layers_json_vector[layer_index] = std::move(layer_json);
                    }
                }
            );
            for (int l_index = 0; l_index < layers_json_vector.size(); l_index++) {
                layers_json.push_back(std::move(layers_json_vector[l_index]));
            }
            layers_json_vector.clear();
            /*for (const Layer *layer : obj->layers()) {
                // for each layer
                json layer_json;
 
                convert_layer_to_json(layer_json, layer);
 
                layers_json.push_back(std::move(layer_json));
            }*/
 
            root_json[JSON_LAYERS] = std::move(layers_json);
 
            //export the support layers
            std::vector<json> support_layers_json_vector(obj->support_layer_count());
            tbb::parallel_for(
                tbb::blocked_range<size_t>(0, obj->support_layer_count()),
                [&support_layers_json_vector, obj, convert_layer_to_json](const tbb::blocked_range<size_t>& support_layer_range) {
                    for (size_t s_layer_index = support_layer_range.begin(); s_layer_index < support_layer_range.end(); ++ s_layer_index) {
                        const SupportLayer *support_layer = obj->get_support_layer(s_layer_index);
                        json support_layer_json, support_islands_json = json::array(), support_fills_json, supportfills_entities_json = json::array();
 
                        convert_layer_to_json(support_layer_json, support_layer);
 
                        support_layer_json[JSON_SUPPORT_LAYER_INTERFACE_ID] = support_layer->interface_id();
                        support_layer_json[JSON_SUPPORT_LAYER_TYPE] = support_layer->support_type;
 
                        //support_islands
                        for (const ExPolygon& support_island : support_layer->support_islands) {
                            json support_island_json = support_island;
                            support_islands_json.push_back(std::move(support_island_json));
                        }
                        support_layer_json[JSON_SUPPORT_LAYER_ISLANDS] = std::move(support_islands_json);
 
                        //support_fills
                        support_fills_json[JSON_EXTRUSION_NO_SORT] = support_layer->support_fills.no_sort;
                        support_fills_json[JSON_EXTRUSION_ENTITY_TYPE] = JSON_EXTRUSION_TYPE_COLLECTION;
                        for (const ExtrusionEntity* extrusion_entity : support_layer->support_fills.entities) {
                            json supportfill_entity_json, supportfill_entity_paths_json = json::array();
                            bool ret = convert_extrusion_to_json(supportfill_entity_json, supportfill_entity_paths_json, extrusion_entity);
                            if (!ret)
                                continue;
 
                            supportfills_entities_json.push_back(std::move(supportfill_entity_json));
                        }
                        support_fills_json[JSON_EXTRUSION_ENTITIES] = std::move(supportfills_entities_json);
                        support_layer_json[JSON_SUPPORT_LAYER_FILLS] = std::move(support_fills_json);
 
                        support_layers_json_vector[s_layer_index] = std::move(support_layer_json);
                    }
                }
            );
            for (int s_index = 0; s_index < support_layers_json_vector.size(); s_index++) {
                support_layers_json.push_back(std::move(support_layers_json_vector[s_index]));
            }
            support_layers_json_vector.clear();
 
            /*for (const SupportLayer *support_layer : obj->support_layers()) {
                json support_layer_json, support_islands_json = json::array(), support_fills_json, supportfills_entities_json = json::array();
 
                convert_layer_to_json(support_layer_json, support_layer);
 
                support_layer_json[JSON_SUPPORT_LAYER_INTERFACE_ID] = support_layer->interface_id();
 
                //support_islands
                for (const ExPolygon& support_island : support_layer->support_islands.expolygons) {
                    json support_island_json = support_island;
                    support_islands_json.push_back(std::move(support_island_json));
                }
                support_layer_json[JSON_SUPPORT_LAYER_ISLANDS] = std::move(support_islands_json);
 
                //support_fills
                support_fills_json[JSON_EXTRUSION_NO_SORT] = support_layer->support_fills.no_sort;
                support_fills_json[JSON_EXTRUSION_ENTITY_TYPE] = JSON_EXTRUSION_TYPE_COLLECTION;
                for (const ExtrusionEntity* extrusion_entity : support_layer->support_fills.entities) {
                    json supportfill_entity_json, supportfill_entity_paths_json = json::array();
                    bool ret = convert_extrusion_to_json(supportfill_entity_json, supportfill_entity_paths_json, extrusion_entity);
                    if (!ret)
                        continue;
 
                    supportfills_entities_json.push_back(std::move(supportfill_entity_json));
                }
                support_fills_json[JSON_EXTRUSION_ENTITIES] = std::move(supportfills_entities_json);
                support_layer_json[JSON_SUPPORT_LAYER_FILLS] = std::move(support_fills_json);
 
                support_layers_json.push_back(std::move(support_layer_json));
            } // for each layer*/
            root_json[JSON_SUPPORT_LAYERS] = std::move(support_layers_json);
 
            const std::vector<groupedVolumeSlices> &first_layer_obj_groups =  obj->firstLayerObjGroups();
            for (size_t s_group_index = 0; s_group_index < first_layer_obj_groups.size(); ++ s_group_index) {
                groupedVolumeSlices group = first_layer_obj_groups[s_group_index];
 
                //convert the id
                for (ObjectID& obj_id : group.volume_ids)
                {
                    const ModelVolume* currentModelVolumePtr = nullptr;
                    //BBS: support shared object logic
                    const PrintObject* shared_object = obj->get_shared_object();
                    if (!shared_object)
                        shared_object = obj;
                    const ModelVolumePtrs& volumes_ptr = shared_object->model_object()->volumes;
                    size_t volume_count = volumes_ptr.size();
                    for (size_t index = 0; index < volume_count; index ++) {
                        currentModelVolumePtr = volumes_ptr[index];
                        if (currentModelVolumePtr->id() == obj_id) {
                            obj_id.id = index;
                            break;
                        }
                    }
                }
 
                json first_layer_group_json;
 
                first_layer_group_json = group;
                first_layer_groups.push_back(std::move(first_layer_group_json));
            }
            root_json[JSON_FIRSTLAYER_GROUPS] = std::move(first_layer_groups);
 
            filename_vector.push_back(file_name);
            json_vector.push_back(std::move(root_json));
            /*boost::nowide::ofstream c;
            c.open(file_name, std::ios::out | std::ios::trunc);
            if (with_space)
                c << root_json.dump(1, '\t') << std::endl;
            else
                c << root_json.dump(0) << std::endl;
            c.close();*/
            count ++;
            BOOST_LOG_TRIVIAL(info) << boost::format("will dump object %1%'s json to %2%.")%model_obj->name%file_name;
        }
        catch(std::exception &err) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": save to "<<file_name<<" got a generic exception, reason = " << err.what();
            ret = CLI_EXPORT_CACHE_WRITE_FAILED;
        }
    }
 
    boost::mutex mutex;
    tbb::parallel_for(
        tbb::blocked_range<size_t>(0, filename_vector.size()),
        [filename_vector, &json_vector, with_space, &ret, &mutex](const tbb::blocked_range<size_t>& output_range) {
            for (size_t object_index = output_range.begin(); object_index < output_range.end(); ++ object_index) {
                try {
                    boost::nowide::ofstream c;
                    c.open(filename_vector[object_index], std::ios::out | std::ios::trunc);
                    if (with_space)
                        c << json_vector[object_index].dump(1, '\t') << std::endl;
                    else
                        c << json_vector[object_index].dump(0) << std::endl;
                    c.close();
                }
                catch(std::exception &err) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": save to "<<filename_vector[object_index]<<" got a generic exception, reason = " << err.what();
                    boost::unique_lock l(mutex);
                    ret = CLI_EXPORT_CACHE_WRITE_FAILED;
                }
            }
        }
    );
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": total printobject count %1%, saved %2%, ret=%3%")%m_objects.size() %count %ret;
    return ret;
}

References CLI_EXPORT_CACHE_DIRECTORY_CREATE_FAILED, count, export_cached_data(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, JSON_FIRSTLAYER_GROUPS, JSON_IDENTIFY_ID, JSON_LAYER_HEIGHT, JSON_LAYER_ID, JSON_LAYER_OVERHANG_BBOX, JSON_LAYER_OVERHANG_POLYGONS, JSON_LAYER_PRINT_Z, JSON_LAYER_REGIONS, JSON_LAYER_SLICE_Z, JSON_LAYER_SLICED_POLYGONS, JSON_LAYER_SLLICED_BBOXES, JSON_LAYERS, JSON_OBJECT_NAME, JSON_SUPPORT_LAYERS, Slic3r::ModelInstance::loaded_id, m_objects, Slic3r::PrintInstance::model_instance, Slic3r::PrintObjectBase::model_object(), Slic3r::ModelObject::name, PrintObject, Slic3r::groupedVolumeSlices::volume_ids, and Slic3r::ModelObject::volumes.

Referenced by export_cached_data().

Here is the call graph for this function:

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 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 = L("Exporting G-code");
        message += " to ";
        message += path;
    } else
        message = L("Generating G-code");
    this->set_status(80, message);
 
    // The following line may die for multiple reasons.
    // Factory: use BeltGCode for belt printers, plain GCode otherwise.
    std::unique_ptr<GCode> gcode;
    if (m_config.belt_printer.value)
        gcode = std::make_unique<BeltGCode>();
    else
        gcode = std::make_unique<GCode>();
    //BBS: compute plate offset for gcode-generator
    const Vec3d origin = this->get_plate_origin();
    // IMEX firmware-managed zones: writer offset gets the IMEX shift so emitted gcode is
    // centered at bed origin; processor offset stays at plate_origin so the gcode-preview
    // visualizer renders the centered slice at the bed center rather than the prepare-view
    // zone placement. Both arms reduce to set_gcode_offset() semantics when shift is zero.
    // Derived here rather than read as pushed-in state, so an exporter reached without a
    // preceding process() (or after a config change that only invalidated psGCodeExport)
    // still emits in the frame the current config asks for.
    this->update_imex_slice_offset();
    const Vec2d imex_off = this->get_imex_slice_offset();
    gcode->set_gcode_offset_with_imex_shift(origin(0), origin(1), imex_off.x(), imex_off.y());
    gcode->do_export(this, path.c_str(), result, thumbnail_cb);
    gcode->export_layer_filaments(result);
    //BBS
    if (result != nullptr) {
        result->conflict_result = m_conflict_result;
        // Surface the slicer's per-filament nozzle grouping onto the post-slice result
        // the device GUI reads. This is the static L/R + rack subset the multi-nozzle path computes;
        // null for single-nozzle prints where nothing computes it. It is assigned after g-code
        // generation and read by no emitter, so it does not affect the emitted g-code.
        result->nozzle_group_result = this->get_layered_nozzle_group_result();
    }
    return path.c_str();
}

References Slic3r::GCodeProcessorResult::conflict_result, export_gcode(), get_imex_slice_offset(), get_layered_nozzle_group_result(), get_plate_origin(), L, m_config, m_conflict_result, Slic3r::GCodeProcessorResult::nozzle_group_result, Slic3r::PrintBaseWithState< PrintStep, psCount >::output_filepath(), Slic3r::PrintBaseWithState< PrintStep, psCount >::set_status(), and update_imex_slice_offset().

Referenced by export_gcode(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::CLI::run(), and anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ export_gcode_from_previous_file()

void Slic3r::Print::export_gcode_from_previous_file	(	const std::string &	file,
		GCodeProcessorResult *	result,
		ThumbnailsGeneratorCallback	thumbnail_cb = nullptr )

{
    {
        LifecycleEventContext ctx;
        ctx.id = std::to_string(m_model.id().id);
        ctx.name = get_model_name();
        ctx.code = LifecycleEvtCode::Ok;
        ctx.msg  = file;
        ctx.cancellation_check = [this]() { return canceled(); };
        fire_lifecycle_event(LifecycleEvent::GCodeExportStarted, ctx);
    }
 
    try {
        GCodeProcessor processor;
        GCodeProcessor::s_IsBBLPrinter = is_BBL_printer();
        const Vec3d origin = this->get_plate_origin();
        processor.set_xy_offset(origin(0), origin(1));
        // Reloaded sliced projects re-estimate with the same nozzle-grouping slot context as the
        // original export; process_file re-derives the device-side nozzle grouping onto the result
        // (via ensure_nozzle_group_result), so the multi-nozzle send/monitor mapping survives here.
        if (result != nullptr && result->nozzle_group_result)
            processor.initialize_from_context(result->nozzle_group_result);
        processor.configure_exclusion_volume_path_check(this->config());
        //processor.enable_producers(true);
        processor.process_file(file);
 
        // filament seq is loaded from file, processor result will override the value
        auto filament_seq_loaded = result->filament_change_sequence;
        auto nozzle_seq_loaded   = result->nozzle_change_sequence;
        *result = std::move(processor.extract_result());
        result->filament_change_sequence = filament_seq_loaded;
        result->nozzle_change_sequence   = nozzle_seq_loaded;
    } catch (std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ <<  boost::format(": found errors when process gcode file %1%") %file.c_str();
        {
            LifecycleEventContext ctx;
            ctx.id = std::to_string(m_model.id().id);
            ctx.name = get_model_name();
            ctx.code = LifecycleEvtCode::Error;
            ctx.msg  = file + "\n" + ex.what();
            ctx.cancellation_check = [this]() { return canceled(); };
            fire_lifecycle_event(LifecycleEvent::GCodeExportFinished, ctx);
        }
        throw Slic3r::RuntimeError(
            // TRN %1% is a file path.
            Slic3r::format(L("Failed to process the G-code file %1% from the previous 3MF file."), file) + "\n");
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ <<  boost::format(":  process the G-code file %1% successfully")%file.c_str();
 
    {
        LifecycleEventContext ctx;
        ctx.id = std::to_string(m_model.id().id);
        ctx.name = get_model_name();
        ctx.code = LifecycleEvtCode::Ok;
        ctx.msg  = file;
        ctx.cancellation_check = [this]() { return canceled(); };
        fire_lifecycle_event(LifecycleEvent::GCodeExportFinished, ctx);
    }
}

Referenced by export_gcode_from_previous_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extruders()

std::vector< unsigned int > Slic3r::Print::extruders ( bool conside_custom_gcode = false ) const

{
    std::vector<unsigned int> extruders = this->object_extruders();
    append(extruders, this->support_material_extruders());
 
    if (conside_custom_gcode)
        this->append_tool_change_extruders(extruders);
    this->append_wipe_tower_extruder(extruders);
    sort_remove_duplicates(extruders);
    return extruders;
}

References Slic3r::append(), append_tool_change_extruders(), append_wipe_tower_extruder(), extruders(), 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(), append_model_object_extruders(), append_support_extruders(), append_tool_change_extruders(), append_wipe_tower_extruder(), apply(), check_multi_filament_valid(), Slic3r::estimated_wipe_tower_footprint(), extruders(), is_dynamic_group_reorder(), Slic3r::layered_print_cleareance_valid(), Slic3r::GUI::Preview::load_print_as_fff(), max_allowed_layer_height(), object_extruders(), output_filename(), Slic3r::GCode::process_layer(), support_material_extruders(), Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance(), update_shrinkage_compensation(), validate(), and wipe_tower_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finalize()

virtual void Slic3r::PrintBase::finalize ( )

inlinevirtualinherited

Reimplemented in Slic3r::SLAPrint.

441{}

◆ 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(), finalize_first_layer_convex_hull(), first_layer_islands(), m_first_layer_convex_hull, and m_skirt_convex_hull.

Referenced by finalize_first_layer_convex_hull().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finished()

bool Slic3r::Print::finished ( ) const

inlineoverridevirtual

Implements Slic3r::PrintBase.

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

Slic3r::Print::is_step_done

bool is_step_done(PrintStep step) const

Definition Print.hpp:1092

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

1178{ 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()) {
            if (object->support_layers().front()->support_type==stInnerNormal)
                object->support_layers().front()->support_fills.polygons_covered_by_spacing(object_islands, float(SCALED_EPSILON));
            else if(object->support_layers().front()->support_type==stInnerTree) {
                ExPolygons &expolys_first_layer = object->m_support_layers.front()->lslices;
                for (ExPolygon &expoly : expolys_first_layer) { object_islands.push_back(expoly.contour); }
            }
        }
        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 first_layer_islands(), m_objects, PrintObject, SCALED_EPSILON, Slic3r::stInnerNormal, and Slic3r::stInnerTree.

Referenced by finalize_first_layer_convex_hull(), and first_layer_islands().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ first_layer_wipe_tower_corners()

Points Slic3r::Print::first_layer_wipe_tower_corners ( bool check_wipe_tower_existance = true ) const

{
    Points corners;
    if (check_wipe_tower_existance && (!has_wipe_tower() || m_wipe_tower_data.tool_changes.empty()))
        return corners;
    {
        double width = m_wipe_tower_data.bbx.max.x() - m_wipe_tower_data.bbx.min.x();
        double depth = m_wipe_tower_data.bbx.max.y() -m_wipe_tower_data.bbx.min.y();
        Vec2d  pt0   = m_wipe_tower_data.bbx.min + m_wipe_tower_data.rib_offset.cast<double>();
        
        // 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, which only a Type2 tower with a cone wall prints.
        Vec2d center = (pts[0] + pts[2])/2.;
        const bool   has_cone   = wipe_tower_type() == WipeTowerType::Type2 && m_config.wipe_tower_wall_type.value == WipeTowerWallType::wtwCone;
        const double cone_angle = has_cone ? m_config.wipe_tower_cone_angle.value : 0.;
        const auto [cone_R, cone_x_scale] = WipeTower2::get_wipe_tower_cone_base(m_config.prime_tower_width, m_wipe_tower_data.height, m_wipe_tower_data.depth, 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;
            //Orca: offset the wipe tower to the plate origin
            pt += Vec2d(m_config.wipe_tower_x.get_at(m_plate_index) + m_origin(0), m_config.wipe_tower_y.get_at(m_plate_index) + m_origin(1));
            corners.emplace_back(Point(scale_(pt.x()), scale_(pt.y())));
        }
    }
    return corners;
}

References Slic3r::center(), Slic3r::Geometry::deg2rad(), first_layer_wipe_tower_corners(), Slic3r::WipeTower2::get_wipe_tower_cone_base(), has_wipe_tower(), m_config, m_origin, M_PI, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_plate_index, m_wipe_tower_data, scale_, Slic3r::Type2, wipe_tower_type(), and Slic3r::wtwCone.

Referenced by _make_skirt(), first_layer_wipe_tower_corners(), and Slic3r::CLI::run().

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

518{ return m_full_print_config; }

References m_full_print_config.

Referenced by Slic3r::ToolOrdering::ToolOrdering(), Slic3r::GCode::_do_export(), Slic3r::GCode::append_full_config(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf(), Slic3r::anonymous_namespace{SL1.cpp}::fill_slicerconf(), Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_slicing_pipeline_hook(), Slic3r::BackgroundSlicingProcess::prepare_upload(), Slic3r::BackgroundSlicingProcess::process_sla(), Slic3r::SlicingPipelinePluginCapability::RegisterBindings(), and Slic3r::BeltGCode::write_belt_header().

Here is the caller graph for this function:

◆ generate_new_id()

ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

100{ return ObjectID(++ s_last_id); }

Slic3r::ObjectBase::s_last_id

static size_t s_last_id

Definition ObjectID.hpp:101

References s_last_id.

Referenced by ObjectBase(), and set_new_unique_id().

Here is the caller graph for this function:

◆ get_brimMap()

std::map< ObjectID, ExtrusionEntityCollection > & Slic3r::Print::get_brimMap ( )

inline

1146{ return m_brimMap; }

Slic3r::Print::m_brimMap

std::map< ObjectID, ExtrusionEntityCollection > m_brimMap

Definition Print.hpp:1516

References m_brimMap.

◆ get_compatible_filament_type()

int Slic3r::Print::get_compatible_filament_type ( const std::set< int > & types )

static

{
    bool has_high_temperature_filament = false;
    bool has_low_temperature_filament = false;
 
    for (const auto& type : filament_types) {
        if (type == FilamentTempType::HighTemp)
            has_high_temperature_filament = true;
        else if (type == FilamentTempType::LowTemp)
            has_low_temperature_filament = true;
    }
 
    if (has_high_temperature_filament && has_low_temperature_filament)
        return HighLowCompatible;
    else if (has_high_temperature_filament)
        return HighTemp;
    else if (has_low_temperature_filament)
        return LowTemp;
    return HighLowCompatible;
}

References Slic3r::HighLowCompatible, Slic3r::HighTemp, and Slic3r::LowTemp.

Referenced by Slic3r::get_instance_arrange_poly().

Here is the caller graph for this function:

◆ get_config_index() [1/2]

int Slic3r::Print::get_config_index	(	int	filament_id,
		int	layer_id,
		const std::vector< std::string > &	variant_list,
		const std::vector< int > &	self_index_list,
		FilamentIndexMap *	index_map )

protected

{
    const MultiNozzleUtils::LayeredNozzleGroupResult *group_result = m_layered_nozzle_group_result.get();
    // Orca: defensive — when no grouping producer has published a result yet, fall back to the
    // static identity: one filament-variant column per filament.
    if (!group_result)
        return filament_id;
    auto nozzle_info  = group_result->get_nozzle_for_filament(filament_id, layer_id);
    if (!nozzle_info.has_value()) {
        // Orca: this fallback runs per-filament/per-layer in the g-code hot path — log once per filament
        // (reset each slice) instead of flooding thousands of identical lines that bury the real error.
        // Without the cache, the log set is left alone too; the cached caller reports the same filament.
        if (index_map && m_missing_nozzle_group_logged.insert(filament_id).second)
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__
                                     << boost::format(", Line %1%: could not found group_nozzle_info corresponding to filament_id %2%, layer_id %3% (further occurrences for this filament suppressed)") % __LINE__ % filament_id %
                                            layer_id;
        return 0;
    }
 
    ExtruderType     extruder_type      = ExtruderType(m_config.extruder_type.get_at(nozzle_info->extruder_id));
    NozzleVolumeType nozzle_volume_type = nozzle_info->volume_type;
    if (!index_map)
        return get_config_index_base(nozzle_volume_type, extruder_type, filament_id + 1, variant_list, self_index_list);
 
    FilamentIndexKey key{filament_id, extruder_type, nozzle_volume_type};
    auto             iter = index_map->find(key);
    if (iter == index_map->end()) {
        int index = get_config_index_base(nozzle_volume_type, extruder_type, filament_id + 1, variant_list, self_index_list);
        (*index_map)[key] = index;
        return index;
    } else {
        return iter->second;
    }
}

References get_config_index(), Slic3r::get_config_index_base(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzle_for_filament(), m_config, m_layered_nozzle_group_result, m_missing_nozzle_group_logged, and Slic3r::nozzle_volume_type().

Referenced by get_config_index(), get_config_index(), get_filament_config_indx(), and get_nozzle_config_index().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_config_index() [2/2]

int Slic3r::Print::get_config_index	(	int	filament_id,
		int	layer_id,
		const std::vector< std::string > &	variant_list,
		const std::vector< int > &	self_index_list,
		PrintIndexMap &	index_map )

protected

{
    const MultiNozzleUtils::LayeredNozzleGroupResult *group_result = m_layered_nozzle_group_result.get();
    // Orca: same static fallback as the filament overload; the slot degenerates to the filament's
    // extruder column (filament_map is 1 based, get_extruder_id guards the filament id range).
    if (!group_result)
        return (int)get_extruder_id(filament_id);
    auto nozzle_info  = group_result->get_nozzle_for_filament(filament_id, layer_id);
    if (!nozzle_info.has_value()) {
        // Orca: this fallback runs per-filament/per-layer in the g-code hot path — log once per filament
        // (reset each slice) instead of flooding thousands of identical lines that bury the real error.
        if (m_missing_nozzle_group_logged.insert(filament_id).second)
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__
                                     << boost::format(", Line %1%: could not found group_nozzle_info corresponding to filament_id %2%, layer_id %3% (further occurrences for this filament suppressed)") % __LINE__ % filament_id %
                                            layer_id;
        return 0;
    }
 
    int              extruder_id        = nozzle_info->extruder_id + 1; // to 1 based
    ExtruderType     extruder_type      = ExtruderType(m_config.extruder_type.get_at(nozzle_info->extruder_id));
    NozzleVolumeType nozzle_volume_type = nozzle_info->volume_type;
 
    PrintIndexKey key{filament_id, extruder_id, extruder_type, nozzle_volume_type};
    auto          iter = index_map.find(key);
    if (iter == index_map.end()) {
        int index = get_config_index_base(nozzle_volume_type, extruder_type, extruder_id, variant_list, self_index_list);
        index_map[key] = index;
        return index;
    } else {
        return index_map[key];
    }
}

References get_config_index(), Slic3r::get_config_index_base(), get_extruder_id(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzle_for_filament(), m_config, m_layered_nozzle_group_result, m_missing_nozzle_group_logged, and Slic3r::nozzle_volume_type().

Here is the call graph for this function:

◆ get_conflict_result()

ConflictResultOpt Slic3r::Print::get_conflict_result ( ) const

inline

1335{ return m_conflict_result; }

References m_conflict_result.

◆ get_conflict_string()

std::string Slic3r::Print::get_conflict_string ( ) const

inline

    {
        std::string result;
        if (m_conflict_result) {
            result = "Found gcode path conflicts between object " + m_conflict_result.value()._objName1 + " and " + m_conflict_result.value()._objName2;
        }
 
        return result;
    }

References m_conflict_result.

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

Here is the caller graph for this function:

◆ get_extruder_filament_info()

const std::vector< std::vector< DynamicPrintConfig > > & Slic3r::Print::get_extruder_filament_info ( ) const

inline

1237{ return m_extruder_filament_info; }

Slic3r::Print::m_extruder_filament_info

std::vector< std::vector< DynamicPrintConfig > > m_extruder_filament_info

Definition Print.hpp:1531

References m_extruder_filament_info.

Referenced by Slic3r::build_filament_group_context().

Here is the caller graph for this function:

◆ get_extruder_id()

size_t Slic3r::Print::get_extruder_id ( unsigned int filament_id ) const

{
    std::vector<int> filament_map = get_filament_maps();
    if (filament_id < filament_map.size()) {
        return filament_map[filament_id] - 1;
    }
    return 0;
}

References Slic3r::filament_map(), get_extruder_id(), and get_filament_maps().

Referenced by get_config_index(), get_extruder_id(), Slic3r::Layer::is_perimeter_compatible(), and Slic3r::segmentation_top_and_bottom_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_extruder_printable_height()

std::vector< double > Slic3r::Print::get_extruder_printable_height ( ) const

{
    return m_config.extruder_printable_height.values;
}

References get_extruder_printable_height(), and m_config.

Referenced by get_extruder_printable_height().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_extruder_printable_polygons()

std::vector< Polygons > Slic3r::Print::get_extruder_printable_polygons ( ) const

{
    std::vector<Polygons>           extruder_printable_polys;
    std::vector<std::vector<Vec2d>> extruder_printable_areas = m_config.extruder_printable_area.values;
    for (const auto &e_printable_area : extruder_printable_areas) {
        Polygons ploys = {Polygon::new_scale(e_printable_area)};
        extruder_printable_polys.emplace_back(ploys);
    }
    return extruder_printable_polys;
}

References get_extruder_printable_polygons(), m_config, and Slic3r::Polygon::new_scale().

Referenced by get_extruder_printable_polygons(), and Slic3r::outer_inner_brim_area().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_extruder_shared_printable_polygon()

Polygons Slic3r::Print::get_extruder_shared_printable_polygon ( ) const

{
    const std::vector<Vec2ds>& extruder_printable_areas = m_config.extruder_printable_area.values;
    if (m_config.nozzle_diameter.size() < 2 || extruder_printable_areas.empty())
        return {Polygon::new_scale(m_config.printable_area.values)};
    for (const Vec2ds& area : extruder_printable_areas)
        if (area.size() < 3)
            return {Polygon::new_scale(m_config.printable_area.values)};
 
    Polygons shared_printable_polys = {Polygon::new_scale(extruder_printable_areas.front())};
    for (size_t i = 1; i < extruder_printable_areas.size(); ++i)
        shared_printable_polys = intersection(shared_printable_polys, Polygons{Polygon::new_scale(extruder_printable_areas[i])});
    return shared_printable_polys;
}

References Slic3r::area(), get_extruder_shared_printable_polygon(), Slic3r::intersection(), m_config, and Slic3r::Polygon::new_scale().

Referenced by Slic3r::GCode::_do_export(), _make_wipe_tower(), Slic3r::WipeTowerIntegration::append_tcr(), get_extruder_shared_printable_polygon(), Slic3r::layered_print_cleareance_valid(), and Slic3r::WipeTowerIntegration::shared_printable_area().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_extruder_unprintable_polygons()

std::vector< Polygons > Slic3r::Print::get_extruder_unprintable_polygons ( ) const

{
    std::vector<Vec2d>              printable_area           = m_config.printable_area.values;
    Polygon                         printable_poly           = Polygon::new_scale(printable_area);
    std::vector<std::vector<Vec2d>> extruder_printable_areas = m_config.extruder_printable_area.values;
    std::vector<Polygons>           extruder_unprintable_polys;
    for (const auto &e_printable_area : extruder_printable_areas) {
        Polygons ploys = diff(printable_poly, Polygon::new_scale(e_printable_area));
        extruder_unprintable_polys.emplace_back(ploys);
    }
    return extruder_unprintable_polys;
}

References Slic3r::diff(), get_extruder_unprintable_polygons(), m_config, Slic3r::Polygon::new_scale(), and Slic3r::printable_area().

Referenced by get_extruder_unprintable_polygons().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_fake_wipe_tower()

const FakeWipeTower & Slic3r::Print::get_fake_wipe_tower ( ) const

inline

1354{ return m_fake_wipe_tower; }

References m_fake_wipe_tower.

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

Here is the caller graph for this function:

◆ get_filament_config_indx()

int Slic3r::Print::get_filament_config_indx	(	int	filament_id,
		int	layer_id,
		bool	use_cache = true )

{
    return get_config_index(filament_id, layer_id, m_config.filament_extruder_variant.values, m_filament_self_index, use_cache ? &m_filament_index_map : nullptr);
}

References get_config_index(), get_filament_config_indx(), m_config, m_filament_index_map, and m_filament_self_index.

Referenced by get_filament_config_indx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_filament_map_mode()

FilamentMapMode Slic3r::Print::get_filament_map_mode ( ) const

{
    return m_config.filament_map_mode;
}

References get_filament_map_mode(), and m_config.

Referenced by Slic3r::bed_exclusion_physical_extruders(), Slic3r::colliding_bed_exclusion(), get_filament_map_mode(), Slic3r::layered_print_cleareance_valid(), and sequential_print_clearance_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_filament_maps()

std::vector< int > Slic3r::Print::get_filament_maps ( ) const

{
    return m_config.filament_map.values;
}

References get_filament_maps(), and m_config.

Referenced by _make_wipe_tower(), Slic3r::bed_exclusion_physical_extruders(), Slic3r::colliding_bed_exclusion(), get_extruder_id(), get_filament_maps(), Slic3r::GUI::GCodeViewer::load_as_gcode(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_filament_nozzle_maps()

std::vector< int > Slic3r::Print::get_filament_nozzle_maps ( ) const

{
    return m_config.filament_nozzle_map.values;
}

References get_filament_nozzle_maps(), and m_config.

Referenced by get_filament_nozzle_maps(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_filament_temp_type()

FilamentTempType Slic3r::Print::get_filament_temp_type ( const std::string & filament_type )

static

{
    // Range-based classification only: do not use filament_info.json.
    int min_temp, max_temp;
    if (MaterialType::get_temperature_range(filament_type, min_temp, max_temp)) {
        if (max_temp <= 250)
            return FilamentTempType::LowTemp;
        else if (max_temp < 280)
            return FilamentTempType::HighLowCompatible;
        else
            return FilamentTempType::HighTemp;
    }
 
    return Undefine;
}

References Slic3r::filament_type(), get_filament_temp_type(), Slic3r::MaterialType::get_temperature_range(), Slic3r::HighLowCompatible, Slic3r::HighTemp, Slic3r::LowTemp, and Slic3r::Undefine.

Referenced by get_filament_temp_type(), and Slic3r::get_instance_arrange_poly().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_filament_unprintable_flow()

std::map< int, std::set< NozzleVolumeType > > Slic3r::Print::get_filament_unprintable_flow ( const std::vector< unsigned int > & used_filaments ) const

Determines the forbidden nozzle volume types for each used filament.

A filament may declare the extruder variants it supports. Every volume type offered by the printer's extruders that the filament does not support is forbidden for that filament. Hybrid volumes are ignored on both sides, and filaments declaring no variants are unrestricted.

Parameters

used_filaments Totally used filaments when slicing

Returns: A map from used filament index to the set of nozzle volume types it cannot print on

{
    std::map<int, std::set<NozzleVolumeType>> ret;
    std::vector<std::string> extruder_variant_list = m_config.printer_extruder_variant.values;
    // A filament that declares no extruder variants carries no flow restriction.
    const ConfigOptionStrings *filament_variant_opt = m_ori_full_print_config.option<ConfigOptionStrings>("filament_extruder_variant");
    if (filament_variant_opt == nullptr)
        return ret;
    std::vector<std::string> filament_variant_list = filament_variant_opt->values;
    std::vector<int> filament_self_index;
    if (!m_ori_full_print_config.has("filament_self_index"))
        filament_self_index.resize(filament_variant_list.size(), 1);
    else
        filament_self_index = m_ori_full_print_config.option<ConfigOptionInts>("filament_self_index")->values;
    std::unordered_set<int> used_fils_set(used_filaments.begin(), used_filaments.end());
 
    std::unordered_map<int, std::set<NozzleVolumeType>> filament_variant_map;
    for(int i = 0; i < filament_variant_list.size(); ++i){
        NozzleVolumeType volume = convert_to_nvt_type(filament_variant_list[i]);
        if(volume != nvtHybrid) filament_variant_map[filament_self_index[i]].insert(volume);
    }
 
    for (auto iter : filament_variant_map) {
        int fil_idx = iter.first - 1;
        if (used_fils_set.find(fil_idx) == used_fils_set.end()) continue;
        const std::set<NozzleVolumeType> &volumes = iter.second;
        for (int exd_idx = 0; exd_idx < extruder_variant_list.size(); ++exd_idx) {
            auto exd_volume = convert_to_nvt_type(extruder_variant_list[exd_idx]);
            assert(exd_volume != nvtHybrid);
            if (volumes.find(exd_volume) == volumes.end() && exd_volume != nvtHybrid) ret[fil_idx].insert(exd_volume);
        }
    }
    return ret;
}

References Slic3r::convert_to_nvt_type(), get_filament_unprintable_flow(), m_config, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_ori_full_print_config, Slic3r::nvtHybrid, and Slic3r::ConfigOptionVector< T >::values.

Referenced by get_filament_unprintable_flow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_filament_volume_maps()

std::vector< int > Slic3r::Print::get_filament_volume_maps ( ) const

{
    return m_config.filament_volume_map.values;
}

References get_filament_volume_maps(), and m_config.

Referenced by get_filament_volume_maps(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_geometric_unprintable_filaments()

std::vector< std::set< int > > Slic3r::Print::get_geometric_unprintable_filaments ( ) const

inline

1241{ return m_geometric_unprintable_filaments;}

Slic3r::Print::m_geometric_unprintable_filaments

std::vector< std::set< int > > m_geometric_unprintable_filaments

Definition Print.hpp:1581

References m_geometric_unprintable_filaments.

◆ get_hrc_by_nozzle_type()

int Slic3r::Print::get_hrc_by_nozzle_type ( const NozzleType & type )

static

{
    static std::map<std::string, int>nozzle_type_to_hrc;
    if (nozzle_type_to_hrc.empty()) {
        fs::path file_path = fs::path(resources_dir()) / "info" / "nozzle_info.json";
        boost::nowide::ifstream in(file_path.string());
        //std::ifstream in(file_path.string());
        json j;
        try {
            j = json::parse(in);
            in.close();
            for (const auto& elem : j["nozzle_hrc"].items())
                nozzle_type_to_hrc[elem.key()] = elem.value();
        }
        catch (const json::parse_error& err) {
            in.close();
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": parse " << file_path.string() << " got a nlohmann::detail::parse_error, reason = " << err.what();
            nozzle_type_to_hrc = {
                {"hardened_steel",55},
                {"stainless_steel",20},
                {"tungsten_carbide", 85},
                {"brass",2},
                {"undefine",0}
            };
        }
    }
    auto iter = nozzle_type_to_hrc.find(NozzleTypeEumnToStr[type]);
    if (iter != nozzle_type_to_hrc.end())
        return iter->second;
    //0 represents undefine
    return 0;
}

References get_hrc_by_nozzle_type(), Slic3r::NozzleTypeEumnToStr, and Slic3r::resources_dir().

Referenced by get_hrc_by_nozzle_type(), Slic3r::GUI::SelectMachineDialog::is_nozzle_hrc_matched(), Slic3r::GUI::is_same_nozzle_type(), Slic3r::GUI::SyncAmsInfoDialog::is_same_nozzle_type(), Slic3r::GUI::SelectMachineDialog::update_show_status(), and Slic3r::GCodeProcessor::update_slice_warnings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_imex_slice_offset()

Vec2d Slic3r::Print::get_imex_slice_offset ( ) const

inline

1307{ return m_imex_slice_offset; }

Slic3r::Print::m_imex_slice_offset

Vec2d m_imex_slice_offset

Definition Print.hpp:1573

References m_imex_slice_offset.

Referenced by export_gcode().

Here is the caller graph for this function:

◆ get_incompatible_filaments_by_nozzle()

std::vector< std::string > Slic3r::Print::get_incompatible_filaments_by_nozzle	(	const float	nozzle_diameter,
		const std::optional< NozzleVolumeType >	nozzle_volume_type = std::nullopt )

static

{
    static std::map<std::string, std::map<std::string, std::vector<std::string>>> incompatible_filaments;
    if(incompatible_filaments.empty()){
        fs::path file_path = fs::path(resources_dir()) / "info" / "nozzle_incompatibles.json";
        boost::nowide::ifstream in(file_path.string());
        json j;
        try {
            j = json::parse(in);
            for(auto& [volume_type, diameter_list] : j["incompatible_nozzles"].items()) {
                for(auto& [diameter, filaments]: diameter_list.items()){
                    incompatible_filaments[volume_type][diameter] = filaments.get<std::vector<std::string>>();
                }
            }
        }
        catch(const json::parse_error& err){
            in.close();
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": parse " << file_path.string() << " got a nlohmann::detail::parse_error, reason = " << err.what();
 
            incompatible_filaments[get_nozzle_volume_type_string(NozzleVolumeType::nvtHighFlow)] = {};
            incompatible_filaments[get_nozzle_volume_type_string(NozzleVolumeType::nvtStandard)] = {};
        }
    }
    std::ostringstream oss;
    oss << std::fixed << std::setprecision(1) << nozzle_diameter;
    std::string diameter_str = oss.str();
 
    if(nozzle_volume_type.has_value()){
        return incompatible_filaments[get_nozzle_volume_type_string(nozzle_volume_type.value())][diameter_str];
    }
 
    std::vector<std::string> incompatible_filaments_list;
    for(auto& [volume_type, diameter_list] : incompatible_filaments){
        auto iter = diameter_list.find(diameter_str);
        if(iter != diameter_list.end()){
            append(incompatible_filaments_list, iter->second);
        }
    }
    return incompatible_filaments_list;
}

References Slic3r::append(), get_incompatible_filaments_by_nozzle(), Slic3r::get_nozzle_volume_type_string(), Slic3r::nozzle_diameter(), Slic3r::nozzle_volume_type(), Slic3r::nvtHighFlow, Slic3r::nvtStandard, and Slic3r::resources_dir().

Referenced by Slic3r::GUI::PartPlate::check_compatible_of_nozzle_and_filament(), and get_incompatible_filaments_by_nozzle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_layered_nozzle_group_result()

std::shared_ptr< MultiNozzleUtils::LayeredNozzleGroupResult > Slic3r::Print::get_layered_nozzle_group_result ( ) const

inline

1221{ return m_layered_nozzle_group_result; }

References m_layered_nozzle_group_result.

Referenced by Slic3r::GCode::_do_export(), _make_wipe_tower(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::bed_exclusion_physical_extruders(), and export_gcode().

Here is the caller graph for this function:

◆ get_model_name()

std::string Slic3r::Print::get_model_name ( ) const

{
    if (model().model_info != nullptr)
    {
        return model().model_info->model_name;
    } else {
        return "";
    }
}

References get_model_name(), and Slic3r::PrintBaseWithState< PrintStep, psCount >::model().

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::do_export(), export_gcode_from_previous_file(), get_model_name(), output_filename(), and process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_modified_count()

int Slic3r::Print::get_modified_count ( ) const

inline

1318{return m_modified_count;}

References m_modified_count.

Referenced by Slic3r::GUI::GCodeViewer::load_shells().

Here is the caller graph for this function:

◆ get_no_check_flag()

bool Slic3r::PrintBase::get_no_check_flag ( ) const

inlineinherited

528{ return m_no_check; }

Slic3r::PrintBase::m_no_check

bool m_no_check

Definition PrintBase.hpp:568

References m_no_check.

◆ get_nozzle_config_index()

int Slic3r::Print::get_nozzle_config_index	(	int	filament_id,
		int	layer_id )

{
    // Orca: print_extruder_id/print_extruder_variant are PrintRegionConfig members in this codebase;
    // the process-wide expanded values live in the default region config (regions never override them).
    return get_config_index(filament_id, layer_id, m_default_region_config.print_extruder_variant.values, m_default_region_config.print_extruder_id.values, m_nozzle_index_map);
}

References get_config_index(), get_nozzle_config_index(), m_default_region_config, and m_nozzle_index_map.

Referenced by get_nozzle_config_index().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_nozzle_group_result()

std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase > Slic3r::Print::get_nozzle_group_result ( ) const

inline

1220{ return m_nozzle_group_result; }

Slic3r::Print::m_nozzle_group_result

std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase > m_nozzle_group_result

Definition Print.hpp:1534

References m_nozzle_group_result.

Referenced by Slic3r::bed_exclusion_physical_extruders().

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, and PrintObject.

Here is the call graph for this function:

◆ get_object() [2/3]

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

inline

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

References m_objects, and PrintObject.

Referenced by Slic3r::GCode::_do_export(), check_multi_filament_valid(), Slic3r::TreeSupport3D::generate_support_areas(), Slic3r::TreeSupport3D::group_meshes(), Slic3r::make_brim(), Slic3r::GUI::Plater::priv::on_process_completed(), Slic3r::GUI::Plater::priv::on_slicing_update(), Slic3r::outer_inner_brim_area(), and Slic3r::TreeSupport3D::precalculate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_object() [3/3]

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

inline

1136{ return m_objects[idx]; }

References m_objects, and PrintObject.

Here is the call graph for this function:

◆ get_physical_unprintable_filaments()

std::vector< std::set< int > > Slic3r::Print::get_physical_unprintable_filaments ( const std::vector< unsigned int > & used_filaments ) const

Determines the unprintable filaments for each extruder based on its physical attributes.

Currently, the criteria for determining unprintable filament include the following:

TPU filaments can only be placed in the master extruder and must be grouped alone.
We only support at most 1 tpu filament.
An extruder can only accommodate filament with a hardness requirement lower than that of its nozzle.

Parameters

used_filaments Totally used filaments when slicing

Returns: A vector of sets representing unprintable filaments for each extruder.Return an empty vecto if extruder num is 1

{
    int extruder_num = m_config.nozzle_diameter.size();
    std::vector<std::set<int>>physical_unprintables(extruder_num);
    if (extruder_num < 2)
        return physical_unprintables;
 
    auto get_unprintable_extruder_id = [&](unsigned int filament_idx) -> int {
        // filament_printable may be shorter than the filament count; get_at() clamps.
        int status = m_config.filament_printable.get_at(filament_idx);
        for (int i = 0; i < extruder_num; ++i) {
            if (!(status >> i & 1)) {
                return i;
            }
        }
        return -1;
    };
 
 
    std::set<int> tpu_filaments;
    for (auto f : used_filaments) {
        if (m_config.filament_type.get_at(f) == "TPU")
            tpu_filaments.insert(f);
    }
 
    for (auto f : used_filaments) {
        int extruder_id = get_unprintable_extruder_id(f);
        if (extruder_id == -1)
            continue;
        physical_unprintables[extruder_id].insert(f);
    }
 
    return physical_unprintables;
}

References Slic3r::f(), get_physical_unprintable_filaments(), and m_config.

Referenced by get_physical_unprintable_filaments().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_plate_index()

int Slic3r::PrintBase::get_plate_index ( ) const

inlineinherited

526{ return m_plate_index; }

References m_plate_index.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::append_full_config(), Slic3r::estimated_wipe_tower_footprint(), Slic3r::get_wipe_tower_extrusions_extents(), Slic3r::layered_print_cleareance_valid(), and Slic3r::GCode::process_layer().

Here is the caller graph for this function:

◆ get_plate_name()

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

inlineinherited

532{ return m_plate_name; }

Slic3r::PrintBase::m_plate_name

std::string m_plate_name

Definition PrintBase.hpp:571

References m_plate_name.

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

Here is the caller graph for this function:

◆ get_plate_number_formatted()

std::string Slic3r::Print::get_plate_number_formatted ( ) const

{
    std::string plate_number = std::to_string(get_plate_index() + 1);
    static const size_t n_zero = 2;
 
    return std::string(n_zero - std::min(n_zero, plate_number.length()), '0') + plate_number;
}

References Slic3r::PrintBaseWithState< PrintStep, psCount >::get_plate_index(), and get_plate_number_formatted().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_plate_origin()

const Vec3d Slic3r::Print::get_plate_origin ( ) const

inline

1295{ return m_origin; }

References m_origin.

Referenced by Slic3r::GCode::_do_export(), _make_wipe_tower(), Slic3r::GCode::do_export(), Slic3r::estimated_wipe_tower_footprint(), export_gcode(), export_gcode_from_previous_file(), Slic3r::get_wipe_tower_extrusions_extents(), Slic3r::layered_print_cleareance_valid(), Slic3r::make_brim(), reload_gcode_moves(), sequential_print_clearance_valid(), Slic3r::PrintInstance::shift_without_plate_offset(), Slic3r::GCode::timelapse_gcode_config(), Slic3r::translated_bed_exclusion_volumes(), and Slic3r::translated_bed_exclusion_volumes_by_extruder().

Here is the caller graph for this function:

◆ get_print_region()

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

inline

1290{ return *m_print_regions[idx]; }

References m_print_regions.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::extrude_infill(), Slic3r::GCode::extrude_perimeters(), and Slic3r::GCode::process_layer().

Here is the caller graph for this function:

◆ get_rib_offset()

Vec2f Slic3r::Print::get_rib_offset ( ) const

inline

1353{ return m_wipe_tower_data.rib_offset; }

References m_wipe_tower_data.

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

Here is the caller graph for this function:

◆ get_slice_used_filaments()

std::vector< unsigned int > Slic3r::Print::get_slice_used_filaments ( bool first_layer ) const

inline

1247{ return first_layer ? m_slice_used_filaments_first_layer : m_slice_used_filaments;}

Slic3r::Print::m_slice_used_filaments_first_layer

std::vector< unsigned int > m_slice_used_filaments_first_layer

Definition Print.hpp:1565

Slic3r::Print::m_slice_used_filaments

std::vector< unsigned int > m_slice_used_filaments

Definition Print.hpp:1564

References m_slice_used_filaments, and m_slice_used_filaments_first_layer.

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

Here is the caller graph for this function:

◆ get_slice_used_mixed_filaments()

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

inline

1251{ return m_slice_used_mixed_filaments; }

Slic3r::Print::m_slice_used_mixed_filaments

std::vector< unsigned int > m_slice_used_mixed_filaments

Definition Print.hpp:1567

References m_slice_used_mixed_filaments.

◆ get_tool_ordering()

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

inline

1291{ return m_wipe_tower_data.tool_ordering; }

References m_wipe_tower_data.

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

Here is the caller graph for this function:

◆ get_wipe_tower_bbx()

BoundingBoxf Slic3r::Print::get_wipe_tower_bbx ( ) const

inline

1352{ return m_wipe_tower_data.bbx; }

References m_wipe_tower_data.

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

Here is the caller graph for this function:

◆ get_wipe_tower_depth()

float Slic3r::Print::get_wipe_tower_depth ( ) const

inline

1351{ return m_wipe_tower_data.depth; }

References m_wipe_tower_data.

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

Here is the caller graph for this function:

◆ has_auto_brim()

bool Slic3r::Print::has_auto_brim ( ) const

inline

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

References m_objects, and PrintObject.

Here is the call graph for this function:

◆ has_belt_brim()

bool Slic3r::Print::has_belt_brim ( ) const

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

References m_objects, and PrintObject.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_belt_purge_tower()

bool Slic3r::Print::has_belt_purge_tower ( ) const

{
    // Its own purge-tower "type", gated by the belt-only enable_belt_purge_tower
    // option (not the classic enable_prime_tower).
    if (!(m_config.belt_printer.value
          && m_config.enable_belt_purge_tower.value
          && !m_config.spiral_mode.value
          && m_config.filament_diameter.values.size() > 1))
        return false;
 
    return std::any_of(m_objects.begin(), m_objects.end(), [](const PrintObject *object) {
        return object->config().belt_purge_tower_object.value;
    });
}

References m_config, m_objects, and PrintObject.

Referenced by validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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, and PrintObject.

Referenced by Slic3r::PrintRegion::collect_object_printing_extruders(), libvgcode::convert(), libvgcode::convert_brim_skirt_to_vertices(), Slic3r::TreeSupport::draw_circles(), and Slic3r::GCode::process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_infinite_skirt()

bool Slic3r::Print::has_infinite_skirt ( ) const

{
    // Belt printer: no skirt support.
    if (m_config.belt_printer.value)
        return false;
    // Orca: unclear why (m_config.ooze_prevention && this->extruders().size() > 1) logic is here, removed.
    // return (m_config.draft_shield == dsEnabled && m_config.skirt_loops > 0) || (m_config.ooze_prevention && this->extruders().size() > 1);
 
    return (m_config.draft_shield == dsEnabled && m_config.skirt_loops > 0);
}

References Slic3r::dsEnabled, and m_config.

Referenced by _make_skirt(), Slic3r::combine_object_brims(), libvgcode::convert_brim_skirt_to_vertices(), Slic3r::TreeSupport::draw_circles(), Slic3r::Skirt::make_skirt_loops_per_extruder_1st_layer(), Slic3r::Skirt::make_skirt_loops_per_extruder_other_layers(), and Slic3r::GCode::process_layer().

Here is the caller graph for this function:

◆ has_same_shrinkage_compensations()

bool Slic3r::Print::has_same_shrinkage_compensations ( ) const

inline

1396{ return m_same_shrinkage_compensations; }

References m_same_shrinkage_compensations.

Referenced by validate().

Here is the caller graph for this function:

◆ has_shared_per_object_skirt()

bool Slic3r::Print::has_shared_per_object_skirt ( ) const

inline

1172{ return m_has_shared_per_object_skirt; }

References m_has_shared_per_object_skirt.

◆ has_skirt()

bool Slic3r::Print::has_skirt ( ) const

{
    // Belt printer: no skirt support.
    if (m_config.belt_printer.value)
        return false;
    return (m_config.skirt_height > 0);
}

References m_config.

Referenced by _make_skirt(), Slic3r::combine_object_brims(), libvgcode::convert(), Slic3r::Skirt::make_skirt_loops_per_extruder_1st_layer(), and Slic3r::Skirt::make_skirt_loops_per_extruder_other_layers().

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, and PrintObject.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_tilted_belt()

bool Slic3r::Print::has_tilted_belt ( ) const

{
    if (! m_config.belt_printer.value)
        return false;
    // A Z rotation leaves the belt floor flat (BeltTransform forces shear = 0) and no
    // rotation at all means the machine is geometrically a flat bed.
    const BeltRotationAxis axis = m_config.belt_slice_rotation.value;
    if (axis != BeltRotationAxis::X && axis != BeltRotationAxis::Y)
        return false;
    const double tilt = std::abs(m_config.belt_slice_rotation_angle.value);
    return tilt >= BELT_BRIM_MIN_TILT_DEG && tilt <= BELT_BRIM_MAX_TILT_DEG;
}

References Slic3r::BELT_BRIM_MAX_TILT_DEG, Slic3r::BELT_BRIM_MIN_TILT_DEG, m_config, Slic3r::X, and Slic3r::Y.

Referenced by validate().

Here is the caller graph for this function:

◆ has_tpu_filament()

bool Slic3r::Print::has_tpu_filament ( ) const

private

{
    for (unsigned int filament_id : m_wipe_tower_data.tool_ordering.all_extruders()) {
        std::string filament_name = m_config.filament_type.get_at(filament_id);
        if (filament_name == "TPU") {
            return true;
        }
    }
    return false;
}

References m_config, and m_wipe_tower_data.

Referenced by _make_wipe_tower().

Here is the caller graph for this function:

◆ has_wipe_tower()

bool Slic3r::Print::has_wipe_tower ( ) const

{
    // Belt printers never get the classic wipe tower: its G-code is generated
    // directly in machine XY coordinates and bypasses the belt rotation
    // transform. Purging is routed into the belt purge prism instead
    // (see has_belt_purge_tower() / _plan_belt_purge()).
    if (m_config.belt_printer.value)
        return false;
 
    if (m_config.enable_prime_tower.value == true) {
        if (m_config.enable_wrapping_detection.value && m_config.wrapping_exclude_area.values.size() > 2)
            return true;
 
        if (enable_timelapse_print())
            return true;
 
        return !m_config.spiral_mode.value && m_config.filament_diameter.values.size() > 1;
    }
    return false;
}

References enable_timelapse_print(), has_wipe_tower(), and m_config.

Referenced by Slic3r::GCode::_do_export(), append_wipe_tower_extruder(), compacted_wipe_tower_clearance_valid(), first_layer_wipe_tower_corners(), has_wipe_tower(), Slic3r::layered_print_cleareance_valid(), Slic3r::outer_inner_brim_area(), Slic3r::CLI::run(), Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance(), and validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

69{ return m_id; }

References m_id.

◆ invalidate_all_steps()

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

inlineprotectedinherited

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

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

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

Definition PrintBase.hpp:539

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

Referenced by Slic3r::Print::clear(), and Slic3r::Print::invalidate_state_by_config_options().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 = {
        // Belt printer G-code axis remap (only affects G-code output, not slicing).
        "gcode_remap_x",
        "gcode_remap_y",
        "gcode_remap_z",
        // Machine-frame transform (derived from belt tilt; only affects G-code output).
        "belt_frame_tilt_decouple", "belt_frame_tilt_angle",
        // Only inflates the GUI bed volume, like printable_area.
        "belt_printer_infinite_y",
        //BBS
        "additional_cooling_fan_speed",
        "reduce_crossing_wall",
        "max_travel_detour_distance",
        "printable_area",
        "thumbnail_size",
        "before_layer_change_gcode",
        "enable_pressure_advance",
        "pressure_advance",
        "enable_overhang_bridge_fan",
        "overhang_fan_speed",
        "overhang_fan_threshold",
        "slow_down_for_layer_cooling",
        "default_acceleration",
        "deretraction_speed",
        "close_fan_the_first_x_layers",
        "machine_end_gcode",
        "printing_by_object_gcode",
        "filament_end_gcode",
        "post_process",
        // "plugins" is the derived manifest backing the plugin-picker options; on its own it only
        // affects G-code export. The specific option (e.g. slicing_pipeline_plugin) drives any re-slice.
        "plugins",
        "extruder_clearance_height_to_rod",
        "extruder_clearance_height_to_lid",
        "extruder_clearance_radius",
        "nozzle_height",
        "extruder_colour",
        "filament_flow_ratio",
        "reduce_fan_stop_start_freq",
        "dont_slow_down_outer_wall",
        "fan_cooling_layer_time",
        "full_fan_speed_layer",
        "initial_layer_fan_speed",
        "fan_kickstart",
        "part_cooling_fan_min_pwm",
        "fan_speedup_overhangs",
        "fan_speedup_time",
        "filament_colour",
        "default_filament_colour",
        "filament_diameter",
         "volumetric_speed_coefficients",
        "filament_density",
        "filament_cost",
        "filament_notes",
        "outer_wall_acceleration",
        "inner_wall_acceleration",
        "initial_layer_acceleration",
        "top_surface_acceleration",
        "bridge_acceleration",
        "travel_acceleration",
        "sparse_infill_acceleration",
        "internal_solid_infill_acceleration",
        // BBS
        "supertack_plate_temp_initial_layer",
        "cool_plate_temp_initial_layer",
        "textured_cool_plate_temp_initial_layer",
        "eng_plate_temp_initial_layer",
        "hot_plate_temp_initial_layer",
        "textured_plate_temp_initial_layer",
        "gcode_add_line_number",
        "layer_change_gcode",
        "time_lapse_gcode",
        "wrapping_detection_gcode",
        "fan_min_speed",
        "fan_max_speed",
        "printable_height",
        "slow_down_min_speed",
        "max_volumetric_extrusion_rate_slope",
        "max_volumetric_extrusion_rate_slope_segment_length",
        "extrusion_rate_smoothing_external_perimeter_only",
        "reduce_infill_retraction",
        "filename_format",
        "retraction_minimum_travel",
        "retract_before_wipe",
        // Orca:
        "retract_after_wipe",
        "retract_when_changing_layer",
        "retraction_length",
        "retract_length_toolchange",
        "z_hop",
        "travel_slope",
        "retract_lift_above",
        "retract_lift_below", 
        "retract_lift_enforce",
        "retract_restart_extra",
        "retract_restart_extra_toolchange",
        "retraction_speed",
        "use_firmware_retraction",
        "slow_down_layer_time",
        "standby_temperature_delta",
        "preheat_time",
        "preheat_steps",
        "machine_start_gcode",
        "filament_start_gcode",
        "change_filament_gcode",
        "wipe",
        // BBS
        "wipe_distance",
        "curr_bed_type",
        "nozzle_volume",
        "nozzle_hrc",
        "required_nozzle_HRC",
        "upward_compatible_machine",
        "is_infill_first",
        // Orca
        "chamber_temperature",
        "chamber_minimal_temperature",
        "thumbnails",
        "thumbnails_format",
        "center_of_surface_pattern",
        "separated_infills",
        "seam_gap",
        "role_based_wipe_speed",
        "wipe_speed",
        "use_relative_e_distances",
        "accel_to_decel_enable",
        "accel_to_decel_factor",
        "wipe_on_loops",
        "wipe_inward",
        "wipe_inward_distance",
        "gcode_comments",
        "high_precision_gcode",
        "gcode_label_objects", 
        "exclude_object",
        "exclude_object_tolerance",
        "support_material_interface_fan_speed",
        "internal_bridge_fan_speed", // ORCA: Add support for separate internal bridge fan speed control
        "ironing_fan_speed",
        "single_extruder_multi_material_priming",
        "activate_air_filtration",
        "activate_air_filtration_during_print",
        "activate_air_filtration_on_completion",
        "during_print_exhaust_fan_speed",
        "complete_print_exhaust_fan_speed",
        "activate_chamber_temp_control",
        "manual_filament_change",
        "disable_m73",
        "use_firmware_retraction",
        "enable_long_retraction_when_cut",
        "long_retractions_when_cut",
        "retraction_distances_when_cut",
        "filament_long_retractions_when_cut",
        "filament_retraction_distances_when_cut",
        "grab_length",
        "bed_temperature_formula",
        "filament_notes",
        "process_notes",
        "printer_notes",
        "use_3mf"
    };
 
    static std::unordered_set<std::string> steps_ignore;
    static const std::unordered_set<std::string> steps_exclusion_geometry = {
        "bed_exclude_area",
        "bed_exclude_volumes",
        "bed_exclude_volume_mode",
        "extruder_bed_exclude_volumes",
        "extruder_offset"
    };
 
    std::vector<PrintStep> steps;
    std::vector<PrintObjectStep> osteps;
    bool invalidated = false;
 
    for (const t_config_option_key &opt_key : opt_keys) {
        if (steps_exclusion_geometry.find(opt_key) != steps_exclusion_geometry.end()) {
            // Exclusions are consumed while generating brims, support, tree
            // support and wipe-tower geometry, not only during final export.
            steps.emplace_back(psWipeTower);
            steps.emplace_back(psSkirtBrim);
            osteps.emplace_back(posSupportMaterial);
            osteps.emplace_back(posSimplifySupportPath);
        } else 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 == "skirt_type"
            || opt_key == "skirt_loops"
            || opt_key == "skirt_speed"
            || opt_key == "skirt_height"
            || opt_key == "min_skirt_length"
            || opt_key == "single_loop_draft_shield"
            || opt_key == "draft_shield"
            || opt_key == "skirt_distance"
            || opt_key == "skirt_start_angle"
            || opt_key == "ooze_prevention"
            || opt_key == "wipe_tower_x"
            || opt_key == "wipe_tower_y"
            || opt_key == "wipe_tower_rotation_angle") {
            // The tower gcode itself is position-independent (position and rotation are applied
            // at export), except that the wait_for_temp_on_wipe_tower park bakes a bed-relative
            // side choice into it (WipeTower2::toolchange_Change) — regenerate it when the tower
            // moves. Gating on the old config is safe: both inputs of wait_for_temp_enabled
            // invalidate psWipeTower themselves when they are part of the same diff.
            if ((opt_key == "wipe_tower_x" || opt_key == "wipe_tower_y" || opt_key == "wipe_tower_rotation_angle")
                && WipeTower2::wait_for_temp_enabled(m_config))
                steps.emplace_back(psWipeTower);
            steps.emplace_back(psSkirtBrim);
        } else if (
               opt_key == "slicing_pipeline_plugin"
            || opt_key == "print_plugin_config_overrides"
            || opt_key == "initial_layer_print_height"
            || opt_key == "nozzle_diameter"
            || opt_key == "filament_shrink"
            || opt_key == "filament_shrinkage_compensation_z"
            || opt_key == "resolution"
            || opt_key == "precise_z_height"
            // 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_mode"
            // Build plate tilt changes slicing plane orientation.
            || opt_key == "build_plate_tilt_x"
            || opt_key == "build_plate_tilt_y"
            // Belt printer transform options change the mesh geometry before slicing.
            || opt_key == "belt_printer"
            || opt_key == "belt_slice_rotation"
            || opt_key == "belt_slice_rotation_angle") {
            osteps.emplace_back(posSlice);
        } else if (
               opt_key == "belt_support_floor_offset") {
            osteps.emplace_back(posSupportMaterial);
        } else if (
               opt_key == "print_sequence"
            || opt_key == "filament_type"
            || opt_key == "chamber_temperature"
            || opt_key == "nozzle_temperature_initial_layer"
            || opt_key == "filament_minimal_purge_on_wipe_tower"
            || opt_key == "filament_max_volumetric_speed"
            || opt_key == "filament_adaptive_volumetric_speed"
            || 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_stamping_loading_speed"
            || opt_key == "filament_stamping_distance"
            || opt_key == "filament_cooling_initial_speed"
            || opt_key == "filament_cooling_final_speed"
            || opt_key == "filament_ramming_parameters"
            || opt_key == "filament_multitool_ramming"
            || opt_key == "filament_multitool_ramming_volume"
            || opt_key == "filament_multitool_ramming_flow"
            || opt_key == "filament_max_volumetric_speed"
            || opt_key == "gcode_flavor"
            || opt_key == "single_extruder_multi_material"
            || opt_key == "nozzle_temperature"
            // BBS
            || opt_key == "supertack_plate_temp"
            || opt_key == "cool_plate_temp"
            || opt_key == "textured_cool_plate_temp"
            || opt_key == "eng_plate_temp"
            || opt_key == "hot_plate_temp"
            || opt_key == "textured_plate_temp"
            || opt_key == "enable_prime_tower"
            || opt_key == "enable_belt_purge_tower"
            || opt_key == "enable_wrapping_detection"
            || opt_key == "prime_tower_enable_framework"
            || opt_key == "prime_tower_width"
            || opt_key == "prime_tower_brim_width"
            || opt_key == "wipe_tower_type"
            || opt_key == "prime_tower_skip_points"
            || opt_key == "prime_tower_flat_ironing"
            || opt_key == "enable_tower_interface_features"
            || opt_key == "first_layer_print_sequence"
            || opt_key == "other_layers_print_sequence"
            || opt_key == "other_layers_print_sequence_nums" 
            || opt_key == "toolchange_ordering"
            || opt_key == "toolchange_cyclic_order"
            || opt_key == "toolchange_cyclic_first_layer"
            || opt_key == "extruder_ams_count"
            || opt_key == "extruder_nozzle_stats"
            || opt_key == "filament_map_mode"
            || opt_key == "filament_map"
            || opt_key == "filament_nozzle_map"
            || opt_key == "filament_volume_map"
            || opt_key == "filament_adhesiveness_category"
            || opt_key == "filament_tower_interface_pre_extrusion_dist"
            || opt_key == "filament_tower_interface_pre_extrusion_length"
            || opt_key == "filament_tower_ironing_area"
            || opt_key == "filament_tower_interface_purge_volume"
            || opt_key == "filament_tower_interface_print_temp"
            || opt_key == "wipe_tower_bridging"
            || opt_key == "wipe_tower_extra_flow"
            || opt_key == "wipe_tower_no_sparse_layers"
            || opt_key == "wipe_tower_sparse_layers_combination"
            || opt_key == "flush_volumes_matrix"
            || opt_key == "prime_volume"
            || opt_key == "flush_into_infill"
            || opt_key == "flush_into_support"
            || opt_key == "belt_purge_tower_width"
            || opt_key == "initial_layer_infill_speed"
            || opt_key == "travel_speed"
            || opt_key == "travel_speed_z"
            || opt_key == "initial_layer_speed"
            || opt_key == "initial_layer_travel_speed"
            || opt_key == "initial_layer_travel_acceleration"
            || opt_key == "initial_layer_travel_jerk"
            || opt_key == "slow_down_layers"
            || opt_key == "idle_temperature"
            || opt_key == "wipe_tower_cone_angle"
            || opt_key == "wipe_tower_extra_spacing"
            || opt_key == "wipe_tower_max_purge_speed"
            || opt_key == "wipe_tower_wall_type"
            || opt_key == "wipe_tower_extra_rib_length"
            || opt_key == "wipe_tower_rib_width"
            || opt_key == "wipe_tower_fillet_wall"
            || opt_key == "wipe_tower_filament"
            || opt_key == "wiping_volumes_extruders"
            || opt_key == "enable_filament_ramming"
            || opt_key == "tool_change_on_wipe_tower"
            || opt_key == "wait_for_temp_on_wipe_tower"
            || opt_key == "purge_in_prime_tower"
            || opt_key == "z_offset"
            || opt_key == "support_multi_bed_types"
            ) {
            steps.emplace_back(psWipeTower);
            steps.emplace_back(psSkirtBrim);
        } else if (opt_key == "filament_soluble"
                || opt_key == "filament_is_support"
                || opt_key == "filament_printable"
                || opt_key == "filament_change_length"
                || opt_key == "independent_support_layer_height") {
            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);
            osteps.emplace_back(posSimplifySupportPath);
        } else if (
               opt_key == "initial_layer_line_width"
            || opt_key == "min_layer_height"
            || opt_key == "max_layer_height"
            //|| opt_key == "resolution"
            //BBS: when enable arc fitting, we must re-generate perimeter
            || opt_key == "enable_arc_fitting"
            || opt_key == "print_order"
            || opt_key == "wall_sequence") {
            osteps.emplace_back(posPerimeters);
            osteps.emplace_back(posEstimateCurledExtrusions);
            osteps.emplace_back(posInfill);
            osteps.emplace_back(posSupportMaterial);
      osteps.emplace_back(posSimplifyPath);
            osteps.emplace_back(posSimplifyInfill);
            osteps.emplace_back(posSimplifySupportPath);
            steps.emplace_back(psSkirtBrim);
        }
        else if (opt_key == "z_hop_types") {
            osteps.emplace_back(posDetectOverhangsForLift);
        }
        // The bed-zone colour scheme and the advisory margin bands are drawn from the printer
        // config but never reach the slice: compute_imex_zone_layout keeps the margin out of
        // primary_zone_box, which is the only part of the layout update_imex_slice_offset reads.
        // imex_tool_layout does move that box, so it is left to the fallback below.
        else if (opt_key == "imex_viz_theme" || opt_key == "imex_carriage_margin") {
        } 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_config, m_objects, Slic3r::posDetectOverhangsForLift, Slic3r::posEstimateCurledExtrusions, Slic3r::posInfill, Slic3r::posPerimeters, Slic3r::posSimplifyInfill, Slic3r::posSimplifyPath, Slic3r::posSimplifySupportPath, Slic3r::posSlice, Slic3r::posSupportMaterial, PrintObject, Slic3r::psGCodeExport, Slic3r::psSkirtBrim, Slic3r::psWipeTower, Slic3r::sort_remove_duplicates(), and Slic3r::WipeTower2::wait_for_temp_enabled().

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

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

inlineprotectedinherited

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

References m_state.

◆ invalidate_steps() [2/2]

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

inlineprotectedinherited

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

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

Here is the call graph for this function:

◆ is_all_objects_are_short()

bool Slic3r::Print::is_all_objects_are_short ( ) const

inline

                                          {
        return std::all_of(this->objects().begin(), this->objects().end(), [&](PrintObject* obj) { return obj->height() < scale_(this->config().nozzle_height.value); });
    }

References config(), Slic3r::PrintObject::height(), Slic3r::nozzle_height(), objects(), PrintObject, and scale_.

Referenced by object_skirt_offset(), and sequential_print_clearance_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_BBL_printer() [1/2]

bool & Slic3r::Print::is_BBL_printer ( )

inline

1341{ return m_isBBLPrinter; }

Slic3r::Print::m_isBBLPrinter

bool m_isBBLPrinter

Definition Print.hpp:1509

References m_isBBLPrinter.

Referenced by Slic3r::GCode::_do_export(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::bed_exclusion_physical_extruders(), Slic3r::LayerRegion::bridging_flow(), Slic3r::colliding_bed_exclusion(), Slic3r::GCode::do_export(), export_gcode_from_previous_file(), Slic3r::ToolOrdering::get_recommended_filament_maps(), Slic3r::group_fills(), Slic3r::layered_print_cleareance_valid(), Slic3r::GUI::GCodeViewer::load_as_gcode(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GCode::process_layer(), reload_gcode_moves(), sequential_print_clearance_valid(), Slic3r::GCode::set_object_info(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), Slic3r::support_material_1st_layer_flow(), Slic3r::support_material_flow(), Slic3r::support_material_interface_flow(), Slic3r::support_transition_flow(), validate(), Slic3r::DoExport::validate_custom_gcode(), and wipe_tower_type().

Here is the caller graph for this function:

◆ is_BBL_printer() [2/2]

const bool Slic3r::Print::is_BBL_printer ( ) const

inline

1342{ return m_isBBLPrinter; }

References m_isBBLPrinter.

◆ is_dynamic_group_reorder()

bool Slic3r::Print::is_dynamic_group_reorder ( ) const

{
    const auto *opt     = m_full_print_config.option<ConfigOptionBool>("enable_filament_dynamic_map");
    const bool  enabled = opt && opt->value;
    if (!enabled || m_config.filament_map_mode != FilamentMapMode::fmmAutoForFlush || m_config.nozzle_diameter.size() <= 1)
        return false;
 
    // Dynamic regrouping and mixed-color slots are incompatible: a mixed slot is resolved to
    // different physical components per layer, so a group assignment made up-front would be wrong.
    const auto &is_mixed = m_config.filament_is_mixed.values;
    for (unsigned int filament_id : extruders()) {
        if (filament_id < is_mixed.size() && is_mixed[filament_id])
            return false;
    }
    return true;
}

References extruders(), Slic3r::fmmAutoForFlush, is_dynamic_group_reorder(), m_config, and Slic3r::PrintBaseWithState< PrintStep, psCount >::m_full_print_config.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_filaments_compatible()

bool Slic3r::Print::is_filaments_compatible ( const std::vector< int > & types )

static

{
    bool has_high_temperature_filament = false;
    bool has_low_temperature_filament = false;
 
    for (const auto& type : filament_types) {
        if (type == FilamentTempType::HighTemp)
            has_high_temperature_filament = true;
        else if (type == FilamentTempType::LowTemp)
            has_low_temperature_filament = true;
    }
 
    if (has_high_temperature_filament && has_low_temperature_filament)
        return false;
 
    return true;
}

References Slic3r::HighTemp, and Slic3r::LowTemp.

Referenced by Slic3r::arrangement::AutoArranger< TBin >::objfunc().

Here is the caller graph for this function:

◆ 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, PrintObject, and Slic3r::PrintBaseWithState< PrintStep, psCount >::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

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

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

bool is_step_done(PrintStep step) const

Definition PrintBase.hpp:594

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

Referenced by libvgcode::convert(), Slic3r::GCode::do_export(), finished(), Slic3r::layered_print_cleareance_valid(), Slic3r::GUI::Preview::load_print_as_fff(), process(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance(), 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 ( PrintStep step ) const

inlineprotectedinherited

626{ return m_state.is_done_unguarded(step); }

References m_state.

◆ is_step_started_unguarded()

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

inlineprotectedinherited

625{ return m_state.is_started_unguarded(step); }

References m_state.

◆ is_support_used()

bool Slic3r::Print::is_support_used ( ) const

inline

1320{return m_support_used;}

References m_support_used.

◆ layers_sorted_for_object()

std::vector< size_t > Slic3r::Print::layers_sorted_for_object	(	float	start,
		float	end,
		std::vector< LayerPtrs > &	layers_of_objects,
		std::vector< BoundingBox > &	boundingBox_for_objects,
		VecOfPoints &	objects_instances_shift )

{
    std::vector<size_t> idx_of_object_sorted;
    size_t              idx = 0;
    for (const auto &object : m_objects) {
        idx_of_object_sorted.push_back(idx++);
        object->get_certain_layers(start, end, layers_of_objects, boundingBox_for_objects);
    }
    std::sort(idx_of_object_sorted.begin(), idx_of_object_sorted.end(),
              [boundingBox_for_objects](auto left, auto right) { return boundingBox_for_objects[left].area() > boundingBox_for_objects[right].area(); });
 
    objects_instances_shift.clear();
    objects_instances_shift.reserve(m_objects.size());
    for (const auto& object : m_objects)
        objects_instances_shift.emplace_back(object->get_instances_shift_without_plate_offset());
 
    return idx_of_object_sorted;
};

References m_objects.

◆ load_and_construct()

template<class Archive>

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

inlinestaticprivateinherited

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

References id().

Here is the call graph for this function:

◆ load_cached_data()

int Slic3r::Print::load_cached_data ( const std::string & directory )

overridevirtual

Reimplemented from Slic3r::PrintBase.

{
    int ret = 0;
    boost::filesystem::path directory_path(directory);
 
    if (!fs::exists(directory_path)) {
        BOOST_LOG_TRIVIAL(info) << boost::format("directory %1% not exist.")%directory;
        return CLI_IMPORT_CACHE_NOT_FOUND;
    }
 
    auto find_region = [](PrintObject* object, size_t config_hash) -> const PrintRegion* {
        int regions_count = object->num_printing_regions();
        for (int index = 0; index < regions_count; index++ )
        {
            const PrintRegion&  print_region = object->printing_region(index);
            if (print_region.config_hash() == config_hash ) {
                return &print_region;
            }
        }
        return NULL;
    };
 
    int count = 0;
    std::vector<std::pair<std::string, PrintObject*>> object_filenames;
    for (PrintObject *obj : m_objects) {
        const ModelObject* model_obj = obj->model_object();
        const PrintInstance &print_instance = obj->instances()[0];
        const ModelInstance *model_instance = print_instance.model_instance;
 
        obj->clear_layers();
        obj->clear_support_layers();
 
        int identify_id = model_instance->loaded_id;
        if (identify_id <= 0) {
            //for old 3mf
            identify_id = model_instance->id().id;
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": object %1%'s loaded_id is 0, need to use the instance_id %2%")%model_obj->name %identify_id;
            //continue;
        }
        std::string file_name = directory +"/obj_"+std::to_string(identify_id)+".json";
 
        if (!fs::exists(file_name)) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__<<boost::format(": file %1% not exist, maybe a shared object, skip it")%file_name;
            continue;
        }
        object_filenames.push_back({file_name, obj});
    }
 
    boost::mutex mutex;
    std::vector<json> object_jsons(object_filenames.size());
    tbb::parallel_for(
        tbb::blocked_range<size_t>(0, object_filenames.size()),
        [object_filenames, &ret, &object_jsons, &mutex](const tbb::blocked_range<size_t>& filename_range) {
            for (size_t filename_index = filename_range.begin(); filename_index < filename_range.end(); ++ filename_index) {
                try {
                    json root_json;
                    boost::nowide::ifstream ifs(object_filenames[filename_index].first);
                    ifs >> root_json;
                    object_jsons[filename_index] = std::move(root_json);
                }
                catch(std::exception &err) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": load from "<<object_filenames[filename_index].first<<" got a generic exception, reason = " << err.what();
                    boost::unique_lock l(mutex);
                    ret = CLI_IMPORT_CACHE_LOAD_FAILED;
                }
            }
        }
    );
 
    if (ret) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": load json failed.");
        return ret;
    }
 
    for (int obj_index = 0; obj_index < object_jsons.size(); obj_index++) {
        json& root_json = object_jsons[obj_index];
        PrintObject *obj = object_filenames[obj_index].second;
 
        try {
            //boost::nowide::ifstream ifs(file_name);
            //ifs >> root_json;
 
            std::string name = root_json.at(JSON_OBJECT_NAME);
            int identify_id = root_json.at(JSON_IDENTIFY_ID);
            int layer_count = 0, support_layer_count = 0, firstlayer_group_count = 0;
 
            layer_count = root_json[JSON_LAYERS].size();
            support_layer_count = root_json[JSON_SUPPORT_LAYERS].size();
            firstlayer_group_count = root_json[JSON_FIRSTLAYER_GROUPS].size();
 
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__<<boost::format(":will load %1%, identify_id %2%, layer_count %3%, support_layer_count %4%, firstlayer_group_count %5%")
                %name %identify_id %layer_count %support_layer_count %firstlayer_group_count;
 
            Layer* previous_layer = NULL;
            //create layer and layer regions
            for (int index = 0; index < layer_count; index++)
            {
                json& layer_json = root_json[JSON_LAYERS][index];
                Layer* new_layer = obj->add_layer(layer_json[JSON_LAYER_ID], layer_json[JSON_LAYER_HEIGHT], layer_json[JSON_LAYER_PRINT_Z], layer_json[JSON_LAYER_SLICE_Z]);
                if (!new_layer) {
                    BOOST_LOG_TRIVIAL(error) <<__FUNCTION__<< boost::format(":create_layer failed, out of memory");
                    return CLI_OUT_OF_MEMORY;
                }
                if (previous_layer) {
                    previous_layer->upper_layer = new_layer;
                    new_layer->lower_layer = previous_layer;
                }
                previous_layer = new_layer;
 
                //layer regions
                int layer_regions_count = layer_json[JSON_LAYER_REGIONS].size();
                for (int region_index = 0; region_index < layer_regions_count; region_index++)
                {
                    json& region_json = layer_json[JSON_LAYER_REGIONS][region_index];
                    size_t config_hash = region_json[JSON_LAYER_REGION_CONFIG_HASH];
                    const PrintRegion *print_region = find_region(obj, config_hash);
 
                    if (!print_region){
                        BOOST_LOG_TRIVIAL(error) <<__FUNCTION__<< boost::format(":can not find print region of object %1%, layer %2%, print_z %3%, layer_region %4%")
                            %name % index %new_layer->print_z %region_index;
                        //delete new_layer;
                        return CLI_IMPORT_CACHE_DATA_CAN_NOT_USE;
                    }
 
                    new_layer->add_region(print_region);
                }
 
            }
 
            //load the layer data parallel
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__<<boost::format(": load the layers in parallel");
            tbb::parallel_for(
                tbb::blocked_range<size_t>(0, obj->layer_count()),
                [&root_json, &obj](const tbb::blocked_range<size_t>& layer_range) {
                    for (size_t layer_index = layer_range.begin(); layer_index < layer_range.end(); ++ layer_index) {
                        const json& layer_json = root_json[JSON_LAYERS][layer_index];
                        Layer* layer = obj->get_layer(layer_index);
                        extract_layer(layer_json, *layer);
                    }
                }
            );
 
            //support layers
            Layer* previous_support_layer = NULL;
            //create support_layers
            for (int index = 0; index < support_layer_count; index++)
            {
                json& layer_json = root_json[JSON_SUPPORT_LAYERS][index];
                SupportLayer* new_support_layer = obj->add_support_layer(layer_json[JSON_LAYER_ID], layer_json[JSON_SUPPORT_LAYER_INTERFACE_ID], layer_json[JSON_LAYER_HEIGHT], layer_json[JSON_LAYER_PRINT_Z]);
                if (!new_support_layer) {
                    BOOST_LOG_TRIVIAL(error) <<__FUNCTION__<< boost::format(":add_support_layer failed, out of memory");
                    return CLI_OUT_OF_MEMORY;
                }
                if (previous_support_layer) {
                    previous_support_layer->upper_layer = new_support_layer;
                    new_support_layer->lower_layer = previous_support_layer;
                }
                previous_support_layer = new_support_layer;
            }
 
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": finished load layers, start to load support_layers.");
            tbb::parallel_for(
                tbb::blocked_range<size_t>(0, obj->support_layer_count()),
                [&root_json, &obj](const tbb::blocked_range<size_t>& support_layer_range) {
                    for (size_t layer_index = support_layer_range.begin(); layer_index < support_layer_range.end(); ++ layer_index) {
                        const json& layer_json = root_json[JSON_SUPPORT_LAYERS][layer_index];
                        SupportLayer* support_layer = obj->get_support_layer(layer_index);
                        extract_support_layer(layer_json, *support_layer);
                    }
                }
            );
 
            //load first group volumes
            std::vector<groupedVolumeSlices>& firstlayer_objgroups = obj->firstLayerObjGroupsMod();
            for (int index = 0; index < firstlayer_group_count; index++)
            {
                json& firstlayer_group_json = root_json[JSON_FIRSTLAYER_GROUPS][index];
                groupedVolumeSlices firstlayer_group = firstlayer_group_json;
                //convert the id
                for (ObjectID& obj_id : firstlayer_group.volume_ids)
                {
                    ModelVolume* currentModelVolumePtr = nullptr;
                    ModelVolumePtrs& volumes_ptr = obj->model_object()->volumes;
                    size_t volume_count = volumes_ptr.size();
                    if (obj_id.id < volume_count) {
                        currentModelVolumePtr = volumes_ptr[obj_id.id];
                        obj_id = currentModelVolumePtr->id();
                    }
                    else {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": can not find volume_id %1% from object file %2% in firstlayer groups, volume_count %3%!")
                            %obj_id.id %object_filenames[obj_index].first %volume_count;
                        return CLI_IMPORT_CACHE_LOAD_FAILED;
                    }
                }
                firstlayer_objgroups.push_back(std::move(firstlayer_group));
            }
 
            count ++;
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": load object %1% from %2% successfully.")%count%object_filenames[obj_index].first;
        }
        catch(nlohmann::detail::parse_error &err) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<object_filenames[obj_index].first<<" got a nlohmann::detail::parse_error, reason = " << err.what();
            return CLI_IMPORT_CACHE_LOAD_FAILED;
        }
        catch(std::exception &err) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": load from "<<object_filenames[obj_index].first<<" got a generic exception, reason = " << err.what();
            ret = CLI_IMPORT_CACHE_LOAD_FAILED;
        }
    }
 
    object_jsons.clear();
    object_filenames.clear();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": total printobject count %1%, loaded %2%, ret=%3%")%m_objects.size() %count %ret;
    return ret;
}

References CLI_IMPORT_CACHE_NOT_FOUND, Slic3r::PrintRegion::config_hash(), count, Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, load_cached_data(), Slic3r::ModelInstance::loaded_id, m_objects, Slic3r::PrintInstance::model_instance, Slic3r::ModelObject::name, and PrintObject.

Referenced by load_cached_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_try_cancel()

PrintTryCancel Slic3r::PrintBase::make_try_cancel ( ) const

inlineprotectedinherited

554{ return PrintTryCancel(this); }

Slic3r::PrintBase::PrintTryCancel

friend PrintTryCancel

Definition PrintBase.hpp:587

References PrintTryCancel.

◆ 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

420{ return m_model; }

References m_model.

Referenced by Slic3r::ToolOrdering::ToolOrdering(), Slic3r::GUI::Plater::priv::actualize_object_warnings(), apply(), Slic3r::ToolOrdering::assign_custom_gcodes(), Slic3r::GCode::do_export(), Slic3r::Print::sequential_print_clearance_valid(), and Slic3r::sort_object_instances_by_model_order().

Here is the caller graph for this function:

◆ need_check_multi_filaments_compatibility()

bool Slic3r::Print::need_check_multi_filaments_compatibility ( ) const

inline

1357{ return m_need_check_multi_filaments_compatibility; }

Slic3r::Print::m_need_check_multi_filaments_compatibility

bool m_need_check_multi_filaments_compatibility

Definition Print.hpp:1586

References m_need_check_multi_filaments_compatibility.

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

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, and PrintObject.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::generate_timelapse_gcode(), and Slic3r::sort_object_instances_by_model_order().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ num_print_regions()

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

inline

1289{ return m_print_regions.size(); }

References m_print_regions.

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

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);
 
    //Orca: Collect extruders from all regions.
    for (const PrintObject *object : m_objects)
    for (const PrintRegion &region : object->all_regions())
          region.collect_object_printing_extruders(*this, extruders);
 
    for (const PrintObject* object : m_objects)
        append_model_object_extruders(*object->model_object(), extruders);
    sort_remove_duplicates(extruders);
    return extruders;
}

References append_model_object_extruders(), extruders(), m_objects, m_print_regions, PrintObject, 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:

◆ object_skirt_offset()

std::tuple< float, float > Slic3r::Print::object_skirt_offset ( double margin_height = 0 ) const

{
    if (config().skirt_loops == 0 || config().skirt_type != stPerObject || m_objects.empty())
        return std::make_tuple(0, 0);
    
    float max_nozzle_diameter = *std::max_element(m_config.nozzle_diameter.values.begin(), m_config.nozzle_diameter.values.end());
    float max_layer_height    = *std::max_element(config().max_layer_height.values.begin(), config().max_layer_height.values.end());
    float line_width = m_config.initial_layer_line_width.get_abs_value(max_nozzle_diameter);
    float object_skirt_witdh  = skirt_flow().width() + (config().skirt_loops - 1) * skirt_flow().spacing();
    float object_skirt_offset = 0;
 
    if (is_all_objects_are_short())
        object_skirt_offset = config().skirt_distance + object_skirt_witdh;
    else if (config().draft_shield == dsEnabled || config().skirt_height * max_layer_height > config().nozzle_height - margin_height)
        object_skirt_offset = config().skirt_distance + line_width;
    else if (config().skirt_distance + object_skirt_witdh > config().extruder_clearance_radius/2)
        object_skirt_offset = (config().skirt_distance + object_skirt_witdh - config().extruder_clearance_radius/2);
    else
        return std::make_tuple(0, 0);
 
    return std::make_tuple(object_skirt_offset, object_skirt_witdh);
}

References config(), Slic3r::dsEnabled, is_all_objects_are_short(), m_config, m_objects, Slic3r::nozzle_height(), object_skirt_offset(), skirt_flow(), Slic3r::skirt_height(), Slic3r::skirt_type(), and Slic3r::stPerObject.

Referenced by object_skirt_offset(), sequential_print_clearance_valid(), and Slic3r::GUI::GLCanvas3D::update_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ objects()

ConstPrintObjectPtrsAdaptor Slic3r::Print::objects ( ) const

inline

1134{ return ConstPrintObjectPtrsAdaptor(&m_objects); }

References m_objects.

Referenced by Slic3r::ToolOrdering::ToolOrdering(), Slic3r::GCode::_do_export(), Slic3r::GUI::GLCanvas3D::_render_overlays(), apply(), Slic3r::GCode::assign_object_label_ids(), Slic3r::belt_brim_obstacles(), Slic3r::chain_print_object_instances(), Slic3r::chain_print_object_instances_best_of(), Slic3r::chain_print_object_instances_snake(), Slic3r::GCode::collect_layers_to_print(), compacted_wipe_tower_clearance_valid(), libvgcode::convert(), libvgcode::convert_brim_skirt_to_vertices(), Slic3r::TreeSupport::draw_circles(), Slic3r::WipingExtrusions::ensure_perimeters_infills_order(), Slic3r::ToolOrdering::generate_first_layer_tool_order(), Slic3r::generate_tree_support_3D(), Slic3r::get_boundary_external(), Slic3r::get_imex_active_tools(), Slic3r::get_path_of_change_filament(), Slic3r::get_perimeter_spacing_external(), Slic3r::getObjectExtruderMap(), Slic3r::SeamPlacer::init(), Slic3r::GUI::GLGizmoFdmSupports::init_print_instance(), is_all_objects_are_short(), Slic3r::GUI::IMSlider::IsNewPrint(), Slic3r::layered_print_cleareance_valid(), Slic3r::GUI::GCodeViewer::load_as_gcode(), Slic3r::GUI::Preview::load_print_as_fff(), Slic3r::GUI::GCodeViewer::load_shells(), Slic3r::WipingExtrusions::mark_wiping_extrusions(), Slic3r::outer_inner_brim_area(), Slic3r::CLI::run(), sequential_print_clearance_valid(), Slic3r::set_mass_locator(), Slic3r::GCode::set_object_info(), Slic3r::ToolOrdering::sort_and_build_data(), Slic3r::sort_object_instances_by_model_order(), Slic3r::GUI::SelectMachineDialog::start_timelapse_storage_check(), and Slic3r::GUI::Preview::update_layers_slider().

Here is the caller graph for this function:

◆ objects_mutable()

PrintObjectPtrs & Slic3r::Print::objects_mutable ( )

inline

1153{ 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_filaments", new ConfigOptionInt((int)m_config.nozzle_diameter.size()));
    config.set_key_value("num_extruders", new ConfigOptionInt((int) m_config.nozzle_diameter.size()));
    config.set_key_value("plate_name", new ConfigOptionString(get_plate_name()));
    config.set_key_value("plate_number", new ConfigOptionString(get_plate_number_formatted()));
    config.set_key_value("model_name", new ConfigOptionString(get_model_name()));
 
    // the same type of filament contains multiple names, support exporting according to the filament name
    auto full_print_config = this->full_print_config();
    const ConfigOptionStrings* filament_settings_id = full_print_config.option<ConfigOptionStrings>("filament_settings_id");
    std::string filament_name = "";
    auto extruders = this->extruders(true);
    if(!extruders.empty()) {
        // first extruder is the default extruder
        int extruder_id = extruders.front();
        if(filament_settings_id->values.size() > extruder_id) {
            filament_name = filament_settings_id->values[extruder_id];
        }
    }
    size_t end_pos = filament_name.find_first_of("@");
    if (end_pos != std::string::npos) {
        filament_name = filament_name.substr(0, end_pos);
    }
    config.set_key_value("filament_name", new ConfigOptionString(filament_name));
 
    return this->PrintBase::output_filename(m_config.filename_format.value, ".gcode", filename_base, &config);
}

References config(), extruders(), finished(), Slic3r::PrintBaseWithState< PrintStep, psCount >::full_print_config(), get_model_name(), Slic3r::PrintBaseWithState< PrintStep, psCount >::get_plate_name(), get_plate_number_formatted(), m_config, output_filename(), Slic3r::PrintBase::output_filename(), print_statistics(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by output_filename(), and anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export().

Here is the call graph for this function:

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

References Slic3r::ConfigOptionString, Slic3r::format(), L, Slic3r::DynamicConfig::opt_string(), placeholder_parser(), Slic3r::PlaceholderParser::process(), Slic3r::DynamicConfig::set_key_value(), update_object_placeholders(), Slic3r::PlaceholderParser::update_timestamp(), and Slic3r::PlaceholderParser::update_user_name().

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 m_model, and output_filename().

Here is the call graph for this function:

◆ placeholder_parser()

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

inlineinherited

517{ return m_placeholder_parser; }

References m_placeholder_parser.

Referenced by Slic3r::GCode::_do_export(), and 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, and PrintObject.

Referenced by Slic3r::GCode::_do_export(), check_multi_filament_valid(), and Slic3r::make_brim().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_regions_mutable()

PrintRegionPtrs & Slic3r::Print::print_regions_mutable ( )

inline

1154{ return m_print_regions; }

References m_print_regions.

◆ print_statistics() [1/2]

PrintStatistics & Slic3r::Print::print_statistics ( )

inline

1181{ return m_print_statistics; }

Slic3r::Print::m_print_statistics

PrintStatistics m_print_statistics

Definition Print.hpp:1560

References m_print_statistics.

◆ print_statistics() [2/2]

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

inline

1180{ return m_print_statistics; }

References m_print_statistics.

Referenced by Slic3r::GUI::Plater::load_gcode(), output_filename(), and Slic3r::GUI::GCodeViewer::render_all_plates_stats().

Here is the caller graph for this function:

◆ process()

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

overridevirtual

Implements Slic3r::PrintBase.

{
    long long start_time = 0, end_time = 0;
    if (time_cost_with_cache)
        *time_cost_with_cache = 0;
 
    {
        const auto* sp = this->config().option<ConfigOptionStrings>("slicing_pipeline_plugin");
        m_pipeline_plugin_active = s_slicing_pipeline_hook_fn && sp && !sp->values.empty();
    }
 
    name_tbb_thread_pool_threads_set_locale();
 
    // IMEX firmware-managed zones: settle the emission-frame shift from the applied config
    // before anything runs. Zero for every printer that is not IMEX + firmware-managed.
    this->update_imex_slice_offset();
 
    //compute the PrintObject with the same geometries
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": this=%1%, enter, use_cache=%2%, object size=%3%")%this%use_cache%m_objects.size();
    if (m_objects.empty())
        return;
 
    // Belt purge prism: _plan_belt_purge() (psWipeTower) truncates the prism's
    // layers and drops its unclaimed fills, stashing both so a replan can undo
    // them. The object steps below regenerate per-layer content over m_layers
    // ONLY, so if any of them is about to rerun the stashes must go back first;
    // otherwise truncated layers keep stale perimeters/fills and dropped fills
    // are re-inserted next to freshly generated ones. Every object-step
    // invalidation also invalidates psWipeTower, so "psWipeTower not done" is
    // exactly "some object step may rerun" -- and when it IS done nothing below
    // regenerates, and the plan's edits have to stay.
    if (!this->is_step_done(psWipeTower))
        for (PrintObject *obj : m_objects)
            obj->belt_undo_purge_plan();
 
    {
        LifecycleEventContext ctx;
        ctx.id = std::to_string(m_model.id().id);
        ctx.name = get_model_name();
        ctx.code = LifecycleEvtCode::Ok;
        ctx.cancellation_check = [this]() { return canceled(); };
        fire_lifecycle_event(LifecycleEvent::SliceStarted, ctx);
    }
 
    for (PrintObject *obj : m_objects)
        obj->clear_shared_object();
 
    //add the print_object share check logic
    auto is_print_object_the_same = [](const PrintObject* object1, const PrintObject* object2) -> bool{
        if (object1->trafo().matrix() != object2->trafo().matrix())
            return false;
        const ModelObject* model_obj1 = object1->model_object();
        const ModelObject* model_obj2 = object2->model_object();
        if (model_obj1->volumes.size() != model_obj2->volumes.size())
            return false;
        bool has_extruder1 = model_obj1->config.has("extruder");
        bool has_extruder2 = model_obj2->config.has("extruder");
        if ((has_extruder1 != has_extruder2)
            || (has_extruder1 && model_obj1->config.extruder() != model_obj2->config.extruder()))
            return false;
        for (int index = 0; index < model_obj1->volumes.size(); index++) {
            const ModelVolume &model_volume1 = *model_obj1->volumes[index];
            const ModelVolume &model_volume2 = *model_obj2->volumes[index];
            if (model_volume1.type() != model_volume2.type())
                return false;
            if (model_volume1.mesh_ptr() != model_volume2.mesh_ptr())
                return false;
            if (!(model_volume1.get_transformation() == model_volume2.get_transformation()))
                return false;
            has_extruder1 = model_volume1.config.has("extruder");
            has_extruder2 = model_volume2.config.has("extruder");
            if ((has_extruder1 != has_extruder2)
                || (has_extruder1 && model_volume1.config.extruder() != model_volume2.config.extruder()))
                return false;
            if (!model_volume1.supported_facets.equals(model_volume2.supported_facets))
                return false;
            if (!model_volume1.seam_facets.equals(model_volume2.seam_facets))
                return false;
            if (!model_volume1.mmu_segmentation_facets.equals(model_volume2.mmu_segmentation_facets))
                return false;
            if (!model_volume1.fuzzy_skin_facets.equals(model_volume2.fuzzy_skin_facets))
                return false;
            if (model_volume1.config.get() != model_volume2.config.get())
                return false;
        }
        //if (!object1->config().equals(object2->config()))
        //    return false;
        if (model_obj1->layer_height_profile.get() != model_obj2->layer_height_profile.get())
            return false;
        if (model_obj1->config.get() != model_obj2->config.get())
            return false;
        return true;
    };
    int object_count = m_objects.size();
    std::set<PrintObject*> need_slicing_objects;
    std::set<PrintObject*> re_slicing_objects;
    // Belt global modes couple each object's bed position into its layer Z values,
    // so sharing layers between "identical" objects is wrong.
    bool belt_no_share = m_config.belt_printer.value;
    if (!use_cache) {
        for (int index = 0; index < object_count; index++)
        {
            PrintObject *obj =  m_objects[index];
            if (!belt_no_share) {
                for (PrintObject *slicing_obj : need_slicing_objects)
                {
                    if (is_print_object_the_same(obj, slicing_obj)) {
                        obj->set_shared_object(slicing_obj);
                        break;
                    }
                }
            }
            if (!obj->get_shared_object())
                need_slicing_objects.insert(obj);
        }
    }
    else {
        for (int index = 0; index < object_count; index++)
        {
            PrintObject *obj =  m_objects[index];
            if (obj->layer_count() > 0)
                need_slicing_objects.insert(obj);
        }
        for (int index = 0; index < object_count; index++)
        {
            PrintObject *obj =  m_objects[index];
            bool found_shared = false;
            if (need_slicing_objects.find(obj) == need_slicing_objects.end()) {
                if (!belt_no_share) {
                    for (PrintObject *slicing_obj : need_slicing_objects)
                    {
                        if (is_print_object_the_same(obj, slicing_obj)) {
                            obj->set_shared_object(slicing_obj);
                            found_shared = true;
                            break;
                        }
                    }
                }
                if (!found_shared) {
                    BOOST_LOG_TRIVIAL(warning) << boost::format("Also can not find the shared object, identify_id %1%, maybe shared object is skipped")%obj->model_object()->instances[0]->loaded_id;
                    //throw Slic3r::SlicingError("Cannot find the cached data.");
                    //don't report errot, set use_cache to false, and reslice these objects
                    need_slicing_objects.insert(obj);
                    re_slicing_objects.insert(obj);
                    //use_cache = false;
                }
            }
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": total object counts %1% in current print, need to slice %2%")%m_objects.size()%need_slicing_objects.size();
    BOOST_LOG_TRIVIAL(info) << "Starting the slicing process." << log_memory_info();
    if (!use_cache) {
        // Fire the SlicingPipeline hook for `obj` iff it just (re)computed `pstep` this pass.
        auto hook_after = [this](PrintObject* obj, bool was_done, PrintObjectStep pstep, SlicingPipelineStepPlugin sstep) {
            if (m_pipeline_plugin_active && !was_done && obj->is_step_done(pstep))
                run_pipeline_hook(sstep, obj);
        };
 
        // SlicingPipeline: dedicated slice loop so the Slice boundary is hookable before perimeters.
        for (PrintObject *obj : m_objects) {
            if (need_slicing_objects.count(obj) != 0) {
                const bool was_done = obj->is_step_done(posSlice);
                obj->slice();
                hook_after(obj, was_done, posSlice, SlicingPipelineStepPlugin::posSlice);
                // re-snapshot each layer's raw_slices AFTER the Slice hook ran, so the
                // plugin's mutation becomes the untyped baseline. Without this, a later
                // perimeter-only re-run (make_perimeters -> restore_untyped_slices) reverts
                // slices to the PRE-hook geometry while posSlice stays cached (the hook does
                // not re-fire), silently un-applying the mutation; raw_slices consumers
                // (sharp-tail support, ToolOrdering) also read this backup directly. Gated on
                // an active plugin AND a genuine (re)slice, so the inactive path is untouched
                // and re-backing-up an unmutated layer is a harmless identical copy.
                if (m_pipeline_plugin_active && !was_done && obj->is_step_done(posSlice))
                    for (Layer *layer : obj->layers())
                        layer->backup_untyped_slices();
            } else {
                if (obj->set_started(posSlice)) obj->set_done(posSlice);   // shared/duplicate — no hook
            }
        }
        for (PrintObject *obj : m_objects) {
            if (need_slicing_objects.count(obj) != 0) {
                const bool was_done = obj->is_step_done(posPerimeters);
                obj->make_perimeters();   // slice() inside is a no-op: posSlice already DONE
                hook_after(obj, was_done, posPerimeters, SlicingPipelineStepPlugin::posPerimeters);
            } else {
                if (obj->set_started(posPerimeters)) obj->set_done(posPerimeters);
            }
        }
        for (PrintObject *obj : m_objects) {
            if (need_slicing_objects.count(obj) != 0) {
                const bool was_done = obj->is_step_done(posEstimateCurledExtrusions);
                obj->estimate_curled_extrusions();
                hook_after(obj, was_done, posEstimateCurledExtrusions, SlicingPipelineStepPlugin::posEstimateCurledExtrusions);
            }
            else {
                if (obj->set_started(posEstimateCurledExtrusions))
                    obj->set_done(posEstimateCurledExtrusions);
            }
        }
        for (PrintObject *obj : m_objects) {
            if (need_slicing_objects.count(obj) != 0) {
                // split prepare_infill (fill-surface prep) from infill (make_fills) so a
                // plugin can mutate fill surfaces at the PrepareInfill seam and have make_fills
                // consume them (unlike the Infill seam, which fires after the fills are already
                // built). infill() re-invokes prepare_infill() as a no-op once posPrepareInfill
                // is DONE, so this is a mechanical split mirroring the slice/perimeters loop.
                const bool prepare_was_done = obj->is_step_done(posPrepareInfill);
                obj->prepare_infill();
                hook_after(obj, prepare_was_done, posPrepareInfill, SlicingPipelineStepPlugin::posPrepareInfill);
                const bool was_done = obj->is_step_done(posInfill);
                obj->infill();
                hook_after(obj, was_done, posInfill, SlicingPipelineStepPlugin::posInfill);
            }
            else {
                if (obj->set_started(posPrepareInfill))
                    obj->set_done(posPrepareInfill);
                if (obj->set_started(posInfill))
                    obj->set_done(posInfill);
            }
        }
        for (PrintObject *obj : m_objects) {
            if (need_slicing_objects.count(obj) != 0) {
                const bool was_done = obj->is_step_done(posIroning);
                obj->ironing();
                hook_after(obj, was_done, posIroning, SlicingPipelineStepPlugin::posIroning);
            }
            else {
                if (obj->set_started(posIroning))
                    obj->set_done(posIroning);
            }
        }
 
        // Z-Contouring
        for (PrintObject *obj : m_objects) {
            bool need_contouring = need_slicing_objects.count(obj) != 0 && obj->need_z_contouring();
            if (need_contouring) {
                const bool was_done = obj->is_step_done(posContouring);
                obj->contour_z();
                hook_after(obj, was_done, posContouring, SlicingPipelineStepPlugin::posContouring);
            } else {
                if (obj->set_started(posContouring))
                    obj->set_done(posContouring);
            }
        }
 
        // SlicingPipeline: support runs in the parallel block below; the hook must fire in a
        // sequential loop afterward. Snapshot per-object done-state just before the parallel_for.
        std::vector<char> sup_was_done(m_objects.size(), 1);
        if (m_pipeline_plugin_active)
            for (size_t i = 0; i < m_objects.size(); ++i)
                sup_was_done[i] = m_objects[i]->is_step_done(posSupportMaterial) ? 1 : 0;
 
        tbb::parallel_for(tbb::blocked_range<int>(0, int(m_objects.size())),
            [this, need_slicing_objects](const tbb::blocked_range<int>& range) {
                for (int i = range.begin(); i < range.end(); i++) {
                    PrintObject* obj = m_objects[i];
                    if (need_slicing_objects.count(obj) != 0) {
                        // The belt brim follows sequentially below.
                        obj->generate_support_material(false);
                    }
                    else {
                        if (obj->set_started(posSupportMaterial))
                            obj->set_done(posSupportMaterial);
                    }
                }
            }
        );
        // The belt brim keeps clear of every object's layers and support layers,
        // so it runs once no support step is rebuilding them any more.
        for (PrintObject *obj : m_objects)
            obj->generate_belt_brim();
 
        if (m_pipeline_plugin_active)
            for (size_t i = 0; i < m_objects.size(); ++i)
                if (need_slicing_objects.count(m_objects[i]) != 0 && !sup_was_done[i]
                    && m_objects[i]->is_step_done(posSupportMaterial))
                    run_pipeline_hook(SlicingPipelineStepPlugin::posSupportMaterial, m_objects[i]);
 
        for (PrintObject* obj : m_objects) {
            if (need_slicing_objects.count(obj) != 0) {
                const bool was_done = obj->is_step_done(posDetectOverhangsForLift);
                obj->detect_overhangs_for_lift();
                hook_after(obj, was_done, posDetectOverhangsForLift, SlicingPipelineStepPlugin::posDetectOverhangsForLift);
            }
            else {
                if (obj->set_started(posDetectOverhangsForLift))
                    obj->set_done(posDetectOverhangsForLift);
            }
        }
    }
    else {
        for (PrintObject *obj : m_objects) {
            if (re_slicing_objects.count(obj) == 0) {
                if (obj->set_started(posSlice))
                    obj->set_done(posSlice);
                if (obj->set_started(posPerimeters))
                    obj->set_done(posPerimeters);
                if (obj->set_started(posPrepareInfill))
                    obj->set_done(posPrepareInfill);
                if (obj->set_started(posInfill))
                    obj->set_done(posInfill);
                if (obj->set_started(posIroning))
                    obj->set_done(posIroning);
                if (obj->set_started(posContouring))
                    obj->set_done(posContouring);
                if (obj->set_started(posSupportMaterial))
                    obj->set_done(posSupportMaterial);
                if (obj->set_started(posDetectOverhangsForLift))
                    obj->set_done(posDetectOverhangsForLift);
            }
            else {
                obj->make_perimeters();
                obj->infill();
                obj->ironing();
                obj->generate_support_material();
                obj->detect_overhangs_for_lift();
                obj->estimate_curled_extrusions();
            }
        }
    }
 
    for (PrintObject *obj : m_objects)
    {
        if (need_slicing_objects.count(obj) == 0) {
            obj->copy_layers_from_shared_object();
            obj->copy_layers_overhang_from_shared_object();
        }
    }
 
 
 
    if (this->set_started(psWipeTower)) {
        {
            std::vector<std::set<int>> geometric_unprintables(m_config.nozzle_diameter.size());
            for (PrintObject* obj : m_objects) {
                std::vector<std::set<int>> obj_geometric_unprintables = obj->detect_extruder_geometric_unprintables();
                for (size_t idx = 0; idx < obj_geometric_unprintables.size(); ++idx) {
                    if (idx < geometric_unprintables.size()) {
                        geometric_unprintables[idx].insert(obj_geometric_unprintables[idx].begin(), obj_geometric_unprintables[idx].end());
                    }
                }
            }
            this->set_geometric_unprintable_filaments(geometric_unprintables);
        }
 
        m_wipe_tower_data.clear();
        m_tool_ordering.clear();
        if (this->has_belt_purge_tower() && this->config().print_sequence != PrintSequence::ByObject) {
            this->_plan_belt_purge();
        }
        else if (this->has_wipe_tower()) {
            this->_make_wipe_tower();
        }
        else if (this->config().print_sequence != PrintSequence::ByObject) {
            // 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);
            m_tool_ordering.sort_and_build_data(*this, -1, false);
            if (m_tool_ordering.empty() || m_tool_ordering.last_extruder() == unsigned(-1))
                throw Slic3r::SlicingError(L("The print is empty. The model is not printable with current print settings."));
 
        }
        this->set_done(psWipeTower);
        if (m_pipeline_plugin_active) run_pipeline_hook(SlicingPipelineStepPlugin::psWipeTower, nullptr);
    }
 
    if (this->has_wipe_tower()) {
        m_fake_wipe_tower.set_pos({ m_config.wipe_tower_x.get_at(m_plate_index), m_config.wipe_tower_y.get_at(m_plate_index) });
        // Validated on every process() run rather than only when the wipe tower step is (re)generated.
        // Moving the tower changes only wipe_tower_x/y, which invalidates psSkirtBrim but not psWipeTower,
        // so a validate call living inside _make_wipe_tower would be skipped and keep using the stale
        // position, missing a fresh collision. The tower geometry (tool_changes) is stored in the local
        // frame and is position independent, so re-checking here with the current position is correct.
        this->validate_compacted_wipe_tower_clearance();
    }
 
    if (this->set_started(psSkirtBrim)) {
        this->set_status(70, L("Generating skirt & brim"));
 
        if (time_cost_with_cache)
            start_time = (long long)Slic3r::Utils::get_current_time_utc();
 
        m_skirt.clear();
        m_skirt_brim_groups.clear();
        m_has_shared_per_object_skirt = false;
        m_skirt_convex_hull.clear();
        m_objectBrimAreasByInstance.clear();
        m_first_layer_convex_hull.points.clear();
        for (PrintObject *object : m_objects)  object->m_skirt.clear();
 
        //BBS: get the objects' indices when GCodes are generated
        ToolOrdering tool_ordering;
        unsigned int initial_extruder_id = (unsigned int)-1;
        bool         has_wipe_tower = false;
        std::vector<const PrintInstance*>           print_object_instances_ordering;
        std::vector<const PrintInstance*>::const_iterator   print_object_instance_sequential_active;
        std::vector<std::pair<coordf_t, std::vector<GCode::LayerToPrint>>> layers_to_print = GCode::collect_layers_to_print(*this);
        std::vector<unsigned int> printExtruders;
        // Per-object first-layer mixed-slot resolutions for the by-object remap below
        // (BBS reads them from m_sequential_print_data->object_tool_ordering_map).
        std::map<ObjectID, std::map<unsigned int, unsigned int>> seq_mixed_resolution;
        // Cleared on every process so a print-sequence or selector-mode change can never leave
        // stale object pointers behind; repopulated below only by the sequential selector path.
        m_sequential_dynamic_orderings.clear();
        if (this->config().print_sequence == PrintSequence::ByObject) {
            // Order object instances for sequential print.
            print_object_instances_ordering = sort_object_instances_by_model_order(*this);
            // A mixed slot is virtual; only its components reach a nozzle. These per-object orderings
            // are unsorted (no resolve_mixed_filaments), so expand the slots here for the grouping, the
            // unprintable sets and the slice-used lists. Because the expansion happens here rather than
            // on the sorted orderings, the first-layer used set lists every component of a mixed slot,
            // not just the one layer 0 resolves to. No-op without mixed filaments.
            const auto &is_mixed  = m_config.filament_is_mixed.values;
            const auto &comp_strs = m_config.filament_mixed_components.values;
            const bool  has_mixed = has_any_mixed_filament(is_mixed);
            std::vector<unsigned int> first_layer_used_filaments;
            std::vector<std::vector<unsigned int>> all_filaments;
            for (print_object_instance_sequential_active = print_object_instances_ordering.begin(); print_object_instance_sequential_active != print_object_instances_ordering.end(); ++print_object_instance_sequential_active) {
                tool_ordering = ToolOrdering(*(*print_object_instance_sequential_active)->print_object, initial_extruder_id);
                for (size_t idx = 0; idx < tool_ordering.layer_tools().size(); ++idx) {
                    auto layer_filament = tool_ordering.layer_tools()[idx].extruders;
                    if (has_mixed)
                        layer_filament = expand_mixed_filaments(layer_filament, is_mixed, comp_strs);
                    all_filaments.emplace_back(layer_filament);
                    if (idx == 0)
                        first_layer_used_filaments.insert(first_layer_used_filaments.end(), layer_filament.begin(), layer_filament.end());
                }
            }
            sort_remove_duplicates(first_layer_used_filaments);
            auto used_filaments = collect_sorted_used_filaments(all_filaments);
            this->set_slice_used_filaments(first_layer_used_filaments,used_filaments);
 
            auto physical_unprintables = this->get_physical_unprintable_filaments(used_filaments);
            auto geometric_unprintables = this->get_geometric_unprintable_filaments();
            if (has_mixed)
                expand_mixed_slots_in_unprintables(geometric_unprintables, is_mixed, comp_strs);
            auto filament_unprintable_volumes = this->get_filament_unprintable_flow(used_filaments);
            // Selector (per-layer regroup) prints skip the static grouping: their print-wide result
            // is stitched from the per-object plans after the ordering loop below.
            const bool dynamic_reorder = this->is_dynamic_group_reorder();
            if (!dynamic_reorder) {
                std::vector<int>filament_maps = this->get_filament_maps();
                auto map_mode = get_filament_map_mode();
                // Grouping returns a nozzle-aware result; the 1-based extruder map for the by-object
                // path is derived from it. It is computed in every static map mode (in manual modes it
                // mirrors the user's assignment) and published print-wide: GCode's per-nozzle
                // placeholder and config-index lookups read it via get_layered_nozzle_group_result(),
                // and without it sequential exports on multi-nozzle printers see an empty nozzle table
                // (e.g. nozzle_diameter_at_nozzle_id[]) and custom g-code fails to resolve.
                auto grouping_result = ToolOrdering::get_recommended_filament_maps(all_filaments, this, map_mode, physical_unprintables, geometric_unprintables, filament_unprintable_volumes);
                this->set_nozzle_group_result(std::make_shared<MultiNozzleUtils::LayeredNozzleGroupResult>(grouping_result));
                // Orca: the sequential write-back stays gated to auto modes. In manual modes the
                // config maps already carry the user's assignment (the per-object ToolOrdering below
                // consumes them directly), so a write-back would only re-store the pre-slice values;
                // keeping the gate avoids churning the config on every sequential manual slice.
                if (map_mode < FilamentMapMode::fmmManual) {
                    auto derived_maps = grouping_result.get_extruder_map(false);
                    if (!derived_maps.empty()) {
                        filament_maps = derived_maps;
                        // Write the maps back: used filaments adopt the engine's extruder/nozzle
                        // choice, unused ones keep their config assignment.
                        // Orca: the config maps are the merge base; fall back to a synthesized base
                        // when no producer sized them to the filament count (CLI runs until the
                        // per-filament synthesis lands there), where indexing per filament would
                        // run out of bounds.
                        std::vector<int> base_filament_map = m_config.filament_map.values;
                        if (base_filament_map.size() != derived_maps.size())
                            base_filament_map.assign(derived_maps.size(), 1);
                        std::vector<int> base_volume_map = m_config.filament_volume_map.values;
                        if (base_volume_map.size() != derived_maps.size())
                            base_volume_map.assign(derived_maps.size(), (int)nvtStandard);
                        update_filament_maps_to_config(FilamentGroupUtils::update_used_filament_values(base_filament_map, derived_maps, used_filaments),
                                                       FilamentGroupUtils::update_used_filament_values(base_volume_map, grouping_result.get_volume_map(), used_filaments),
                                                       grouping_result.get_nozzle_map());
                    }
                }
                // check map valid both in auto and mannual mode
                std::transform(filament_maps.begin(), filament_maps.end(), filament_maps.begin(), [](int value) {return value - 1; });
            }
 
            //        print_object_instances_ordering = sort_object_instances_by_max_z(print);
            const PrintObject                     *prev_planned_object = nullptr;
            unsigned int                           seq_last_extruder   = (unsigned int)-1;
            MultiNozzleUtils::NozzleStatusRecorder nozzle_status;
            std::vector<std::vector<int>>          nozzle_map_per_layer;
            std::vector<std::vector<unsigned int>> stitched_layer_filaments;
            print_object_instance_sequential_active = print_object_instances_ordering.begin();
            std::vector<unsigned int> used_mixed_filaments;
            for (; print_object_instance_sequential_active != print_object_instances_ordering.end(); ++print_object_instance_sequential_active) {
                const PrintObject *print_object = (*print_object_instance_sequential_active)->print_object;
                if (dynamic_reorder) {
                    if (print_object != prev_planned_object) {
                        // Plan each unique object once, threading the physical nozzle occupancy and
                        // the previous object's last filament into the next plan; repeated instances
                        // of an object reuse the plan, mirroring the export loop's reuse.
                        ToolOrdering ordering(*print_object, seq_last_extruder);
                        ordering.set_nozzle_status(nozzle_status);
                        ordering.sort_and_build_data(*print_object, seq_last_extruder);
                        nozzle_status = ordering.get_nozzle_status();
                        if (ordering.last_extruder() != static_cast<unsigned int>(-1))
                            seq_last_extruder = ordering.last_extruder();
                        const auto &object_maps = ordering.get_layered_nozzle_group_result().get_layer_filament_nozzle_maps();
                        nozzle_map_per_layer.insert(nozzle_map_per_layer.end(), object_maps.begin(), object_maps.end());
                        // Orca: the stitch input comes from the same orderings that produced the
                        // per-layer maps — the collection loop above is per-instance and seeded -1,
                        // so its layers are misaligned with these plans. layer_tools() of a sorted
                        // ordering already carries the planned per-layer filament order.
                        for (const auto &layer_tool : ordering.layer_tools())
                            stitched_layer_filaments.emplace_back(layer_tool.extruders);
                        m_sequential_dynamic_orderings[print_object] = std::move(ordering);
                        prev_planned_object = print_object;
                    }
                    tool_ordering = m_sequential_dynamic_orderings.at(print_object);
                } else {
                    tool_ordering = ToolOrdering(*print_object, initial_extruder_id);
                    tool_ordering.sort_and_build_data(*print_object, initial_extruder_id);
                    if (!tool_ordering.layer_tools().empty())
                        seq_mixed_resolution[print_object->id()] = tool_ordering.layer_tools().front().mixed_filament_resolution;
                }
                // Only sorted orderings have run resolve_mixed_filaments, so only they know which
                // mixed slots actually print.
                append(used_mixed_filaments, tool_ordering.used_mixed_filaments());
                if ((initial_extruder_id = tool_ordering.first_extruder()) != static_cast<unsigned int>(-1)) {
                    append(printExtruders, tool_ordering.tools_for_layer(layers_to_print.front().first).extruders);
                }
            }
            sort_remove_duplicates(used_mixed_filaments);
            this->set_slice_used_mixed_filaments(used_mixed_filaments);
            if (dynamic_reorder && m_objects.size() > 1) {
                // Stitch the per-object plans into one print-wide selector result. A single-object
                // sequential print publishes (and writes back) from its own ordering instead: the
                // per-object publish gate treats one object as not sequential.
                auto stitched = ToolOrdering::build_sequential_group_result(this, std::move(nozzle_map_per_layer), stitched_layer_filaments,
                                                                            stitched_layer_filaments, used_filaments, physical_unprintables,
                                                                            geometric_unprintables, filament_unprintable_volumes);
                this->set_nozzle_group_result(std::make_shared<MultiNozzleUtils::LayeredNozzleGroupResult>(stitched));
                update_to_config_by_nozzle_group_result(stitched);
            }
        }
        else {
            tool_ordering = this->tool_ordering();
            tool_ordering.assign_custom_gcodes(*this);
 
            std::vector<unsigned int> first_layer_used_filaments;
            if (!tool_ordering.layer_tools().empty())
                first_layer_used_filaments = tool_ordering.layer_tools().front().extruders;
 
            this->set_slice_used_filaments(first_layer_used_filaments, tool_ordering.all_extruders());
            this->set_slice_used_mixed_filaments(tool_ordering.used_mixed_filaments());
            has_wipe_tower = this->has_wipe_tower() && tool_ordering.has_wipe_tower();
            initial_extruder_id = tool_ordering.first_extruder();
            print_object_instances_ordering = chain_print_object_instances(*this);
            append(printExtruders, tool_ordering.tools_for_layer(layers_to_print.front().first).extruders);
        }
 
        auto objectExtruderMap = getObjectExtruderMap(*this);
        // Resolve mixed filament virtual slots to physical components so brim
        // extruder matching works correctly (mixed slot IDs are not present
        // in printExtruders after ToolOrdering::resolve_mixed_filaments).
        {
            const LayerTools *first_lt = nullptr;
            if (m_config.print_sequence != PrintSequence::ByObject && !tool_ordering.layer_tools().empty())
                first_lt = &tool_ordering.layer_tools().front();
            for (auto &[obj_id, ext_1based] : objectExtruderMap) {
                if (ext_1based == 0)
                    continue;
                const std::map<unsigned int, unsigned int> *resolution = nullptr;
                if (first_lt)
                    resolution = &first_lt->mixed_filament_resolution;
                else if (auto obj_it = seq_mixed_resolution.find(obj_id); obj_it != seq_mixed_resolution.end())
                    resolution = &obj_it->second;
                if (resolution) {
                    auto it = resolution->find(ext_1based - 1);
                    if (it != resolution->end())
                        ext_1based = it->second + 1;
                }
            }
        }
        std::vector<std::pair<ObjectID, unsigned int>> objPrintVec;
        for (const PrintInstance* instance : print_object_instances_ordering) {
            const ObjectID& print_object_ID = instance->print_object->id();
            bool existObject = false;
            for (auto& objIDPair : objPrintVec) {
                if (print_object_ID == objIDPair.first) existObject = true;
            }
            if (!existObject && objectExtruderMap.find(print_object_ID) != objectExtruderMap.end())
                objPrintVec.push_back(std::make_pair(print_object_ID, objectExtruderMap.at(print_object_ID)));
        }
        // Orca: Build both the old object-keyed brim map and the per-instance
        // maps used by skirt/brim groups.
        m_brimMap.clear();
        m_brimFilamentMap.clear();
        m_brimMapByInstance.clear();
        for (const auto& [object_id, filament] : objPrintVec)
            if (filament > 0)
                m_brimFilamentMap.emplace(object_id, filament - 1);
        m_first_layer_convex_hull.points.clear();
        if (this->has_brim()) {
            Polygons islands_area;
            make_brim(*this, this->make_try_cancel(), islands_area, m_brimMap,
                m_brimMapByInstance, objPrintVec, printExtruders,
                &m_objectBrimAreasByInstance);
            for (Polygon& poly_ex : islands_area)
                poly_ex.douglas_peucker(SCALED_RESOLUTION);
            for (Polygon &poly : union_(this->first_layer_islands(), islands_area))
                append(m_first_layer_convex_hull.points, std::move(poly.points));
        }
 
 
        // Belt brim: bound the first-layer convex hull by the lowest apron band, so
        // bed levelling and the initial purge line account for brim that reaches
        // ahead of every object.
        if (this->has_belt_brim()) {
            for (PrintObject *object : m_objects) {
                if (! object->has_belt_brim() || object->belt_brim_prologue().empty())
                    continue;
                const BeltBrimBand &lowest = object->belt_brim_prologue().front();
                for (const PrintInstance &instance : object->instances())
                    for (const ExPolygon &ex : lowest.areas) {
                        Polygon poly = ex.contour;
                        poly.translate(instance.shift);
                        append(m_first_layer_convex_hull.points, std::move(poly.points));
                    }
            }
        }
 
        // Unchanged for belt printers: _make_skirt() already returns early for them, and
        // the belt brim does not populate m_brimMapByInstance, which is what the
        // skirt/brim grouping reads.
        if (has_skirt() || has_infinite_skirt() || has_brim()) {
            // Generate skirt/brim groups after brim so per-object and draft-shield footprints
            // include brims when grouping and offsetting skirt loops.
            assert(m_skirt.empty());
            _make_skirt();
            if (m_config.print_sequence == PrintSequence::ByObject &&
                m_config.skirt_type == stPerObject &&
                this->has_shared_per_object_skirt()) {
                throw Slic3r::SlicingError(L("Per-object skirts cannot fit between the objects in By object print sequence.\n\nMove the objects farther apart, reduce brim/skirt size, switch Skirt type to Combined, or switch Print sequence to By layer."));
            }
        }
 
        this->finalize_first_layer_convex_hull();
        this->set_done(psSkirtBrim);
        if (m_pipeline_plugin_active) run_pipeline_hook(SlicingPipelineStepPlugin::psSkirtBrim, nullptr);
 
        if (time_cost_with_cache) {
            end_time = (long long)Slic3r::Utils::get_current_time_utc();
            *time_cost_with_cache = *time_cost_with_cache + end_time - start_time;
        }
    }
    //BBS
    for (PrintObject *obj : m_objects) {
        if (((!use_cache)&&(need_slicing_objects.count(obj) != 0))
            || (use_cache &&(re_slicing_objects.count(obj) != 0))){
            const bool was_done = obj->is_step_done(posSimplifyPath);
            obj->simplify_extrusion_path();
            // Unlike every other seam (all inside the `if (!use_cache)` block above), this loop is
            // shared with the use_cache path (re_slicing_objects), so `!use_cache` must be checked
            // explicitly here to keep hooks from ever firing on cache-loaded (plugin-final) objects.
            if (!use_cache && m_pipeline_plugin_active && !was_done && obj->is_step_done(posSimplifyPath))
                run_pipeline_hook(SlicingPipelineStepPlugin::posSimplifyPath, obj);
        }
        else {
            if (obj->set_started(posSimplifyPath))
                obj->set_done(posSimplifyPath);
            if (obj->set_started(posSimplifyInfill))
                obj->set_done(posSimplifyInfill);
            if (obj->set_started(posSimplifySupportPath))
                obj->set_done(posSimplifySupportPath);
        }
    }
 
    // BBS
    bool has_adaptive_layer_height = false;
    for (PrintObject* obj : m_objects) {
        if (obj->model_object()->layer_height_profile.empty() == false) {
            has_adaptive_layer_height = true;
            break;
        }
    }
    if(!m_no_check /*&& !has_adaptive_layer_height*/)
    {
        using Clock                 = std::chrono::high_resolution_clock;
        auto            startTime   = Clock::now();
        std::optional<const FakeWipeTower *> wipe_tower_opt = {};
        if (this->has_wipe_tower()) {
            m_fake_wipe_tower.set_pos({m_config.wipe_tower_x.get_at(m_plate_index), m_config.wipe_tower_y.get_at(m_plate_index)});
            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);
        auto            endTime     = Clock::now();
        volatile double seconds     = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count() / (double) 1000;
        BOOST_LOG_TRIVIAL(info) << "gcode path conflicts check takes " << seconds << " secs.";
 
        m_conflict_result = conflictRes;
        if (conflictRes.has_value()) {
            BOOST_LOG_TRIVIAL(error) << boost::format("gcode path conflicts found between %1% and %2%")%conflictRes.value()._objName1 %conflictRes.value()._objName2;
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << "Slicing process finished." << log_memory_info();
 
    {
        LifecycleEventContext ctx;
        ctx.id = std::to_string(m_model.id().id);
        ctx.name = get_model_name();
        ctx.code = LifecycleEvtCode::Ok;
        ctx.cancellation_check = [this]() { return canceled(); };
        fire_lifecycle_event(LifecycleEvent::SliceGeometryFinished, ctx);
    }
}

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf(), and anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reload_gcode_moves()

void Slic3r::Print::reload_gcode_moves ( GCodeProcessorResult * result ) const

{
    GCodeProcessor processor;
    GCodeProcessor::s_IsBBLPrinter = is_BBL_printer();
    const Vec3d origin = this->get_plate_origin();
    processor.set_xy_offset(origin(0), origin(1));
    // Estimate the per-move times with the same nozzle-grouping slot context as the export.
    if (result->nozzle_group_result)
        processor.initialize_from_context(result->nozzle_group_result);
    try {
        processor.process_file(result->filename);
    } catch (const std::exception& ex) {
        // The edited file is what gets printed, so failing to preview it must not fail the slice.
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": cannot re-read the G-code file " << result->filename << ": " << ex.what();
        std::lock_guard<std::mutex> lock(result->result_mutex);
        result->lines_ends.clear();
        return;
    }
 
    GCodeProcessorResult& reloaded = processor.result();
    std::lock_guard<std::mutex> lock(result->result_mutex);
    result->moves      = std::move(reloaded.moves);
    result->lines_ends = std::move(reloaded.lines_ends);
}

References Slic3r::GCodeProcessorResult::filename, get_plate_origin(), Slic3r::GCodeProcessor::initialize_from_context(), is_BBL_printer(), Slic3r::GCodeProcessorResult::lines_ends, Slic3r::GCodeProcessorResult::moves, Slic3r::GCodeProcessorResult::nozzle_group_result, Slic3r::GCodeProcessor::process_file(), reload_gcode_moves(), Slic3r::GCodeProcessor::result(), Slic3r::GCodeProcessorResult::result_mutex, Slic3r::GCodeProcessor::s_IsBBLPrinter, and Slic3r::GCodeProcessor::set_xy_offset().

Referenced by reload_gcode_moves().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ restart()

void Slic3r::PrintBase::restart ( )

inlineinherited

513{ m_cancel_status = NOT_CANCELED; }

References m_cancel_status, and NOT_CANCELED.

Referenced by PrintBase(), and Slic3r::GUI::GLGizmoFdmSupports::run_thread().

Here is the caller graph for this function:

◆ run_pipeline_hook()

void Slic3r::Print::run_pipeline_hook	(	SlicingPipelineStepPlugin	step,
		const PrintObject *	object )

inlineprivate

                                                                                      {
        if (m_pipeline_plugin_active && s_slicing_pipeline_hook_fn)
            s_slicing_pipeline_hook_fn(*this, object, step);
    }

References m_pipeline_plugin_active, PrintObject, and s_slicing_pipeline_hook_fn.

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sequential_dynamic_orderings()

const std::map< const PrintObject *, ToolOrdering > & Slic3r::Print::sequential_dynamic_orderings ( ) const

inline

1235{ return m_sequential_dynamic_orderings; }

References m_sequential_dynamic_orderings.

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

Here is the caller graph for this function:

◆ sequential_print_clearance_valid()

StringObjectException Slic3r::Print::sequential_print_clearance_valid	(	const Print &	print,
		Polygons *	polygons = nullptr,
		std::vector< std::pair< Polygon, float > > *	height_polygons = nullptr )

static

{
    StringObjectException single_object_exception;
    const auto& print_config = print.config();
    const Vec3d print_origin = print.get_plate_origin();
    const std::vector<std::vector<BedExcludeRegion>> exclusion_volumes = translated_bed_exclusion_volumes_by_extruder(print);
 
    struct print_instance_info
    {
        const PrintInstance *print_instance;
        BoundingBox    bounding_box;
        Polygon        hull_polygon;
        int                  object_index;
        double         arrange_score;
        double               height;
    };
    auto find_object_index = [](const Model& model, const ModelObject* obj) {
        for (int index = 0; index < model.objects.size(); index++)
        {
            if (model.objects[index] == obj)
                return index;
        }
        return -1;
    };
 
    auto [object_skirt_offset, _] = print.object_skirt_offset();
    std::vector<struct print_instance_info> print_instance_with_bounding_box;
    {
        // sequential_print_horizontal_clearance_valid
        Polygons convex_hulls_other;
        if (polygons != nullptr)
            polygons->clear();
        std::vector<size_t> intersecting_idxs;
 
        // 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 obj_distance = print.is_all_objects_are_short() ? scale_(std::max(0.5f * MAX_OUTER_NOZZLE_DIAMETER, object_skirt_offset) - 0.1) : scale_(0.5 * print.config().extruder_clearance_radius.value + object_skirt_offset - 0.1);
 
        for (const PrintObject *print_object : print.objects()) {
            assert(! print_object->model_object()->instances.empty());
            assert(! print_object->instances().empty());
            
            // Orca: check convex hull intersection for each instance individually to handle rotation/offset differences correctly
            // 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_hull0 = print_object->model_object()->convex_hull_2d(Geometry::assemble_transform(
                            { 0.0, 0.0, instance.model_instance->get_offset().z() }, instance.model_instance->get_rotation(), instance.model_instance->get_scaling_factor(), instance.model_instance->get_mirror()));
 
                Polygon convex_hull_no_offset = convex_hull0, convex_hull;
                auto tmp = offset(convex_hull_no_offset, obj_distance, jtRound, scale_(0.1));
                if (!tmp.empty()) { // tmp may be empty due to clipper's bug, see STUDIO-2452
                    convex_hull = tmp.front();
                    // 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());
                }
                const std::optional<BedExclusionCollision> exclusion_collision = colliding_bed_exclusion(
                    print, *print_object, *instance.model_instance, exclusion_volumes);
                if (exclusion_collision.has_value()) {
                    const std::string collision_message = !exclusion_collision->collision_volume ?
                        (boost::format(L("%1% is too close to exclusion area. There may be collisions when printing.")) % instance.model_instance->get_object()->name).str() :
                        is_auto_filament_map_mode(print.get_filament_map_mode()) && print.is_BBL_printer() ?
                            // TRN %1% is the object name.
                            (boost::format(L("%1% intersects collision volumes for every available extruder.")) % instance.model_instance->get_object()->name).str() :
                            // TRN %1% is the object name, %2% the extruder number counted from 1.
                            (boost::format(L("%1% intersects a collision volume for extruder %2%.")) % instance.model_instance->get_object()->name % (exclusion_collision->extruder_id + 1)).str();
                    if (single_object_exception.string.empty()) {
                        single_object_exception.string = collision_message;
                        // single_object_exception.object = instance.model_instance->get_object();
                        //ORCA: Pass ModelInstance instead of ModelObject
                        single_object_exception.object = instance.model_instance;
                    }
                    else {
                        single_object_exception.string += "\n" + collision_message;
                        single_object_exception.object = nullptr;
                    }
                }
 
                // 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()) {
                        bool has_exception = false;
                        if (single_object_exception.string.empty()) {
                            single_object_exception.string = (boost::format(L("%1% is too close to others, and collisions may be caused.")) %instance.model_instance->get_object()->name).str();
                            // single_object_exception.object = instance.model_instance->get_object();
                            //ORCA: Pass ModelInstance instead of ModelObject for better selection
                            single_object_exception.object = instance.model_instance;
                            has_exception                  = true;
                        }
                        else {
                            single_object_exception.string += "\n"+(boost::format(L("%1% is too close to others, and collisions may be caused.")) %instance.model_instance->get_object()->name).str();
                            // single_object_exception.object = nullptr; 
                            // ORCA: Keep the first object so jump works
                            // has_exception                  = true;
                            has_exception                  = true;
                        }
 
                        if (polygons) {
                            intersecting_idxs.emplace_back(i);
                            intersecting_idxs.emplace_back(convex_hulls_other.size());
                        }
 
                        if (has_exception) break;
                    }
                }
                struct print_instance_info print_info {&instance, convex_hull.bounding_box(), convex_hull};
                print_info.height = instance.print_object->height();
                print_info.object_index = find_object_index(print.model(), print_object->model_object());
                print_instance_with_bounding_box.push_back(std::move(print_info));
                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]));
            }
        }
    }
 
    // calc sort order
    double hc1              = scale_(print.config().extruder_clearance_height_to_lid); // height to lid
    double hc2              = scale_(print.config().extruder_clearance_height_to_rod); // height to rod
    double printable_height = scale_(print.config().printable_height);
 
#if 0 //do not sort anymore, use the order in object list
    auto bed_points = get_bed_shape(print_config);
    float bed_width = bed_points[1].x() - bed_points[0].x();
    // 如果扩大以后的多边形的距离小于这个值，就需要严格保证从左到右的打印顺序，否则会撞工具头右侧
    float unsafe_dist = scale_(print_config.extruder_clearance_max_radius.value - print_config.extruder_clearance_radius.value);
    struct VecHash
    {
        size_t operator()(const Vec2i32 &n1) const
        {
            return std::hash<coord_t>()(int(n1(0) * 100 + 100)) + std::hash<coord_t>()(int(n1(1) * 100 + 100)) * 101;
        }
    };
    std::unordered_set<Vec2i32, VecHash> left_right_pair; // pairs in this vector must strictly obey the left-right order
    for (size_t i = 0; i < print_instance_with_bounding_box.size();i++) {
        auto &inst         = print_instance_with_bounding_box[i];
        inst.index         = i;
        Point pt           = inst.bounding_box.center();
        inst.arrange_score = pt.x() / 2 + pt.y(); // we prefer print row-by-row, so cost on x-direction is smaller
    }
    for (size_t i = 0; i < print_instance_with_bounding_box.size(); i++) {
        auto &inst         = print_instance_with_bounding_box[i];
        auto &l            = print_instance_with_bounding_box[i];
        for (size_t j = 0; j < print_instance_with_bounding_box.size(); j++) {
            if (j != i) {
                auto &r        = print_instance_with_bounding_box[j];
                auto ly1       = l.bounding_box.min.y();
                auto ly2       = l.bounding_box.max.y();
                auto ry1       = r.bounding_box.min.y();
                auto ry2       = r.bounding_box.max.y();
                auto lx1       = l.bounding_box.min.x();
                auto rx1       = r.bounding_box.min.x();
                auto lx2       = l.bounding_box.max.x();
                auto rx2       = r.bounding_box.max.x();
                auto inter_min = std::max(ly1, ry1);
                auto inter_max = std::min(ly2, ry2);
                auto inter_y   = inter_max - inter_min;
 
                // 如果y方向的重合超过轮廓的膨胀量，说明两个物体在一行，应该先打左边的物体，即先比较二者的x坐标。
                // If the overlap in the y direction exceeds the expansion of the contour, it means that the two objects are in a row and the object on the left should be hit first, that is, the x coordinates of the two should be compared first.
                if (inter_y > scale_(0.5 * print.config().extruder_clearance_radius.value)) {
                    if (std::max(rx1 - lx2, lx1 - rx2) < unsafe_dist) {
                        if (lx1 > rx1) {
                            left_right_pair.insert({j, i});
                            BOOST_LOG_TRIVIAL(debug) << "in-a-row, print_instance " << r.print_instance->model_instance->get_object()->name << "(" << r.arrange_score << ")"
                                                     << " -> " << l.print_instance->model_instance->get_object()->name << "(" << l.arrange_score << ")";
                        } else {
                            left_right_pair.insert({i, j});
                            BOOST_LOG_TRIVIAL(debug) << "in-a-row, print_instance " << l.print_instance->model_instance->get_object()->name << "(" << l.arrange_score << ")"
                                                     << " -> " << r.print_instance->model_instance->get_object()->name << "(" << r.arrange_score << ")";
                        }
                    }
                }
                if (l.height > hc1 && r.height < hc1) {
                    // 当前物体超过了顶盖高度，必须后打
                    left_right_pair.insert({j, i});
                    BOOST_LOG_TRIVIAL(debug) << "height>hc1, print_instance " << r.print_instance->model_instance->get_object()->name << "(" << r.arrange_score << ")"
                                             << " -> " << l.print_instance->model_instance->get_object()->name << "(" << l.arrange_score << ")";
                }
                else if (l.height > hc2 && l.height > r.height && l.arrange_score<r.arrange_score) {
                    // 如果当前物体的高度超过滑杆，且比r高，就给它加一点代价，尽量让高的物体后打（只有物体高度超过滑杆时才有必要按高度来）
                    if (l.arrange_score < r.arrange_score)
                        l.arrange_score = r.arrange_score + 10;
                    BOOST_LOG_TRIVIAL(debug) << "height>hc2, print_instance " << inst.print_instance->model_instance->get_object()->name
                                             << ", right=" << r.print_instance->model_instance->get_object()->name << ", l.score: " << l.arrange_score
                                             << ", r.score: " << r.arrange_score;
                }
            }
        }
    }
    // 多做几次代价传播，因为前一次有些值没有更新。
    // TODO 更好的办法是建立一颗树，一步到位。不过我暂时没精力搞，先就这样吧
    for (int k=0;k<5;k++)
    for (auto p : left_right_pair) {
        auto &l = print_instance_with_bounding_box[p(0)];
        auto &r = print_instance_with_bounding_box[p(1)];
        if(r.arrange_score<l.arrange_score)
            r.arrange_score = l.arrange_score + 10;
    }
 
    BOOST_LOG_TRIVIAL(debug) << "bed width: " << unscale_(bed_width) << ", unsafe_dist:" << unscale_(unsafe_dist) << ", height_to_lid: " << unscale_(hc1) << ", height_to_rod:" << unscale_(hc2) << ", final dependency:";
    for (auto p : left_right_pair) {
        auto &l         = print_instance_with_bounding_box[p(0)];
        auto &r         = print_instance_with_bounding_box[p(1)];
        BOOST_LOG_TRIVIAL(debug) << "print_instance " << I18N::translate(l.print_instance->model_instance->get_object()->name) << "(" << l.arrange_score << ")"
                                 << " -> " << I18N::translate(r.print_instance->model_instance->get_object()->name) << "(" << r.arrange_score << ")";
    }
    // sort the print instance
    std::sort(print_instance_with_bounding_box.begin(), print_instance_with_bounding_box.end(),
        [](print_instance_info& l, print_instance_info& r) {return l.arrange_score < r.arrange_score;});
 
    for (auto &inst : print_instance_with_bounding_box)
        BOOST_LOG_TRIVIAL(debug) << "after sorting print_instance " << inst.print_instance->model_instance->get_object()->name << ", score: " << inst.arrange_score
                                 << ", height:"<< inst.height;
#else
    // sort the print instance
    std::sort(print_instance_with_bounding_box.begin(), print_instance_with_bounding_box.end(),
        [](print_instance_info& l, print_instance_info& r) {return l.object_index < r.object_index;});
 
    for (auto &inst : print_instance_with_bounding_box)
        BOOST_LOG_TRIVIAL(debug) << "after sorting print_instance " << inst.print_instance->model_instance->get_object()->name << ", object_index: " << inst.object_index
                                 << ", height:"<< inst.height;
 
#endif
    // sequential_print_vertical_clearance_valid
    {
        // Ignore the last instance printed.
        //print_instance_with_bounding_box.pop_back();
        /*bool has_interlaced_objects = false;
        for (int k = 0; k < print_instance_count; k++)
        {
            auto inst = print_instance_with_bounding_box[k].print_instance;
            auto bbox = print_instance_with_bounding_box[k].bounding_box;
            auto iy1 = bbox.min.y();
            auto iy2 = bbox.max.y();
 
            for (int i = 0; i < k; i++)
            {
                auto& p = print_instance_with_bounding_box[i].print_instance;
                auto bbox2 = print_instance_with_bounding_box[i].bounding_box;
                auto py1 = bbox2.min.y();
                auto py2 = bbox2.max.y();
                auto inter_min = std::max(iy1, py1); // min y of intersection
                auto inter_max = std::min(iy2, py2); // max y of intersection. length=max_y-min_y>0 means intersection exists
                if (inter_max - inter_min > 0) {
                    has_interlaced_objects = true;
                    break;
                }
            }
            if (has_interlaced_objects)
                break;
        }*/
 
        // if objects are not overlapped on y-axis, they will not collide even if they are taller than extruder_clearance_height_to_rod
        int print_instance_count = print_instance_with_bounding_box.size();
        std::map<const PrintInstance*, std::pair<Polygon, float>> too_tall_instances;
        for (int k = 0; k < print_instance_count; k++)
        {
            auto inst = print_instance_with_bounding_box[k].print_instance;
            // 只需要考虑喷嘴到滑杆的偏移量，这个比整个工具头的碰撞半径要小得多
            // Only the offset from the nozzle to the slide bar needs to be considered, which is much smaller than the collision radius of the entire tool head.
            auto bbox = print_instance_with_bounding_box[k].bounding_box.inflated(-scale_(0.5 * print.config().extruder_clearance_radius.value + object_skirt_offset));
            auto iy1 = bbox.min.y();
            auto iy2 = bbox.max.y();
            (const_cast<ModelInstance*>(inst->model_instance))->arrange_order = k+1;
            double height = (k == (print_instance_count - 1))?printable_height:hc1;
            /*if (has_interlaced_objects) {
                if ((k < (print_instance_count - 1)) && (inst->print_object->height() > hc2)) {
                    too_tall_instances[inst] = std::make_pair(print_instance_with_bounding_box[k].hull_polygon, unscaled<double>(hc2));
                }
            }
            else {
                if ((k < (print_instance_count - 1)) && (inst->print_object->height() > hc1)) {
                    too_tall_instances[inst] = std::make_pair(print_instance_with_bounding_box[k].hull_polygon, unscaled<double>(hc1));
                }
            }*/
 
            for (int i = k+1; i < print_instance_count; i++)
            {
                auto& p = print_instance_with_bounding_box[i].print_instance;
                auto bbox2 = print_instance_with_bounding_box[i].bounding_box;
                auto py1 = bbox2.min.y();
                auto py2 = bbox2.max.y();
                auto inter_min = std::max(iy1, py1); // min y of intersection
                auto inter_max = std::min(iy2, py2); // max y of intersection. length=max_y-min_y>0 means intersection exists
                if (inter_max - inter_min > 0) {
                    height = hc2;
                    break;
                }
            }
            if (height < inst->print_object->max_z())
                too_tall_instances[inst] = std::make_pair(print_instance_with_bounding_box[k].hull_polygon, unscaled<double>(height));
        }
 
        if (too_tall_instances.size() > 0) {
            //return {, inst->model_instance->get_object()};
            for (auto& iter: too_tall_instances) {
                if (single_object_exception.string.empty()) {
                    single_object_exception.string = (boost::format(L("%1% is too tall, and collisions will be caused.")) %iter.first->model_instance->get_object()->name).str();
                    single_object_exception.object = iter.first->model_instance->get_object();
                }
                else {
                    single_object_exception.string += "\n" + (boost::format(L("%1% is too tall, and collisions will be caused.")) %iter.first->model_instance->get_object()->name).str();
                    single_object_exception.object = nullptr;
                }
                if (height_polygons)
                    height_polygons->emplace_back(std::move(iter.second));
            }
        }
    }
 
    return single_object_exception;
}

References Print(), _, Slic3r::Geometry::assemble_transform(), Slic3r::bounding_box(), Slic3r::colliding_bed_exclusion(), config(), Slic3r::Geometry::convex_hull(), empty(), Slic3r::get_bed_shape(), get_filament_map_mode(), get_plate_origin(), Slic3r::intersection(), is_all_objects_are_short(), Slic3r::is_auto_filament_map_mode(), is_BBL_printer(), Slic3r::jtRound, L, MAX_OUTER_NOZZLE_DIAMETER, Slic3r::PrintBase::model(), Slic3r::PrintBaseWithState< PrintStep, psCount >::model(), Slic3r::StringObjectException::object, object_skirt_offset(), objects(), Slic3r::offset(), Slic3r::printable_height(), PrintObject, scale_, Slic3r::StringObjectException::string, Slic3r::I18N::translate(), Slic3r::translated_bed_exclusion_volumes_by_extruder(), unscale_, and Slic3r::unscaled().

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

108{ ar(m_id); }

References m_id.

◆ set_calib_params()

void Slic3r::Print::set_calib_params ( const Calib_Params & params )

                                                       {
    m_calib_params = params;
    m_calib_params.mode = params.mode;
}

References m_calib_params, and Slic3r::Calib_Params::mode.

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf().

Here is the caller graph for this function:

◆ set_cancel_callback()

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

inlineinherited

496{ m_cancel_callback = cancel_callback; }

References cancel_callback(), and m_cancel_callback.

Here is the call graph for this function:

◆ set_check_multi_filaments_compatibility()

void Slic3r::Print::set_check_multi_filaments_compatibility ( bool check )

inline

1356{ m_need_check_multi_filaments_compatibility = check; }

anonymous_namespace{GLGizmoEmboss.cpp}::check

bool check(ModelVolumeType volume_type)

Definition GLGizmoEmboss.cpp:515

References m_need_check_multi_filaments_compatibility.

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

Here is the caller graph for this function:

◆ set_done()

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

References m_state, Slic3r::PrintStateBase::NON_CRITICAL, Slic3r::PrintBase::state_mutex(), Slic3r::PrintBase::status_update_warnings(), and Slic3r::PrintBase::throw_if_canceled().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_extruder_filament_info()

void Slic3r::Print::set_extruder_filament_info ( const std::vector< std::vector< DynamicPrintConfig > > & filament_info )

inline

1238{ m_extruder_filament_info = filament_info; }

References m_extruder_filament_info.

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

Here is the caller graph for this function:

◆ set_gcode_file_invalidated()

void Slic3r::Print::set_gcode_file_invalidated ( )

{
    this->invalidate_step(psGCodeExport);
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ <<  boost::format(": done");
}

References invalidate_step(), Slic3r::psGCodeExport, and set_gcode_file_invalidated().

Referenced by set_gcode_file_invalidated().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_gcode_file_ready()

void Slic3r::Print::set_gcode_file_ready ( )

{
    this->set_started(psGCodeExport);
  this->set_done(psGCodeExport);
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ <<  boost::format(": done");
}

References Slic3r::psGCodeExport, Slic3r::PrintBaseWithState< PrintStep, psCount >::set_done(), set_gcode_file_ready(), and Slic3r::PrintBaseWithState< PrintStep, psCount >::set_started().

Referenced by Slic3r::GUI::Plater::load_gcode(), and set_gcode_file_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_geometric_unprintable_filaments()

void Slic3r::Print::set_geometric_unprintable_filaments ( const std::vector< std::set< int > > & unprintables_filament_ids )

inline

1240{ m_geometric_unprintable_filaments = unprintables_filament_ids; }

References m_geometric_unprintable_filaments.

◆ set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

90{ m_id = 0; }

References 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

89{ m_id = generate_new_id(); }

Slic3r::ObjectBase::generate_new_id

static ObjectID generate_new_id()

Definition ObjectID.hpp:100

References generate_new_id(), and m_id.

Referenced by Slic3r::ModelVolume::ModelVolume(), Slic3r::Model::assign_new_unique_ids_recursive(), Slic3r::ModelVolume::assign_new_unique_ids_recursive(), 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_no_check_flag()

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

inlineinherited

529{ m_no_check = no_check; }

References m_no_check.

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

Here is the caller graph for this function:

◆ set_nozzle_group_result()

void Slic3r::Print::set_nozzle_group_result ( std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase > result )

{
    m_nozzle_group_result         = std::move(result);
    m_layered_nozzle_group_result = std::dynamic_pointer_cast<MultiNozzleUtils::LayeredNozzleGroupResult>(m_nozzle_group_result);
    ++m_config_index_generation;
}

References m_config_index_generation, m_layered_nozzle_group_result, m_nozzle_group_result, and set_nozzle_group_result().

Referenced by set_nozzle_group_result().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_plate_index()

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

inlineinherited

527{ m_plate_index = index; }

References m_plate_index.

◆ set_plate_name()

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

inlineinherited

533{ m_plate_name = name; }

References m_plate_name.

◆ set_plate_origin()

void Slic3r::Print::set_plate_origin ( Vec3d origin )

inline

1294{ m_origin = origin; }

References m_origin.

◆ set_slice_used_filaments()

void Slic3r::Print::set_slice_used_filaments	(	const std::vector< unsigned int > &	first_layer_used_filaments,
		const std::vector< unsigned int > &	used_filaments )

inline

                                                                                                                                           {
        m_slice_used_filaments_first_layer = first_layer_used_filaments;
        m_slice_used_filaments = used_filaments;
    }

References m_slice_used_filaments, and m_slice_used_filaments_first_layer.

◆ set_slice_used_mixed_filaments()

void Slic3r::Print::set_slice_used_mixed_filaments ( const std::vector< unsigned int > & used_mixed_filaments )

inline

                                                                                             {
        m_slice_used_mixed_filaments = used_mixed_filaments;
    }

References m_slice_used_mixed_filaments.

◆ set_slicing_pipeline_hook_fn()

void Slic3r::Print::set_slicing_pipeline_hook_fn ( SlicingPipelineHookFn fn )

inlinestatic

1064{ s_slicing_pipeline_hook_fn = std::move(fn); }

References s_slicing_pipeline_hook_fn.

Referenced by Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_slicing_pipeline_hook(), and Slic3r::plugin_hooks::uninstall().

Here is the caller graph for this function:

◆ set_started()

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

inlineprotectedinherited

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

References m_state, Slic3r::PrintBase::state_mutex(), and Slic3r::PrintBase::throw_if_canceled().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_status()

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

inherited

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

References m_status_callback.

Referenced by Slic3r::TreeSupport3D::generate_support_areas(), Slic3r::SLAPrint::StatusReporter::operator()(), Slic3r::GCode::process_layers(), and Slic3r::GUI::GLGizmoFdmSupports::run_thread().

Here is the caller graph for this function:

◆ set_status_callback()

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

inlineinherited

488{ m_status_callback = cb; }

References 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

484{ m_status_callback = nullptr; }

References m_status_callback.

◆ set_status_silent()

void Slic3r::PrintBase::set_status_silent ( )

inlineinherited

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

References m_status_callback.

Referenced by anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export().

Here is the caller graph for this function:

◆ set_task()

virtual void Slic3r::PrintBase::set_task ( const TaskParams & params )

inlinevirtualinherited

Reimplemented in Slic3r::SLAPrint.

434{}

◆ shrinkage_compensation()

Vec3d Slic3r::Print::shrinkage_compensation ( ) const

inline

1398{ return m_shrinkage_compensation; }

References m_shrinkage_compensation.

Referenced by validate().

Here is the caller graph for this function:

◆ skirt()

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

inline

1170{ return m_skirt; }

References m_skirt.

Referenced by libvgcode::convert_brim_skirt_to_vertices(), and Slic3r::get_print_extrusions_extents().

Here is the caller graph for this function:

◆ skirt_brim_groups()

const std::vector< SkirtBrimGroup > & Slic3r::Print::skirt_brim_groups ( ) const

inline

1171{ return m_skirt_brim_groups; }

References m_skirt_brim_groups.

Referenced by Slic3r::GCode::_do_export(), Slic3r::find_skirt_brim_group_idx(), Slic3r::GCode::generate_object_brim(), and Slic3r::GCode::generate_object_skirt_group().

Here is the caller graph for this function:

◆ skirt_first_layer_height()

double Slic3r::Print::skirt_first_layer_height ( ) const

{
    return m_config.initial_layer_print_height.value;
}

References m_config.

Referenced by _make_skirt(), _make_wipe_tower(), and Slic3r::outer_inner_brim_area().

Here is the caller graph for this function:

◆ skirt_flow()

Flow Slic3r::Print::skirt_flow ( ) const

{
 
    // Orca: fall back to m_config if no objects are present
    ConfigOptionFloatOrPercent width = m_config.initial_layer_line_width;
    if (width.value <= 0)
        width = m_objects.empty() ? m_config.initial_layer_line_width : m_objects.front()->config().line_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,
        // Flow::new_from_config_width takes care of the percent to value substitution
        width,
        // ORCA: resolve the actual nozzle the support filament is printed with (dual-nozzle printers).
        (float)nozzle_diameter_for_filament(m_config, m_objects.empty() ? 0 : m_objects.front()->config().support_filament, this->is_BBL_printer()),
        (float)this->skirt_first_layer_height());
}

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

Referenced by _make_skirt(), Slic3r::GCode::generate_skirt(), and object_skirt_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slicing_errors_message()

std::string Slic3r::Print::slicing_errors_message ( const SlicingErrors & errors ) const

{
    std::string message;
    for (const SlicingError &error : errors.errors_) {
        std::string object_name;
        for (const PrintObject *object : m_objects)
            if (object->id().id == error.objectId()) {
                object_name = object->model_object()->name;
                break;
            }
        if (!message.empty())
            message += "\n";
        message += object_name.empty() ? std::string(error.what()) : object_name + ": " + error.what();
    }
    return message;
}

References Slic3r::SlicingErrors::errors_, m_objects, Slic3r::SlicingError::objectId(), and PrintObject.

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

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

538{ return m_state_mutex; }

Slic3r::PrintBase::m_state_mutex

std::mutex m_state_mutex

Definition PrintBase.hpp:585

References m_state_mutex.

Referenced by Slic3r::PrintBaseWithState< PrintStep, psCount >::active_step_add_warning(), Slic3r::PrintBaseWithState< PrintStep, psCount >::is_step_done(), Slic3r::PrintBaseWithState< PrintStep, psCount >::set_done(), Slic3r::PrintBaseWithState< PrintStep, psCount >::set_started(), Slic3r::PrintObjectBase::state_mutex(), Slic3r::PrintBaseWithState< PrintStep, psCount >::step_state_with_timestamp(), and Slic3r::PrintBaseWithState< PrintStep, psCount >::step_state_with_warnings().

Here is the caller graph for this function:

◆ statistics_by_extruder() [1/2]

StatisticsByExtruderCount & Slic3r::Print::statistics_by_extruder ( )

inline

1184{ return m_statistics_by_extruder_count; }

References m_statistics_by_extruder_count.

◆ statistics_by_extruder() [2/2]

const StatisticsByExtruderCount Slic3r::Print::statistics_by_extruder ( ) const

inline

1183{ return m_statistics_by_extruder_count; }

References m_statistics_by_extruder_count.

◆ status_update_warnings() [1/2]

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

protectedinherited

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

References m_status_callback, and PrintObjectBase.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ status_update_warnings() [2/2]

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

protectedinherited

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

References m_status_callback, and PrintObjectBase.

Here is the call graph for this function:

◆ step_state_with_timestamp()

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

inlineinherited

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

References m_state, and Slic3r::PrintBase::state_mutex().

Here is the call graph for this function:

◆ step_state_with_warnings()

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

inlineinherited

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

References m_state, and Slic3r::PrintBase::state_mutex().

Here is the call graph for this function:

◆ support_material_extruders()

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

{
    std::vector<unsigned int> extruders;
    bool support_uses_current_extruder = false;
    // BBS
    auto num_extruders = (unsigned int)m_config.filament_diameter.size();
 
    for (PrintObject *object : m_objects) {
        if (object->has_support_material() && append_support_extruders(object->config(), num_extruders, extruders))
            support_uses_current_extruder = true;
    }
 
    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(), append_support_extruders(), extruders(), m_config, m_objects, object_extruders(), PrintObject, 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.

1069{ return ptFFF; }

Slic3r::ptFFF

@ ptFFF

Definition Config.hpp:231

References Slic3r::ptFFF.

◆ throw_if_canceled()

void Slic3r::PrintBase::throw_if_canceled ( ) const

inlineprotectedinherited

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

References m_cancel_status.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GCode::process_layers(), Slic3r::PrintBaseWithState< PrintStep, psCount >::set_done(), and Slic3r::PrintBaseWithState< PrintStep, psCount >::set_started().

Here is the caller graph for this function:

◆ timestamp()

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

inlinevirtualinherited

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

74{ return 0; }

◆ tool_ordering()

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

inline

1191{ return m_tool_ordering; }

References m_tool_ordering.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::OozePrevention::pre_toolchange().

Here is the caller graph for this function:

◆ translate_to_print_space() [1/2]

Vec2d Slic3r::Print::translate_to_print_space ( const Point & point ) const

                                                              {
    return Vec2d(unscaled(point.x()) - m_origin(0) - m_imex_slice_offset.x(),
                 unscaled(point.y()) - m_origin(1) - m_imex_slice_offset.y());
}

References m_imex_slice_offset, m_origin, translate_to_print_space(), and Slic3r::unscaled().

Here is the call graph for this function:

◆ translate_to_print_space() [2/2]

Vec2d Slic3r::Print::translate_to_print_space ( const Vec2d & point ) const

                                                              {
    //const BoundingBoxf bed_bbox(config().printable_area.values);
    return Vec2d(point(0) - m_origin(0) - m_imex_slice_offset.x(),
                 point(1) - m_origin(1) - m_imex_slice_offset.y());
}

References m_imex_slice_offset, m_origin, and translate_to_print_space().

Referenced by Slic3r::GCode::_do_export(), Slic3r::polygon_to_string(), Slic3r::GCode::set_object_info(), translate_to_print_space(), and translate_to_print_space().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_filament_maps_to_config()

void Slic3r::Print::update_filament_maps_to_config	(	std::vector< int >	f_maps,
		std::vector< int >	f_volume_maps = std::vector<int>{},
		std::vector< int >	f_nozzle_maps = std::vector<int>{} )

{
    if ((m_config.filament_map.values != f_maps) || (m_config.filament_volume_map.values != f_volume_maps) || (m_config.filament_nozzle_map.values != f_nozzle_maps))
    {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": filament maps changed after pre-slicing.");
        m_ori_full_print_config.option<ConfigOptionInts>("filament_map", true)->values = f_maps;
        m_config.filament_map.values = f_maps;
 
        if (!f_volume_maps.empty()) {
            m_ori_full_print_config.option<ConfigOptionInts>("filament_volume_map", true)->values = f_volume_maps;
            m_config.filament_volume_map.values = f_volume_maps;
        }
        else {
            m_ori_full_print_config.option<ConfigOptionInts>("filament_volume_map", true)->values.resize(f_maps.size(), nvtStandard);
            m_config.filament_volume_map.values.resize(f_maps.size(), nvtStandard);
        }
 
        if (!f_nozzle_maps.empty()) {
            m_ori_full_print_config.option<ConfigOptionInts>("filament_nozzle_map", true)->values = f_nozzle_maps;
            m_config.filament_nozzle_map.values = f_nozzle_maps;
        }
    }
 
    {
        int extruder_count = 1, extruder_volume_type_count = 1;
        bool support_multi = m_ori_full_print_config.support_different_extruders(extruder_count);
        // Orca: resolve the filament variants wherever Print::apply does, a multi-variant filament
        // on a single-variant printer included.
        const bool expand_filaments = (extruder_count > 1) || support_multi || m_ori_full_print_config.has_multi_variant_filament();
        std::vector<std::vector<NozzleVolumeType>> nozzle_volume_types;
        extruder_volume_type_count = m_ori_full_print_config.get_extruder_nozzle_volume_count(extruder_count, nozzle_volume_types);
 
        //filament_map_2
        // Orca: seed with 0-based extruder indices so the override keying below degenerates to the
        // plain per-extruder slot when the rebuild loop is skipped; the loop overwrites every
        // entry when it runs.
        m_config.filament_map_2.values = f_maps;
        for (auto& v : m_config.filament_map_2.values)
            --v;
        auto opt_extruder_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(m_ori_full_print_config.option("extruder_type"));
        auto opt_nozzle_volume_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(m_ori_full_print_config.option("nozzle_volume_type"));
        // Orca: the loop tolerates configs without the extruder options (unit tests, degenerate
        // presets); the backfill and the override are bounds-checked because the change block above
        // is skipped when the maps are unchanged, in which case the stored map may be shorter than
        // the filament count.
        auto* ori_volume_map = m_ori_full_print_config.option<ConfigOptionInts>("filament_volume_map", true);
        for (int index = 0; opt_extruder_type && opt_nozzle_volume_type && index < f_maps.size(); index++)
        {
            ExtruderType extruder_type = (ExtruderType)(opt_extruder_type->get_at(f_maps[index] - 1));
            NozzleVolumeType nozzle_volume_type = (NozzleVolumeType)(opt_nozzle_volume_type->get_at(f_maps[index] - 1));
            if (f_volume_maps.empty()) {
                // No per-filament map supplied: backfill from the extruder's own volume type.
                if (m_config.filament_volume_map.values.size() > index)
                    m_config.filament_volume_map.values[index] = nozzle_volume_type;
                if (ori_volume_map->values.size() > index)
                    ori_volume_map->values[index] = nozzle_volume_type;
            }
            else if ((extruder_volume_type_count > extruder_count) && (m_config.filament_volume_map.values.size() > index))
                nozzle_volume_type = (NozzleVolumeType)(m_config.filament_volume_map.values[index]);
            // Orca: when the process variant columns cannot be matched (degenerate
            // print_extruder_id), key the override by plain extruder index like the seeding
            // above instead of poisoning the map with -1.
            int slot_index = m_ori_full_print_config.get_index_for_extruder(f_maps[index], "print_extruder_id", extruder_type, nozzle_volume_type, "print_extruder_variant");
            m_config.filament_map_2.values[index] = slot_index >= 0 ? slot_index : f_maps[index] - 1;
        }
 
        m_full_print_config = m_ori_full_print_config;
        std::set<std::string> filament_keys = filament_options_with_variant;
        filament_keys.insert("filament_self_index");
        if (expand_filaments)
            m_full_print_config.update_values_to_printer_extruders_for_multiple_filaments(m_full_print_config, extruder_count, extruder_volume_type_count, filament_keys,  "filament_self_index", "filament_extruder_variant");
 
        const std::vector<std::string> &extruder_retract_keys = print_config_def.extruder_retract_keys();
        const std::string               filament_prefix       = "filament_";
        t_config_option_keys            print_diff;
        DynamicPrintConfig              filament_overrides;
        for (auto& opt_key: extruder_retract_keys)
        {
            const ConfigOption *opt_new_filament = m_full_print_config.option(filament_prefix + opt_key);
            const ConfigOption *opt_new_machine = m_full_print_config.option(opt_key);
            const ConfigOption *opt_old_machine = m_config.option(opt_key);
 
            if (opt_new_filament)
                compute_filament_override_value(opt_key, opt_old_machine, opt_new_machine, opt_new_filament, m_full_print_config, print_diff, filament_overrides, m_config.filament_map_2.values);
        }
 
        if (expand_filaments) {
            t_config_option_keys keys(filament_options_with_variant.begin(), filament_options_with_variant.end());
            keys.push_back("filament_self_index");
            m_config.apply_only(m_full_print_config, keys, true);
        }
        if (!print_diff.empty()) {
            m_placeholder_parser.apply_config(filament_overrides);
            m_config.apply(filament_overrides);
        }
    }
    update_filament_self_index_cache();
    m_has_auto_filament_map_result = true;
}

References Slic3r::compute_filament_override_value(), Slic3r::filament_options_with_variant, m_config, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_full_print_config, m_has_auto_filament_map_result, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_ori_full_print_config, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_placeholder_parser, Slic3r::nozzle_volume_type(), Slic3r::nvtStandard, Slic3r::print_config_def, update_filament_maps_to_config(), and update_filament_self_index_cache().

Referenced by update_filament_maps_to_config(), and update_to_config_by_nozzle_group_result().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_filament_self_index_cache()

void Slic3r::Print::update_filament_self_index_cache ( )

private

{
    m_missing_nozzle_group_logged.clear();   // reset the per-slice get_config_index log dedupe
    ++m_config_index_generation;
 
    std::vector<int> values;
    if (m_full_print_config.has("filament_self_index")) {
        values = m_full_print_config.option<ConfigOptionInts>("filament_self_index")->values;
    } else if (m_ori_full_print_config.has("filament_self_index")) {
        values = m_ori_full_print_config.option<ConfigOptionInts>("filament_self_index")->values;
    } else {
        values = m_config.filament_self_index.values;
    }
 
    size_t expected_size = m_config.filament_extruder_variant.values.size();
    m_filament_self_index.clear();
    if (expected_size == 0) {
        m_filament_index_map.clear();
        m_nozzle_index_map.clear();
        return;
    }
    m_filament_self_index.resize(expected_size, 1);
    if (!values.empty()) {
        for (size_t i = 0; i < expected_size; ++i) {
            int v = i < values.size() ? values[i] : 1;
            if (v <= 0)
                v = 1;
            m_filament_self_index[i] = v;
        }
    }
    m_filament_index_map.clear();
    m_nozzle_index_map.clear();
}

References m_config, m_config_index_generation, m_filament_index_map, m_filament_self_index, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_full_print_config, m_missing_nozzle_group_logged, m_nozzle_index_map, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_ori_full_print_config, and update_filament_self_index_cache().

Referenced by update_filament_maps_to_config(), update_filament_self_index_cache(), and update_to_config_by_nozzle_group_result().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_imex_slice_offset()

void Slic3r::Print::update_imex_slice_offset ( )

{
    m_imex_slice_offset = Vec2d::Zero();
    if (!m_config.is_imex.value || !m_config.imex_firmware_managed_zones.value || m_objects.empty())
        return;
 
    // Already the resolved plate-or-process mode: the plate config overrides the process
    // preset's key on the way in, exactly as PartPlate::get_imex_mode() prefers the plate.
    const std::string& active_mode = m_objects.front()->config().imex_parallel_mode.value;
    const ImexZoneLayout layout    = compute_imex_zone_layout(m_full_print_config, active_mode,
                                                              std::string(),
                                                              get_extents(m_config.printable_area.values));
    // Empty / Primary mode and an empty layout both come back as Vec2d::Zero() here.
    m_imex_slice_offset = compute_imex_slice_offset(true, active_mode, layout.primary_zone_box);
}

References Slic3r::compute_imex_slice_offset(), Slic3r::compute_imex_zone_layout(), Slic3r::get_extents(), m_config, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_full_print_config, m_imex_slice_offset, m_objects, Slic3r::ImexZoneLayout::primary_zone_box, and update_imex_slice_offset().

Referenced by export_gcode(), process(), and update_imex_slice_offset().

Here is the call graph for this function:

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

References Slic3r::ConfigOptionString, Slic3r::ModelInstance::get_scaling_factor(), Slic3r::ModelObject::input_file, Slic3r::ModelObject::instances, Slic3r::ModelInstance::is_printable(), m_model, Slic3r::ModelObject::name, Slic3r::DynamicConfig::set_key_value(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_shrinkage_compensation()

void Slic3r::Print::update_shrinkage_compensation	(	size_t	num_extruders,
		std::vector< int > &	variant_index )

private

{
    const auto set_compensation = [this](unsigned int extruder) {
        // 100% from the user is the equivalent to 0 in orca.
        const double xy_compensation = 100.0 / m_config.filament_shrink.get_at(extruder);
        const double z_compensation  = 100.0 / m_config.filament_shrinkage_compensation_z.get_at(extruder);
        m_shrinkage_compensation = { xy_compensation, xy_compensation, z_compensation };
    };
    const auto same_shrinkage = [this](unsigned int a, unsigned int b) {
        return m_config.filament_shrink.get_at(a) == m_config.filament_shrink.get_at(b) &&
               m_config.filament_shrinkage_compensation_z.get_at(a) == m_config.filament_shrinkage_compensation_z.get_at(b);
    };
    // Usually all filaments share the same shrinkage, then it does not matter which of them print.
    bool uniform = true;
    for (unsigned int extruder = 1; extruder < num_extruders && uniform; ++ extruder)
        uniform = same_shrinkage(0, extruder);
    if (uniform) {
        m_same_shrinkage_compensations = true;
        set_compensation(0);
        return;
    }
 
    std::vector<unsigned int> extruders;
    const auto append_feature_extruders = [num_extruders, &extruders](const PrintRegionConfig &config) {
        for (int id : { config.outer_wall_filament_id.value, config.inner_wall_filament_id.value, config.sparse_infill_filament_id.value,
                        config.internal_solid_filament_id.value, config.top_surface_filament_id.value, config.bottom_surface_filament_id.value }) {
            const unsigned int i = (unsigned int)std::max(0, id - 1);
            extruders.emplace_back(i >= num_extruders ? 0 : i);
        }
    };
    for (const ModelObject *model_object : m_model.objects) {
        if (std::none_of(model_object->instances.begin(), model_object->instances.end(), [](const ModelInstance *mi) { return mi->is_printable(); }))
            continue;
        std::vector<const ModelVolume*> modifiers;
        std::copy_if(model_object->volumes.begin(), model_object->volumes.end(), std::back_inserter(modifiers), [](const ModelVolume *mv) { return mv->is_modifier(); });
        for (const ModelVolume *part : model_object->volumes) {
            if (! part->is_model_part())
                continue;
            std::vector<PrintRegionConfig> parents { region_config_from_model_volume(m_default_region_config, nullptr, *part, num_extruders, variant_index) };
            for (const auto &[range, range_config] : model_object->layer_config_ranges)
                parents.emplace_back(region_config_from_model_volume(m_default_region_config, &range_config.get(), *part, num_extruders, variant_index));
            for (const PrintRegionConfig &parent : parents) {
                append_feature_extruders(parent);
                for (const ModelVolume *modifier : modifiers)
                    append_feature_extruders(region_config_from_model_volume(parent, nullptr, *modifier, num_extruders, variant_index));
            }
        }
        append_model_object_extruders(*model_object, extruders);
        const PrintObjectConfig object_config = PrintObject::object_config_from_model_object(m_default_object_config, *model_object, num_extruders, variant_index);
        if (PrintObject::has_support_material(object_config))
            append_support_extruders(object_config, (unsigned int)num_extruders, extruders);
    }
    this->append_tool_change_extruders(extruders);
    // A mixed slot prints with its physical components.
    const auto expand_and_sort = [this, &extruders]() {
        extruders = expand_mixed_filaments(extruders, m_config.filament_is_mixed.values, m_config.filament_mixed_components.values);
    };
    expand_and_sort();
    // The wipe tower filament may also be flushed into the objects.
    this->append_wipe_tower_extruder(extruders);
    expand_and_sort();
 
    m_same_shrinkage_compensations = ! extruders.empty() &&
        std::all_of(extruders.begin(), extruders.end(), [&](unsigned int extruder) { return same_shrinkage(extruders.front(), extruder); });
    m_shrinkage_compensation = Vec3d::Ones();
    if (m_same_shrinkage_compensations)
        set_compensation(extruders.front());
}

References append_model_object_extruders(), append_support_extruders(), append_tool_change_extruders(), append_wipe_tower_extruder(), config(), Slic3r::expand_mixed_filaments(), extruders(), Slic3r::PrintObject::has_support_material(), Slic3r::ModelObject::instances, Slic3r::ModelVolume::is_model_part(), Slic3r::ModelObject::layer_config_ranges, m_config, m_default_object_config, m_default_region_config, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_model, m_same_shrinkage_compensations, m_shrinkage_compensation, Slic3r::PrintObject::object_config_from_model_object(), Slic3r::PrintObjectConfig, Slic3r::PrintRegionConfig, Slic3r::range(), Slic3r::region_config_from_model_volume(), update_shrinkage_compensation(), and Slic3r::ModelObject::volumes.

Referenced by update_shrinkage_compensation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_to_config_by_nozzle_group_result()

void Slic3r::Print::update_to_config_by_nozzle_group_result ( const MultiNozzleUtils::LayeredNozzleGroupResult & group_result )

{
    std::vector<int> derived_maps = group_result.get_extruder_map(false); // 1-based
    if (derived_maps.empty())
        return;
 
    if (!group_result.is_support_dynamic_nozzle_map()) {
        // No filament actually migrated between nozzles, so the plan reduces to a single
        // grouping: write all maps like the static paths do, and the next apply re-derives
        // identical slots from the written maps.
        std::vector<int> base_filament_map = m_config.filament_map.values;
        if (base_filament_map.size() != derived_maps.size())
            base_filament_map.assign(derived_maps.size(), 1);
        std::vector<int> base_volume_map = m_config.filament_volume_map.values;
        if (base_volume_map.size() != derived_maps.size())
            base_volume_map.assign(derived_maps.size(), (int)nvtStandard);
        const std::vector<unsigned int> used_filaments = group_result.get_used_filaments();
        update_filament_maps_to_config(FilamentGroupUtils::update_used_filament_values(base_filament_map, derived_maps, used_filaments),
                                       FilamentGroupUtils::update_used_filament_values(base_volume_map, group_result.get_volume_map(), used_filaments),
                                       group_result.get_nozzle_map());
        return;
    }
 
    // Orca: keep the coarse per-filament extruder map published even though the per-layer truth
    // lives in the grouping result: the pre-export consumers, the plate read-back after slicing
    // and the preview panel all key on filament_map. The write is direct — the full map
    // write-back's single-slot rebuild would undo the per-variant expansion below.
    m_ori_full_print_config.option<ConfigOptionInts>("filament_map", true)->values = derived_maps;
    m_config.filament_map.values = derived_maps;
 
    std::unordered_map<int, std::vector<FilamentVariantUse>> filament_variant_uses;
    if (!collect_filament_variant_uses(group_result, m_ori_full_print_config, filament_variant_uses)) {
        // Degenerate config (no filament/extruder typing): fall back to the single-slot
        // write-back so the maps and overrides stay coherent.
        update_filament_maps_to_config(derived_maps);
        return;
    }
 
    int extruder_count = 1, extruder_volume_type_count = 1;
    m_ori_full_print_config.support_different_extruders(extruder_count);
    std::vector<std::vector<NozzleVolumeType>> nozzle_volume_types;
    extruder_volume_type_count = m_ori_full_print_config.get_extruder_nozzle_volume_count(extruder_count, nozzle_volume_types);
 
    // Note: filament_map_2 keeps its apply-time (static) derivation here; the per-slot machine
    // indices below key the override merge instead, so nothing on this path reads it. Its other
    // consumers are the three-map write-back (which recomputes it) and the diagnostic copy in
    // the g-code header; the time estimator resolves per-(extruder x volume-type) machine limits
    // from the live nozzle occupancy instead (see GCodeProcessor::get_machine_config_idx).
    m_full_print_config = m_ori_full_print_config;
    std::set<std::string> filament_keys = filament_options_with_variant;
    filament_keys.insert("filament_self_index");
    std::vector<int> slot_machine_indices;
    m_full_print_config.update_filament_config_values_for_multiple_extruders(m_full_print_config, filament_variant_uses,
                                                                             extruder_count, extruder_volume_type_count,
                                                                             filament_keys, "filament_self_index", "filament_extruder_variant",
                                                                             &slot_machine_indices);
 
    const std::vector<std::string> &extruder_retract_keys = print_config_def.extruder_retract_keys();
    const std::string               filament_prefix       = "filament_";
    t_config_option_keys            print_diff;
    DynamicPrintConfig              filament_overrides;
    for (auto& opt_key: extruder_retract_keys)
    {
        const ConfigOption *opt_new_filament = m_full_print_config.option(filament_prefix + opt_key);
        const ConfigOption *opt_new_machine = m_full_print_config.option(opt_key);
        const ConfigOption *opt_old_machine = m_config.option(opt_key);
 
        if (opt_new_filament)
            compute_filament_override_value(opt_key, opt_old_machine, opt_new_machine, opt_new_filament, m_full_print_config, print_diff, filament_overrides, slot_machine_indices);
    }
 
    {
        t_config_option_keys keys(filament_options_with_variant.begin(), filament_options_with_variant.end());
        keys.push_back("filament_self_index");
        m_config.apply_only(m_full_print_config, keys, true);
    }
    if (!print_diff.empty()) {
        m_placeholder_parser.apply_config(filament_overrides);
        m_config.apply(filament_overrides);
    }
 
    update_filament_self_index_cache();
    m_has_auto_filament_map_result = true;
}

References collect_filament_variant_uses(), Slic3r::compute_filament_override_value(), Slic3r::filament_options_with_variant, Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_extruder_map(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzle_map(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_filaments(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_volume_map(), Slic3r::MultiNozzleUtils::NozzleGroupResultBase::is_support_dynamic_nozzle_map(), m_config, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_full_print_config, m_has_auto_filament_map_result, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_ori_full_print_config, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_placeholder_parser, Slic3r::nvtStandard, Slic3r::print_config_def, update_filament_maps_to_config(), update_filament_self_index_cache(), update_to_config_by_nozzle_group_result(), and Slic3r::FilamentGroupUtils::update_used_filament_values().

Referenced by update_to_config_by_nozzle_group_result().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate()

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

overridevirtual

Reimplemented from Slic3r::PrintBase.

{
    auto add_warning = [warnings](StringObjectException w) {
        w.is_warning = true;
        if (warnings != nullptr)
            warnings->push_back(std::move(w));
    };
    auto warn = [&](std::string msg, std::string opt_key = "", const ObjectBase* object = nullptr) {
        StringObjectException w;
        w.string  = std::move(msg);
        w.opt_key = std::move(opt_key);
        w.object  = object;
        add_warning(std::move(w));
    };
 
    std::vector<unsigned int> extruders = this->extruders();
    unsigned int nozzles = m_config.nozzle_diameter.size();
 
    if (m_objects.empty())
        return {std::string()};
 
    if (extruders.empty())
        return { L("No extrusions under current settings.") };
 
    // A flow ratio of 0 would extrude nothing, and a nil one would write NaN extrusion lengths.
    {
        const std::vector<double> &flow_ratios = m_config.filament_flow_ratio.values;
        const std::vector<int>    &self_index  = m_config.filament_self_index.values;
        for (size_t column = 0; column < flow_ratios.size(); ++column) {
            // filament_self_index maps a column to its filament once the filament arrays hold one column per variant
            const unsigned int filament_id = self_index.size() == flow_ratios.size() ? self_index[column] - 1 : column;
            if (flow_ratios[column] > 0. || !std::binary_search(extruders.begin(), extruders.end(), filament_id))
                continue;
            StringObjectException err;
            // TRN %1% is the filament number as shown in the filament list, starting from 1.
            err.string  = Slic3r::format(L("The flow ratio of filament %1% must be greater than 0."), filament_id + 1);
            err.opt_key = "filament_flow_ratio";
            return err;
        }
    }
 
    // IDEX/IQEX: block multi-color in non-primary parallel modes when the active
    // configuration can't physically support it (no within-gantry toolchange path
    // or MMU lane sharing). See imex_multicolor_block_reason() for the full rule.
    // Both IMEX checks below need the active mode's tools string and its declared primary,
    // so imex_resolve_routing() derives them once for the whole block -- and is the same call
    // the plater's pre-slice warning makes, so the two cannot describe the plate differently.
    // Note this block is NOT gated on extruders.size() > 1: the primary
    // routing check applies to a single-filament plate too, which is its most common case.
    if (m_config.is_imex.value && !m_objects.empty()) {
        const std::string& parallel_mode = m_objects.front()->config().imex_parallel_mode.value;
        if (!parallel_mode.empty() && parallel_mode != kImexPrimaryMode) {
            // Tool changes added from the layer slider switch heads mid-print as a painted color
            // does, so they count here, as the plate's warning badge counts them.
            const std::vector<unsigned int> imex_extruders = this->extruders(/*conside_custom_gcode=*/true);
            std::vector<int> used_filaments_0b;
            std::vector<int> used_slots_1b;
            used_filaments_0b.reserve(imex_extruders.size());
            used_slots_1b.reserve(imex_extruders.size());
            for (unsigned int e : imex_extruders) {
                used_filaments_0b.push_back((int)e);
                used_slots_1b.push_back((int)e + 1);
            }
 
            // The active mode's tools string, its declared primary, and whether this plate's
            // filaments reach that primary are all derived ONCE, here. The plater's pre-slice
            // warning (collect_imex_warnings) makes the identical call, so the sentence it
            // shows before slicing and the refusal below cannot describe the plate
            // differently. An unresolved mode, and a mode the tools array is too short to
            // cover, both yield an empty roster and no primary.
            const ImexRouting routing = imex_resolve_routing(m_config, parallel_mode, used_slots_1b,
                                                             m_config.physical_extruder_map);
 
            // A mixed filament is blended at the nozzle by its component toolheads, and a
            // parallel mode is already using those toolheads to print copies or mirrors, so
            // the two cannot run at once -- regardless of where the components are routed.
            //
            // Runs before BOTH rules below. Against the routing rule it would otherwise be
            // reported as merely unrouted: mixed slots are kept at the tail of the filament
            // arrays, past the physical filament count, so on a printer whose logical extruder
            // count equals that count they fall outside physical_extruder_map and resolve to no
            // head. Against the multi-color rule, a mixed slot plus any second filament trips
            // the >1 gate and earns a lecture about gantry topology the user never configured.
            // Being unsupported outright, this dominates both.
            {
                const auto& is_mixed = m_config.filament_is_mixed.values;
                if (std::any_of(used_filaments_0b.begin(), used_filaments_0b.end(),
                                [&](int slot) { return slot >= 0 && slot < (int) is_mixed.size() && is_mixed[slot]; })) {
                    StringObjectException err;
                    // "Mixed filament" is the term the rest of the UI uses -- the button that
                    // creates one, and the sibling refusal for the wipe tower filament.
                    err.string = L("Mixed filaments are not supported in IDEX/IQEX parallel modes. "
                                   "Switch this plate to Primary mode.");
                    err.object = m_objects.front();
                    return err;
                }
            }
 
            // Multi-color has the more specific rule and its remedies are self-contained
            // (an MMU manifold sharing one head cannot be fixed by switching mode), so it runs
            // ahead of the routing block below, which would otherwise mask it with advice that
            // leads to this error on the next slice. validate() returns on the first error.
            if (used_filaments_0b.size() > 1) {
                const std::string reason = imex_multicolor_block_reason(
                    parallel_mode,
                    routing.active_tools,
                    m_config.imex_tools_per_gantry.value,
                    used_filaments_0b,
                    m_config.physical_extruder_map);
                if (!reason.empty())
                    return { reason };
            }
 
            // The IMEX Primary tool prints the sliced paths directly, so it can only use a
            // filament the printer's physical_extruder_map routes to it. The ghost filament
            // picker already enforces this for the secondary tools; the primary's filament
            // comes from the ordinary object filament selector, which has no IMEX awareness,
            // so nothing detected the mismatch. collect_imex_warnings() reads the SAME
            // routing.primary_logical off the same derivation, and discards it into a display
            // fallback so its warning still has a filament to name.
            //
            // Blocks rather than warns, matching the multi-color rule above -- but on intent,
            // not on physics, and the distinction matters to anyone tempted to relax it. The
            // emitter does not use the declared primary: it re-derives an effective one from
            // the filament actually in use (GCode.cpp's initial_extruder_id -> pem lookups), so
            // a plate whose only filament sits on a Span tool sharing the primary's gantry does
            // produce coherent G-code. It is refused anyway. A parallel mode exists to run
            // carriages in parallel; a single-colour plate riding one span lane is not that, and
            // silently accepting it would make the mode's declared roster meaningless.
            //
            // Where the routed head is absent from the mode's active tools the plate is broken
            // outright, not merely off-intent: the 1st->2nd layer temperature
            // branch (GCode.cpp, mutually exclusive with the standard path) skips it too, so
            // that head holds nozzle_temperature_initial_layer for the whole job. First-layer
            // temperatures are unaffected -- _print_first_layer_extruder_temperatures is not
            // IMEX-branched -- so this is a stuck-hot nozzle, not a cold one.
            //
            // `primary_unrouted` is the whole condition: a declared primary, a populated
            // routing map, and nothing used reaching it. Blended slots would also read as
            // unrouted -- they sit past the map by construction -- but they never get here,
            // the mixed-filament rule above returns first.
            if (routing.primary_unrouted) {
                std::string routed_list;
                for (int head : routing.routed_heads)
                    routed_list += (routed_list.empty() ? "T" : ", T") + std::to_string(head);
                // Print::apply() normalises physical_extruder_map through
                // effective_physical_extruder_map (PrintApply.cpp) before validate() runs, so
                // an unauthored map arrives here as the identity and every slot is in range.
                // What is left is a printer with more filaments than logical extruders, where
                // the tail slots fall outside the map. Narrow, but without this the sentence
                // ends in a dangling "on .".
                StringObjectException err;
                if (routed_list.empty())
                    err.string = Slic3r::format(
                        // TRN %1% is the IDEX/IQEX mode name, %2% the tool number.
                        L("IDEX/IQEX mode \"%1%\" prints with T%2%, but none of this plate's filaments are on a configured tool. "
                          "Assign a filament loaded on T%2%, or switch this plate to Primary mode."),
                        parallel_mode, routing.primary_phys);
                else
                    err.string = Slic3r::format(
                        // TRN %1% is the IDEX/IQEX mode name, %2% the tool number, %3% a list of tools such as "T1, T2".
                        L("IDEX/IQEX mode \"%1%\" prints with T%2%, but this plate's filaments are on %3%. "
                          "Assign a filament loaded on T%2%, or switch this plate to Primary mode."),
                        parallel_mode, routing.primary_phys, routed_list);
                // Gives the notification a "Jump to <object>" link, which selects the object
                // and switches to Prepare -- directly enabling the first suggested remedy.
                err.object = m_objects.front();
                return err;
            }
        }
    }
 
    // Belt printer validation: incompatible features.
    if (m_config.belt_printer.value) {
        for (const PrintObject *object : m_objects) {
            if (object->config().raft_layers > 0)
                return { L("Raft is not compatible with belt printer mode.") };
        }
        if (m_config.draft_shield != dsDisabled)
            return { L("Draft shield is not compatible with belt printer mode.") };
 
        // Belt brim spans many layers and owns the layers below the object, which
        // spiral vase cannot share. The prime tower setting is no obstacle: belt
        // printers never print the classic tower, and the belt purge prism is an
        // ordinary object that never takes a brim.
        if (this->has_belt_brim()) {
            if (m_config.spiral_mode.value)
                return { L("Brim is not compatible with spiral vase mode on a belt printer. "
                           "Disable one of them.") };
        }
 
        for (const PrintObject *object : m_objects) {
            const PrintObjectConfig &ocfg = object->config();
            // Mirror PrintObject::has_belt_brim(): an inner-only brim needs a positive
            // brim_width (leading/extra widen only the outer ring), so keep this
            // predicate in step or the belt-brim warnings below would fire for a brim
            // that has_belt_brim() rejects.
            const bool wants_brim = ocfg.brim_type != btNoBrim
                                 && (ocfg.brim_type == btInnerOnly
                                         ? ocfg.brim_width.value > 0.
                                         : (ocfg.brim_width.value > 0. || ocfg.leading_brim_length.value > 0.
                                            || ocfg.extra_brim_width.value > 0.));
            if (! wants_brim)
                continue;
 
            if (! this->has_tilted_belt()) {
                if (std::abs(m_config.belt_slice_rotation_angle.value) > BELT_BRIM_MAX_TILT_DEG)
                    warn(L("The belt is too steep for a brim, so no brim will be generated."),
                         "brim_width", object->model_object());
                else
                    warn(L("A brim is only generated when the belt is tilted. Set a belt tilt angle, "
                           "or remove the brim setting."),
                         "brim_type", object->model_object());
            }
 
            if (ocfg.brim_type == btAutoBrim || ocfg.brim_type == btEar || ocfg.brim_type == btPainted)
                warn(L("Belt printers support outer and inner brim only. Auto, Mouse ear and Painted "
                       "brim are printed as Outer brim only, using Brim width."),
                     "brim_type", object->model_object());
 
            if (ocfg.leading_brim_length.value > 0. && ocfg.brim_object_gap.value > 0.)
                warn(L("Brim-object gap separates the leading brim from the object's leading edge, "
                       "which is the edge it is meant to anchor. Set the gap to 0 when using leading "
                       "brim length."),
                     "brim_object_gap", object->model_object());
        }
        if (this->has_belt_brim() && m_objects.size() > 1)
            warn(L("Leading brim length extends ahead of each object along the belt, and Arrange does "
                   "not reserve that space. Leave room between objects."),
                 "leading_brim_length");
    } else {
        // "Leading edge only" describes where a part meets a moving belt, so it has no
        // meaning on a fixed bed.  Brim.cpp prints it as an ordinary outer brim rather
        // than silently producing nothing; say so.
        for (const PrintObject *object : m_objects)
            if (object->config().brim_type == btLeadingEdgeOnly)
                warn(L("\"Leading edge only\" brim applies to belt printers. On this printer it is "
                       "printed as an ordinary outer brim."),
                     "brim_type", object->model_object());
    }
 
    // Orca: a gradient mixed filament only renders its gradient with "Mixed color sublayer" on;
    // without it ToolOrdering::resolve_mixed_filaments prints one whole component per layer and
    // the gradient is dropped silently. extruders() already covers painting, height ranges,
    // per-feature filament ids and supports, and still lists mixed slots under their own id here.
    if (!m_config.enable_mixed_color_sublayer.value) {
        const auto &is_mixed = m_config.filament_is_mixed.values;
        const auto &gradient = m_config.filament_mixed_gradient.values;
        if (std::any_of(extruders.begin(), extruders.end(), [&](unsigned int e) {
                return e < is_mixed.size() && is_mixed[e] && e < gradient.size() && gradient[e]; }))
            warn(L("A gradient mixed filament is used, but 'Mixed color sublayer' is disabled. The gradient will not be printed."),
                 "enable_mixed_color_sublayer");
    }
 
    if (nozzles < 2 && extruders.size() > 1) {
        auto ret = check_multi_filament_valid(*this);
        if (!ret.string.empty())
        {
            ret.type = STRING_EXCEPT_FILAMENTS_DIFFERENT_TEMP;
            if (ret.is_warning) {
                add_warning(ret);
            }else
                return ret;
        }
    }
 
    if (m_config.print_sequence == PrintSequence::ByObject && (m_objects.size() > 1 || m_objects[0]->instances().size() > 1)) {
        if (m_config.timelapse_type == TimelapseType::tlSmooth)
            return {L("Smooth mode of timelapse is not supported when \"by object\" sequence is enabled.")};
 
        if (m_config.enable_wrapping_detection) {
            StringObjectException clumping_detection_setting_err;
            clumping_detection_setting_err.string = L("Clumping detection is not supported when \"by object\" sequence is enabled.");
            clumping_detection_setting_err.opt_key = "enable_wrapping_detection";
            return clumping_detection_setting_err;
        }
 
        //BBS: refine seq-print validation logic
        auto ret = sequential_print_clearance_valid(*this, collison_polygons, height_polygons);
        if (!ret.string.empty()) {
            ret.type = STRING_EXCEPT_OBJECT_COLLISION_IN_SEQ_PRINT;
            return ret;
        }
    }
    else {
        //BBS
        StringObjectException layer_warning;
        auto ret = layered_print_cleareance_valid(*this, &layer_warning);
        if (!ret.string.empty()) {
            ret.type = STRING_EXCEPT_OBJECT_COLLISION_IN_LAYER_PRINT;
            return ret;
        }
        if (!layer_warning.string.empty())
            add_warning(layer_warning);
 
        // Orca: a compacted prime tower drags the nozzle back down to the plate on every toolchange, so
        // tall objects collide with it much like they do in sequential printing. Checking it here rather
        // than only during slicing is what lets the plater show the collision area and the height limit
        // while the plate is still being arranged.
        ret = compacted_wipe_tower_clearance_valid(*this, collison_polygons, height_polygons);
        if (!ret.string.empty()) {
            ret.type = STRING_EXCEPT_OBJECT_COLLISION_IN_LAYER_PRINT;
            return ret;
        }
    }
 
    if (m_config.belt_printer.value && m_config.enable_belt_purge_tower.value
        && m_config.print_sequence == PrintSequence::ByObject
        && extruders.size() > 1) {
        StringObjectException warningtemp;
        warningtemp.string     = L("The belt purge tower is not generated in \"By object\" print sequence; "
                                   "filament changes will not be purged.");
        warningtemp.opt_key    = "enable_belt_purge_tower";
        warningtemp.is_warning = true;
        add_warning(warningtemp);
    }
 
    // The purge tower is a model object the GUI creates and sizes; libslic3r only purges
    // into one that exists. A project sliced without it (the CLI on a project saved before
    // the tower was generated) changes filament with nowhere to purge.
    if (m_config.belt_printer.value && m_config.enable_belt_purge_tower.value
        && m_config.print_sequence != PrintSequence::ByObject
        && ! m_config.spiral_mode.value && this->object_extruders().size() > 1 && ! this->has_belt_purge_tower()) {
        StringObjectException warningtemp;
        warningtemp.string     = L("The belt purge tower is enabled but the project has no purge tower object; "
                                   "filament changes will not be purged. Open the project in the application "
                                   "to generate the tower.");
        warningtemp.opt_key    = "enable_belt_purge_tower";
        warningtemp.is_warning = true;
        add_warning(warningtemp);
    }
 
    if (m_config.belt_printer.value && m_config.enable_belt_purge_tower.value) {
        const size_t prism_count = std::count_if(m_objects.begin(), m_objects.end(), [](const PrintObject *object) {
            return object->config().belt_purge_tower_object.value;
        });
        if (prism_count > 1)
            return {L("The project contains multiple managed belt purge towers. Reload the plate or toggle the belt purge tower off and on to regenerate it.")};
    }
 
    if (m_config.enable_prime_tower) {
        for (const PrintObject* object : m_objects) {
            if (object->config().precise_z_height.value) {
                warn(L("Enabling both precise Z height and the prime tower may cause slicing errors."), "precise_z_height");
                break;
            }
        }
    } else {
        if (m_config.enable_wrapping_detection)
            warn(L("A prime tower is required for clumping detection; otherwise, there may be flaws on the model."), "enable_prime_tower");
    }
 
    if (m_config.spiral_mode) {
        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.print_sequence != PrintSequence::ByObject)
            return {L("Please select \"By object\" print sequence to print multiple objects in spiral vase mode."), nullptr, "spiral_mode"};
        // A mixed (virtual) filament always resolves to multiple physical components, which
        // spiral vase cannot print.
        const auto &is_mixed = m_config.filament_is_mixed.values;
        for (const PrintObject *object : m_objects)
            for (unsigned int ext : object->object_extruders())
                if (ext < is_mixed.size() && is_mixed[ext])
                    return {L("Spiral (vase) mode does not work when an object contains more than one material."), nullptr, "spiral_mode"};
        assert(m_objects.size() == 1);
        const auto all_regions = m_objects.front()->all_regions();
        if (all_regions.size() > 1) {
            // Orca: make sure regions are not compatible
            if (std::any_of(all_regions.begin() + 1, all_regions.end(), [this, ra = all_regions.front()](const auto rb) {
                return !Layer::is_perimeter_compatible(*this, ra, rb);
            })) {
                return {L("Spiral (vase) mode does not work when an object contains more than one material."), nullptr, "spiral_mode"};
            }
        }
    }
 
    // 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 belt printers the slicing-frame Z spans the sheared X-length and
    // is not comparable to printable_height (which is gantry clearance in the
    // build-volume frame).  Compare against the model's pre-shear Z instead,
    // mirroring the bbox computed in PrintObject::update_slicing_parameters.
    // The machine-frame transform only changes how that height is written to
    // G-code, not how much room there is under the gantry.
    const bool belt_printer = this->config().belt_printer.value;
    const double shrinkage_compensation_z = this->shrinkage_compensation().z();
    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];
 
        double effective_max_z       = 0;
        bool   last_layer_below_max  = false;
        bool   have_height           = false;
 
        if (belt_printer) {
            const double raw_z = print_object.model_object()->max_z();
            effective_max_z = raw_z;
            have_height     = raw_z > 0;
        } else {
            //FIXME It is quite expensive to generate object layers just to get the print height!
            auto layers = generate_object_layers(print_object.slicing_parameters(), layer_height_profile(print_object_idx), print_object.config().precise_z_height.value);
            if (!layers.empty()) {
                // The object layers start above the raft.
                const double raft_z  = print_object.slicing_parameters().object_print_z_min;
                effective_max_z      = raft_z + layers.back();
                last_layer_below_max = layers.size() >= 2 &&
                    raft_z + 0.5 * (layers[layers.size() - 2] + layers.back()) <= this->config().printable_height + EPSILON;
                have_height          = true;
            }
        }
 
        if (!have_height)
            continue;
 
        // The layers of a regular printer already carry the Z shrinkage compensation, the belt height does not.
        const double compensated_max_z   = belt_printer ? effective_max_z * shrinkage_compensation_z : effective_max_z;
        const double uncompensated_max_z = belt_printer ? effective_max_z : print_object.slicing_parameters().object_print_z_uncompensated_max;
        if (shrinkage_compensation_z != 1. && compensated_max_z > this->config().printable_height + EPSILON &&
            uncompensated_max_z <= this->config().printable_height + EPSILON) {
            // The object exceeds the maximum build volume height because of shrinkage compensation.
            return StringObjectException{
                Slic3r::format(_u8L("While the object %1% itself fits the build volume, it exceeds the maximum build volume height because of material shrinkage compensation."), print_object.model_object()->name),
                print_object.model_object(),
                ""
            };
        } else if (effective_max_z > this->config().printable_height + EPSILON) {
            return StringObjectException{
                last_layer_below_max ?
                Slic3r::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.") :
                Slic3r::format(_u8L("The object %1% exceeds the maximum build volume height."), print_object.model_object()->name),
                print_object.model_object(),
                ""
            };
        }
    }
 
    // 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() && is_tree(print_object.config().support_type.value) && (print_object.config().support_style.value == smsTreeOrganic || 
                // Orca: use organic as default
                print_object.config().support_style.value == smsDefault) &&
            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() || this->has_belt_purge_tower()) && ! m_objects.empty()) {
        // Orca: wipe_tower_filament (issue #10971) is inserted into the tool order after
        // resolve_mixed_filaments has expanded every mixed (virtual) slot, so a mixed slot here
        // would reach the G-code as a tool change to a slot no nozzle carries. The GUI hides
        // mixed slots from the option; this guards loaded projects and the CLI.
        if (this->has_wipe_tower() && m_config.wipe_tower_filament > 0) {
            const auto  &is_mixed = m_config.filament_is_mixed.values;
            const size_t wipe_idx = size_t(m_config.wipe_tower_filament - 1);
            if (wipe_idx < is_mixed.size() && is_mixed[wipe_idx])
                return { L("The wipe tower filament cannot be a mixed filament."), nullptr, "wipe_tower_filament" };
        }
 
        // 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 { L("Different nozzle diameters and different filament diameters may not work well when prime tower is enabled. It's very experimental, please proceed with caucious.") };
                    warn(L("Different nozzle diameters and different filament diameters may not work well when the prime tower is enabled. It's very experimental, so please proceed with caution."), "nozzle_diameter");
                    break;
                }
        }
 
        // The following two constraints come from the classic wipe tower G-code
        // generator; purging into the belt purge prism uses normal object
        // extrusions and does not need them.
        if (this->has_wipe_tower()) {
            if (! m_config.use_relative_e_distances)
                return { L("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 {L("Ooze prevention is only supported with the wipe tower when 'single_extruder_multi_material' is off.")};
        }
 
#if 0
        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)
            return { L("The prime tower is currently only supported for the Marlin, RepRap/Sprinter, RepRapFirmware and Repetier G-code flavors.")};
 
        if ((m_config.print_sequence == PrintSequence::ByObject) && extruders.size() > 1)
            return { L("A prime tower is not supported in \u201cBy object\u201d print."), nullptr, "enable_prime_tower" };
 
        // BBS: When prime tower is on, object layer and support layer must be aligned. So support gap should be multiple of object layer height.
        for (size_t i = 0; i < m_objects.size(); i++) {
            const PrintObject* object = m_objects[i];
            const SlicingParameters& slicing_params = object->slicing_parameters();
            if (object->config().adaptive_layer_height) {
                return  { L("A prime tower is not supported when adaptive layer height is on. It requires that all objects have the same layer height."), object, "adaptive_layer_height" };
            }
 
            if (!object->config().enable_support)
                continue;
 
            double gap_layers = slicing_params.gap_object_support / slicing_params.layer_height;
            if (gap_layers - (int)gap_layers > EPSILON) {
                return {L("A prime tower requires any \u201csupport gap\u201d to be a multiple of layer height."), object};
            }
        }
#endif
 
        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 {L("A prime tower requires that all objects have the same layer height."), object, "initial_layer_print_height"};
                if (slicing_params.raft_layers() != slicing_params0.raft_layers())
                    return {L("A prime tower requires that all objects are printed over the same number of raft layers."), object, "raft_layers"};
                // BBS: support gap can be multiple of object layer height, remove _L()
#if 0
                if (slicing_params0.gap_object_support != slicing_params.gap_object_support ||
                    slicing_params0.gap_support_object != slicing_params.gap_support_object)
                    return {L("The prime tower is only supported for multiple objects if they are printed with the same support_top_z_distance."), object};
#endif
                if (!equal_layering(slicing_params, slicing_params0))
                    return  { L("A prime tower requires that all objects are sliced with the same layer height."), object };
                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;
                }
            }
 
            // BBS: remove obsolete logics and _L()
            if (has_custom_layering) {
                std::vector<std::vector<coordf_t>> layer_z_series;
                layer_z_series.assign(m_objects.size(), std::vector<coordf_t>());
               
                for (size_t idx_object = 0; idx_object < m_objects.size(); ++idx_object) {
                    layer_z_series[idx_object] = generate_object_layers(m_objects[idx_object]->slicing_parameters(), layer_height_profiles[idx_object], m_objects[idx_object]->config().precise_z_height.value);
                }
 
                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()) {
                        // BBS: remove the break condition, because a variable layer height object and a new object will not be checked when slicing
                        //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 {L("The prime 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);
    }
 
        // BBS: remove L()
#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 {L("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 {
            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);
            if (extrusion_width_min == 0) {
                // Default "auto-generated" extrusion width is always valid.
            } else if (extrusion_width_min <= layer_height) {
                    err_msg = L("Line width too small");
                    return false;
                } else if (extrusion_width_max > max_nozzle_diameter * MAX_LINE_WIDTH_MULTIPLIER) {
                err_msg = L("Line width too large");
        return false;
      }
      return true;
    };
        for (PrintObject *object : m_objects) {
            if (object->has_support_material()) {
                // BBS: remove useless logics and L()
#if 0
        if ((object->config().support_filament == 0 || object->config().support_interface_filament == 0) && max_nozzle_diameter - min_nozzle_diameter > EPSILON) {
                    // The object has some form of support and either support_filament or support_interface_filament
                    // 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 {L("Printing with multiple extruders of differing nozzle diameters. "
                           "If support is to be printed with the current filament (support_filament == 0 or support_interface_filament == 0), "
                           "all nozzles have to be of the same diameter."), object, "support_filament"};
                }
#endif
 
                // BBS
#if 0
                if (this->has_wipe_tower() && object->config().independent_support_layer_height) {
                    return {L("A prime tower requires that support has the same layer height as the object."), object, "support_filament"};
                }
#endif
 
                // Prusa: Fixing crashes with invalid tip diameter or branch diameter
                // https://github.com/prusa3d/PrusaSlicer/commit/96b3ae85013ac363cd1c3e98ec6b7938aeacf46d
                if (is_tree(object->config().support_type.value)) {
                    if (object->config().support_style == smsTreeOrganic ||
                        // Orca: use organic as default
                        object->config().support_style == smsDefault) {
 
                        // Orca: check the support wall count and the base pattern
                        if (object->config().tree_support_wall_count > 1 &&
                            object->config().support_base_pattern != SupportMaterialPattern::smpNone &&
                            object->config().support_base_pattern != SupportMaterialPattern::smpDefault)
                            warn(L("For Organic supports, two walls are supported only with the Hollow/Default base pattern."), "support_base_pattern");
 
                        // Orca: check if the Lightning base pattern selected
                        if (object->config().support_base_pattern == SupportMaterialPattern::smpLightning)
                            warn(L("The Lightning base pattern is not supported by this support type; Rectilinear will be used instead."), "support_base_pattern");
 
                        float extrusion_width = std::min(
                            support_material_flow(object).width(),
                            support_material_interface_flow(object).width());
                        if (object->config().tree_support_tip_diameter < extrusion_width - EPSILON)
                            return { L("Organic support tree tip diameter must not be smaller than support material extrusion width."), object, "tree_support_tip_diameter" };
                        if (object->config().tree_support_branch_diameter_organic < 2. * extrusion_width - EPSILON)
                            return { L("Organic support branch diameter must not be smaller than 2x support material extrusion width."), object, "tree_support_branch_diameter_organic" };
                        if (object->config().tree_support_branch_diameter_organic < object->config().tree_support_tip_diameter)
                            return { L("Organic support branch diameter must not be smaller than support tree tip diameter."), object, "tree_support_branch_diameter_organic" };
                    }
                } else if (object->config().support_base_pattern == SupportMaterialPattern::smpLightning) {
                    // Orca: check if the Lightning base pattern selected
                    warn(L("The Lightning base pattern is not supported by this support type; Rectilinear will be used instead."), "support_base_pattern");
                } else if (object->config().support_base_pattern == SupportMaterialPattern::smpNone) {
                    // Orca: check if the Hollow base pattern selected
                    warn(L("The Hollow base pattern is not supported by this support type; Rectilinear will be used instead."), "support_base_pattern");
                }
            }
 
            // Do we have custom support data that would not be used?
            // Notify the user in that case.
            if (! object->has_support()) {
                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) {
                        warn(L("Support enforcers are used but support is not enabled. Please enable support."), "", object);
                        break;
                    }
                }
            }
 
            double initial_layer_print_height = m_config.initial_layer_print_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_interface_filament-1
                    : object->config().support_filament-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 (initial_layer_print_height > first_layer_min_nozzle_diameter)
                return {L("Layer height cannot exceed nozzle diameter."), object, "initial_layer_print_height"};
 
            // validate layer_height
            double layer_height = object->config().layer_height.value;
            if (layer_height > min_nozzle_diameter)
                return {L("Layer height cannot exceed nozzle diameter."), object, "layer_height"};
 
            // Validate extrusion widths.
            std::string err_msg;
            if (!validate_extrusion_width(object->config(), "line_width", layer_height, err_msg))
              return {err_msg, object, "line_width"};
            if (object->has_support() || object->has_raft()) {
                if (!validate_extrusion_width(object->config(), "support_line_width", layer_height, err_msg))
                    return {err_msg, object, "support_line_width"};
            }
            for (const char *opt_key : { "inner_wall_line_width", "outer_wall_line_width", "sparse_infill_line_width", "internal_solid_infill_line_width", "top_surface_line_width","skin_infill_line_width" ,"skeleton_infill_line_width"})
        for (const PrintRegion &region : object->all_regions())
                    if (!validate_extrusion_width(region.config(), opt_key, layer_height, err_msg))
                  return  {err_msg, object, opt_key};
 
            const bool allow_thin_bridge_width = object->config().thick_bridges && object->config().thick_internal_bridges;
            for (const PrintRegion &region : object->all_regions()) {
                const auto &bridge_width_opt = region.config().bridge_line_width;
                for (FlowRole bridge_role : { frPerimeter, frInfill, frSolidInfill, frTopSolidInfill }) {
                    const double nozzle_diameter = nozzle_diameter_for_filament(m_config, region.extruder(bridge_role), this->is_BBL_printer());
                    const double bridge_width    = bridge_width_opt.get_abs_value(nozzle_diameter);
                    if (bridge_width <= 0.)
                        continue;
                    if (bridge_width > nozzle_diameter) {
                        err_msg = L("Bridge line width must not exceed nozzle diameter");
                        return { err_msg, object, "bridge_line_width" };
                    }
                    if (!allow_thin_bridge_width && bridge_width <= layer_height) {
                        err_msg = L("Line width too small");
                        return { err_msg, object, "bridge_line_width" };
                    }
                }
            }
        }
    }
 
    // Orca: G92 E0 is not supported when using absolute extruder addressing
    // This check is modified from PrusaSlicer, the original author is Vojtech Bubnik
    // Orca: case‑sensitive match for exactly "G92 E0" (uppercase G and E only) 
    // because gcode is case sensitive and G92 e0 satisfies the regex but causes a slicing error
    // https://github.com/OrcaSlicer/OrcaSlicer/issues/13927
 
      // Matches any case of "G92 E0" (original pattern)
    static const boost::regex regex_g92e0 {
        "^[ \\t]*[gG]92[ \\t]*[eE](0(\\.0*)?|\\.0+)[ \\t]*(;.*)?$"
    };
    // Matches only the exact uppercase "G92 E0"
    static const boost::regex regex_g92e0_correct {
        "^[ \\t]*G92[ \\t]*E(0(\\.0*)?|\\.0+)[ \\t]*(;.*)?$"
    };
 
    const bool before_has_g92_any = boost::regex_search(
        m_config.before_layer_change_gcode.value, regex_g92e0);
    const bool layer_has_g92_any  = boost::regex_search(
        m_config.layer_change_gcode.value, regex_g92e0);
 
    if (m_config.use_relative_e_distances) {
        // Relative mode: "G92 E0" is required to reset extruder position.
        const bool before_has_g92_exact = boost::regex_search(
            m_config.before_layer_change_gcode.value, regex_g92e0_correct);
        const bool layer_has_g92_exact  = boost::regex_search(
            m_config.layer_change_gcode.value, regex_g92e0_correct);
 
        // Wrong case found?
        if (before_has_g92_any && !before_has_g92_exact)
            return {L("\"G92 E0\" was found in before_layer_change_gcode, but the G or E are not uppercase. "
                      "Please change them to the exact uppercase \"G92 E0\"."),
                    nullptr, "before_layer_change_gcode"};
        if (layer_has_g92_any && !layer_has_g92_exact)
            return {L("\"G92 E0\" was found in layer_change_gcode, but the G or E are not uppercase. "
                      "Please change them to the exact uppercase \"G92 E0\"."),
                    nullptr, "layer_change_gcode"};
 
        // Only Marlin flavours need the reset; BBL printers do not.
        if ((m_config.gcode_flavor == gcfMarlinLegacy || m_config.gcode_flavor == gcfMarlinFirmware) &&
            !is_BBL_printer() &&
            !before_has_g92_exact && !layer_has_g92_exact)
            return {L("Relative extruder addressing requires resetting the extruder position at each layer to "
                      "prevent loss of floating point accuracy. Add \"G92 E0\" to layer_gcode."),
                    nullptr, "before_layer_change_gcode"};
    } else {
        // Absolute mode: any occurrence of "G92 E0" is incompatible.
        if (before_has_g92_any)
            return {L("\"G92 E0\" was found in before_layer_change_gcode, which is incompatible with absolute extruder "
                      "addressing."),
                    nullptr, "before_layer_change_gcode"};
        if (layer_has_g92_any)
            return {L("\"G92 E0\" was found in layer_change_gcode, which is incompatible with absolute extruder "
                      "addressing."),
                    nullptr, "layer_change_gcode"};
  }
 
    const ConfigOptionDef* bed_type_def = print_config_def.get("curr_bed_type");
    assert(bed_type_def != nullptr);
 
    // ORCA: check if bed type is compatible with all selected filaments
    if (is_BBL_printer() || m_config.support_multi_bed_types.value) {
      const t_config_enum_values* bed_type_keys_map = bed_type_def->enum_keys_map;
      for (unsigned int extruder_id : extruders) {
          const ConfigOptionInts* bed_temp_opt = m_config.option<ConfigOptionInts>(get_bed_temp_key(m_config.curr_bed_type));
          for (unsigned int extruder_id : extruders) {
              int curr_bed_temp = bed_temp_opt->get_at(extruder_id);
              if (curr_bed_temp == 0 && bed_type_keys_map != nullptr) {
                  std::string bed_type_name;
                  for (auto item : *bed_type_keys_map) {
                      if (item.second == m_config.curr_bed_type) {
                          bed_type_name = item.first;
                          break;
                      }
                  }
 
                  StringObjectException except;
                  except.string = Slic3r::format(L("Plate %d: %s does not support filament %s"), this->get_plate_index() + 1, L(bed_type_name), extruder_id + 1);
                  except.string += "\n";
                  except.type   = STRING_EXCEPT_FILAMENT_NOT_MATCH_BED_TYPE;
                  except.params.push_back(std::to_string(this->get_plate_index() + 1));
                  except.params.push_back(L(bed_type_name));
                  except.params.push_back(std::to_string(extruder_id+1));
                  except.object = nullptr;
                  return except;
             }
            }
        }
    }
 
    // check if print speed/accel/jerk is higher than the maximum speed of the printer
    if (warnings) {
        // The motion-ability checks are mutually exclusive (gated on warning_key), so collect the
        // single one that fires into a local and push it once - separate from the precise-wall and
        // shrinkage warnings below.
        StringObjectException motion_warning;
        try {
            auto check_extruder = [&](const int extruder_id) {
                auto check_motion_ability_object_setting = [&](const std::vector<std::string>& keys_to_check, double limit) -> std::string {
                    std::string warning_key;
                    for (const auto& key : keys_to_check) {
                        if (m_default_object_config.get_abs_value_at(key, extruder_id) > limit) {
                            warning_key = key;
                            break;
                        }
                    }
                    return warning_key;
                };
                auto check_motion_ability_region_setting = [&](const std::vector<std::string>& keys_to_check, double limit) -> std::string {
                    std::string warning_key;
                    for (const auto& key : keys_to_check) {
                        if (m_default_region_config.get_abs_value_at(key, extruder_id) > limit) {
                            warning_key = key;
                            break;
                        }
                    }
                    return warning_key;
                };
                std::string warning_key;
 
                const auto max_junction_deviation = m_config.machine_max_junction_deviation.values[0]; // TODO: fix this
                const bool ignore_jerk_validation = m_config.gcode_flavor == gcfMarlinFirmware && max_junction_deviation > 0;
 
                // check jerk
                if (!ignore_jerk_validation) {
                    if (m_default_object_config.default_jerk.get_at(extruder_id) == 1 || m_default_object_config.outer_wall_jerk.get_at(extruder_id) == 1 ||
                        m_default_object_config.inner_wall_jerk.get_at(extruder_id) == 1) {
                       motion_warning.string = L("Setting the jerk speed too low could lead to artifacts on curved surfaces");
                       if (m_default_object_config.outer_wall_jerk.get_at(extruder_id) == 1)
                            warning_key = "outer_wall_jerk";
                       else if (m_default_object_config.inner_wall_jerk.get_at(extruder_id) == 1)
                            warning_key = "inner_wall_jerk";
                       else
                            warning_key = "default_jerk";
 
                       motion_warning.opt_key = warning_key;
                    }
 
                    if (warning_key.empty() && m_default_object_config.default_jerk.get_at(extruder_id) > 0) {
                       std::vector<std::string> jerk_to_check = {"default_jerk",     "outer_wall_jerk",    "inner_wall_jerk", "infill_jerk",
                                                                 "top_surface_jerk", "initial_layer_jerk", "travel_jerk"};
                       const auto               max_jerk = std::min(m_config.machine_max_jerk_x.values[0], m_config.machine_max_jerk_y.values[0]);
                       warning_key.clear();
                       warning_key = check_motion_ability_object_setting(jerk_to_check, max_jerk);
                       if (!warning_key.empty()) {
                            motion_warning.string = L(
                                "The jerk setting exceeds the printer's maximum jerk (machine_max_jerk_x/machine_max_jerk_y).\n"
                                "Orca will automatically cap the jerk speed to ensure it doesn't surpass the printer's capabilities.\n"
                                "You can adjust the maximum jerk setting in your printer's configuration to get higher speeds.");
                            motion_warning.opt_key = warning_key;
                       }
                    }
                }
 
                // Check junction deviation
                // Orca: Only marlin FW supports max junction deviation. Dont display warning if firmware is not supporting it.
                const bool support_max_junction_deviation = ( m_config.gcode_flavor == gcfMarlinFirmware);
                if (warning_key.empty() && m_default_object_config.default_junction_deviation.get_at(extruder_id) > max_junction_deviation && support_max_junction_deviation) {
                    motion_warning.string  = L( "Junction deviation setting exceeds the printer's maximum value (machine_max_junction_deviation).\n"
                                          "Orca will automatically cap the junction deviation to ensure it doesn't surpass the printer's capabilities.\n"
                                          "You can adjust the machine_max_junction_deviation value in your printer's configuration to get higher limits.");
                    motion_warning.opt_key = "default_junction_deviation";
                }
                
                // check acceleration
                const auto max_accel = m_config.machine_max_acceleration_extruding.values[0];
                if (warning_key.empty() && m_default_object_config.default_acceleration.get_at(extruder_id) > 0 && max_accel > 0) {
                   const bool support_travel_acc = (m_config.gcode_flavor == gcfRepetier || m_config.gcode_flavor == gcfMarlinFirmware ||
                                                    m_config.gcode_flavor == gcfRepRapFirmware);
 
                   std::vector<std::string> accel_to_check;
                   if (!support_travel_acc)
                        accel_to_check = {
                            "default_acceleration",
                            "inner_wall_acceleration",
                            "outer_wall_acceleration",
                            "bridge_acceleration",
                            "initial_layer_acceleration",
                            "sparse_infill_acceleration",
                            "internal_solid_infill_acceleration",
                            "top_surface_acceleration",
                            "travel_acceleration",
                        };
                   else
                        accel_to_check = {
                            "default_acceleration",
                            "inner_wall_acceleration",
                            "outer_wall_acceleration",
                            "bridge_acceleration",
                            "initial_layer_acceleration",
                            "sparse_infill_acceleration",
                            "internal_solid_infill_acceleration",
                            "top_surface_acceleration",
                        };
                   warning_key = check_motion_ability_object_setting(accel_to_check, max_accel);
                   if (!warning_key.empty()) {
                        motion_warning.string  = L("The acceleration setting exceeds the printer's maximum acceleration "
                                              "(machine_max_acceleration_extruding).\nOrca will "
                                              "automatically cap the acceleration speed to ensure it doesn't surpass the printer's "
                                              "capabilities.\nYou can adjust the "
                                              "machine_max_acceleration_extruding value in your printer's configuration to get higher speeds.");
                        motion_warning.opt_key = warning_key;
                   }
                   if (support_travel_acc) {
                        const auto max_travel = m_config.machine_max_acceleration_travel.values[0];
                        if (max_travel > 0) {
                            accel_to_check = {
                                "travel_acceleration",
                            };
                            warning_key = check_motion_ability_object_setting(accel_to_check, max_travel);
                            if (!warning_key.empty()) {
                                motion_warning.string = L(
                                    "The travel acceleration setting exceeds the printer's maximum travel acceleration "
                                    "(machine_max_acceleration_travel).\nOrca will "
                                    "automatically cap the travel acceleration speed to ensure it doesn't surpass the printer's "
                                    "capabilities.\nYou can adjust the "
                                    "machine_max_acceleration_travel value in your printer's configuration to get higher speeds.");
                                motion_warning.opt_key = warning_key;
                            }
                        }
                   }
                }
 
                // check speed
                // Orca: disable the speed check for now as we don't cap the speed
                // if (warning_key.empty()) {
                //    auto       speed_to_check = {"inner_wall_speed",  "outer_wall_speed", "sparse_infill_speed",   "internal_solid_infill_speed",
                //                                 "top_surface_speed", "bridge_speed",     "internal_bridge_speed", "gap_infill_speed"};
                //    const auto max_speed      = std::min(m_config.machine_max_speed_x.values[0], m_config.machine_max_speed_y.values[0]);
                //    warning_key.clear();
                //    warning_key = check_motion_ability_region_setting(speed_to_check, max_speed);
                //    if (warning_key.empty() && m_config.travel_speed > max_speed)
                //         warning_key = "travel_speed";
                //    if (!warning_key.empty()) {
                //         motion_warning.string = L(
                //             "The speed setting exceeds the printer's maximum speed (machine_max_speed_x/machine_max_speed_y).\nOrca will "
                //             "automatically cap the print speed to ensure it doesn't surpass the printer's capabilities.\nYou can adjust the "
                //             "maximum speed setting in your printer's configuration to get higher speeds.");
                //         motion_warning.opt_key = warning_key;
                //    }
                // }
            };
            check_extruder(0); // TODO: check used extruder variants
 
            // check wall sequence and precise outer wall
            if (m_default_region_config.precise_outer_wall && m_default_region_config.wall_sequence != WallSequence::InnerOuter)
                warn(L("The precise wall option will be ignored for outer-inner or inner-outer-inner wall sequences."), "precise_outer_wall");
 
            // check adaptive pressure advance model of every extruder variant column of the used filaments
            const std::vector<int> &self_index = m_config.filament_self_index.values;
            const size_t pa_columns = std::max(m_config.adaptive_pressure_advance_model.size(), size_t(extruders.back()) + 1);
            for (size_t column = 0; column < pa_columns; ++column) {
                // filament_self_index maps a column to its filament once the filament arrays hold one column per variant
                const unsigned int filament_id = self_index.size() == pa_columns ? self_index[column] - 1 : column;
                if (!std::binary_search(extruders.begin(), extruders.end(), filament_id))
                    continue;
                if (m_config.adaptive_pressure_advance.get_at(column) &&
                    m_config.enable_pressure_advance.get_at(column)) {
 
                    const std::string pa_model = m_config.adaptive_pressure_advance_model.get_at(column);
                    if (!pa_model.empty()) {
                        std::string validation_error = AdaptivePAProcessor::validate_adaptive_pa_model(pa_model);
                        if (!validation_error.empty()) {
                            warn(L("The Adaptive Pressure Advance model for one or more extruders may contain invalid values."),
                                 "adaptive_pressure_advance_model");
                            break;
                        }
                    }
                }
            }
 
        } catch (std::exception& e) {
            BOOST_LOG_TRIVIAL(warning) << "Orca: validate motion ability failed: " << e.what() << std::endl;
        }
        if (!motion_warning.string.empty())
            add_warning(motion_warning);
    }
    if (!this->has_same_shrinkage_compensations())
        warn(L("Filament shrinkage will not be used because filament shrinkage for the used filaments does not match."));
    return {};
}

References _u8L, Slic3r::ImexRouting::active_tools, Slic3r::BELT_BRIM_MAX_TILT_DEG, Slic3r::belt_printer(), Slic3r::btAutoBrim, Slic3r::btEar, Slic3r::btInnerOnly, Slic3r::btLeadingEdgeOnly, Slic3r::btNoBrim, Slic3r::btPainted, Slic3r::ByObject, check_multi_filament_valid(), Slic3r::check_object_layers_fixed(), compacted_wipe_tower_clearance_valid(), config(), Slic3r::PrintObject::config(), Slic3r::dsDisabled, Slic3r::ENFORCER, Slic3r::ConfigOptionDef::enum_keys_map, EPSILON, Slic3r::equal_layering(), extruders(), Slic3r::SlicingParameters::first_print_layer_height, Slic3r::format(), Slic3r::frInfill, Slic3r::frPerimeter, Slic3r::frSolidInfill, Slic3r::frTopSolidInfill, Slic3r::SlicingParameters::gap_object_support, Slic3r::SlicingParameters::gap_support_object, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, Slic3r::generate_object_layers(), Slic3r::ConfigOptionVector< int >::get_at(), Slic3r::get_bed_temp_key(), Slic3r::PrintBaseWithState< PrintStep, psCount >::get_plate_index(), has_belt_brim(), has_belt_purge_tower(), has_same_shrinkage_compensations(), has_tilted_belt(), has_wipe_tower(), Slic3r::imex_multicolor_block_reason(), Slic3r::imex_resolve_routing(), Slic3r::initial_layer_print_height(), Slic3r::InnerOuter, is_BBL_printer(), Slic3r::is_tree(), Slic3r::StringObjectException::is_warning, Slic3r::kImexPrimaryMode, L, Slic3r::layer_height(), Slic3r::SlicingParameters::layer_height, Slic3r::layered_print_cleareance_valid(), m_config, m_default_object_config, m_default_region_config, m_objects, MAX_LINE_WIDTH_MULTIPLIER, Slic3r::ModelObject::max_z(), Slic3r::PrintObjectBase::model_object(), Slic3r::ModelObject::name, Slic3r::nozzle_diameter(), Slic3r::nozzle_diameter_for_filament(), Slic3r::StringObjectException::object, Slic3r::SlicingParameters::object_print_z_min, Slic3r::SlicingParameters::object_print_z_uncompensated_max, Slic3r::StringObjectException::opt_key, Slic3r::StringObjectException::params, Slic3r::ImexRouting::primary_phys, Slic3r::ImexRouting::primary_unrouted, Slic3r::print_config_def, Slic3r::printable_height(), PrintObject, Slic3r::PrintObjectConfig, Slic3r::SlicingParameters::raft_layers(), Slic3r::ImexRouting::routed_heads, sequential_print_clearance_valid(), shrinkage_compensation(), Slic3r::PrintObject::slicing_parameters(), Slic3r::smpDefault, Slic3r::smpLightning, Slic3r::smpNone, Slic3r::smsDefault, Slic3r::smsTreeOrganic, Slic3r::StringObjectException::string, Slic3r::STRING_EXCEPT_FILAMENT_NOT_MATCH_BED_TYPE, Slic3r::STRING_EXCEPT_FILAMENTS_DIFFERENT_TEMP, Slic3r::STRING_EXCEPT_OBJECT_COLLISION_IN_LAYER_PRINT, Slic3r::STRING_EXCEPT_OBJECT_COLLISION_IN_SEQ_PRINT, Slic3r::support_material_flow(), Slic3r::support_material_interface_flow(), Slic3r::tlSmooth, Slic3r::StringObjectException::type, Slic3r::PrintObject::update_layer_height_profile(), and Slic3r::AdaptivePAProcessor::validate_adaptive_pa_model().

Referenced by anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_compacted_wipe_tower_clearance()

void Slic3r::Print::validate_compacted_wipe_tower_clearance ( ) const

{
    // Nothing to check when the tower is not compacted: it then follows the object as usual and the
    // regular by-layer clearance check already covers it. Asking wipe_tower_sparse_layers_skipped()
    // rather than the raw option keeps this from rejecting plates whose tower is in fact full height.
    if (! wipe_tower_sparse_layers_skipped(m_config) || m_config.print_sequence != PrintSequence::ByLayer)
        return;
 
    const std::vector<std::vector<WipeTower::ToolChangeResult>> &tool_changes = m_wipe_tower_data.tool_changes;
    if (tool_changes.empty() || m_objects.empty())
        return;
 
    // Same accumulation the G-code emitter runs, so validation and output cannot disagree.
    const std::vector<float> tower_z = compute_compacted_wipe_tower_z(tool_changes, float(m_config.z_offset.value));
 
    // Wipe tower footprint: build it from the ACTUAL tool-change extrusions rather than the nominal
    // width x depth rectangle returned by first_layer_wipe_tower_corners(). With a rib wall the printed
    // wall bulges past the nominal box and the first-layer brim reaches even further; the nominal box
    // (m_wipe_tower_data.bbx) undercounts that outermost extent by several millimetres, which is
    // exactly the extent that decides how close the sweeping rod comes to a neighbouring object. The
    // extrusion end-points are stored in the wipe-tower local frame, so we map them to the bed frame
    // with the same transform the G-code emitter applies. The two emitters differ in where rib_offset
    // enters: WipeTowerIntegration::append_tcr() (type 1) rotates the point and then adds the offset,
    // append_tcr2() (type 2) adds it before rotating. On a rotated rib-wall tower the two land several
    // millimetres apart, which is exactly the margin this check measures, so follow the emitter in use.
    const Eigen::Rotation2Dd wt_rot(Geometry::deg2rad(m_config.wipe_tower_rotation_angle.value));
    const Vec2d              wt_translate(m_config.wipe_tower_x.get_at(m_plate_index) + m_origin(0),
                                          m_config.wipe_tower_y.get_at(m_plate_index) + m_origin(1));
    const Vec2d              rib_off        = m_wipe_tower_data.rib_offset.cast<double>();
    const bool               rib_off_rotates = this->wipe_tower_type() == WipeTowerType::Type2;
    auto to_bed = [&wt_rot, &wt_translate, &rib_off, rib_off_rotates](const Vec2d &pt) {
        return rib_off_rotates ? Vec2d(wt_rot * (pt + rib_off) + wt_translate) : Vec2d(wt_rot * pt + wt_translate + rib_off);
    };
 
    Points tower_pts;
    for (const std::vector<WipeTower::ToolChangeResult> &layer : tool_changes) {
        if (layer.empty() || wipe_tower_layer_is_sparse(layer))
            continue;
        for (const WipeTower::ToolChangeResult &tcr : layer)
            for (size_t i = 0; i < tcr.extrusions.size(); ++i) {
                // A zero width marks a travel end-point. Keep it only when it opens a real extrusion, so
                // the hull covers the deposited material and nothing else; travels reach a bit further out
                // than the walls do.
                const WipeTower::Extrusion &e = tcr.extrusions[i];
                if (e.width == 0.f && (i + 1 == tcr.extrusions.size() || tcr.extrusions[i + 1].width == 0.f))
                    continue;
                const Vec2d p = to_bed(Vec2d(e.pos.x(), e.pos.y()));
                tower_pts.emplace_back(scale_(p.x()), scale_(p.y()));
            }
    }
    if (tower_pts.empty())
        return;
 
    const CompactedTowerZone zone = compacted_wipe_tower_zone(m_config, Geometry::convex_hull(tower_pts));
    if (zone.empty())
        return;
 
    for (const PrintObject *object : m_objects) {
        const double object_top = unscaled<double>(object->max_z());
        for (const PrintInstance &instance : object->instances()) {
            const Polygon inst_hull = compacted_tower_print_instance_hull(*object, instance);
            if (inst_hull.points.empty())
                continue;
 
            // Report the worst layer rather than the first offending one, it is the one that explains the
            // collision best. The rise has to be known before the clearance: it is what selects the
            // horizontal tier, the nozzle cone being out of the head body's reach.
            double max_rise = 0.;
            for (size_t i = 0; i < tool_changes.size(); ++i) {
                if (tool_changes[i].empty() || wipe_tower_layer_is_sparse(tool_changes[i]))
                    continue;
                // Nothing above the current layer exists yet, so a tall object only counts up to it.
                const double rise = std::min(object_top, double(tool_changes[i].front().print_z)) - tower_z[i];
                if (rise > max_rise)
                    max_rise = rise;
            }
 
            const CompactedTowerClearance clearance = compacted_wipe_tower_clearance(m_config, zone, inst_hull, max_rise);
            if (max_rise <= clearance.allowed_rise + EPSILON)
                continue;
            // Same wording as compacted_wipe_tower_clearance_valid(): height-limit and too-close
            // share one message, since both are layout violations of "No sparse layers".
            throw Slic3r::SlicingError(compacted_wipe_tower_clearance_error());
        }
    }
}

References Slic3r::CompactedTowerClearance::allowed_rise, Slic3r::ByLayer, Slic3r::compacted_tower_print_instance_hull(), Slic3r::compacted_wipe_tower_clearance(), Slic3r::compacted_wipe_tower_clearance_error(), Slic3r::compacted_wipe_tower_zone(), Slic3r::compute_compacted_wipe_tower_z(), Slic3r::Geometry::convex_hull(), Slic3r::Geometry::deg2rad(), Slic3r::CompactedTowerZone::empty(), empty(), EPSILON, m_config, m_objects, m_origin, Slic3r::PrintBaseWithState< PrintStep, psCount >::m_plate_index, m_wipe_tower_data, Slic3r::MultiPoint::points, Slic3r::WipeTower::Extrusion::pos, PrintObject, scale_, Slic3r::Type2, Slic3r::unscaled(), Slic3r::WipeTower::Extrusion::width, Slic3r::wipe_tower_layer_is_sparse(), Slic3r::wipe_tower_sparse_layers_skipped(), and wipe_tower_type().

Here is the call graph for this function:

◆ wipe_tower_data()

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

{
    // Until the tower is generated, size it with the estimate the GUI/CLI placement uses, so
    // validation cannot reject a position the clamp just accepted.
    if (is_step_done(psWipeTower) || filaments_cnt == 0)
        return m_wipe_tower_data;
 
    double max_height   = 0.;
    double layer_height = std::numeric_limits<double>::max();
    for (const PrintObject *object : m_objects) {
        max_height   = std::max(max_height, unscale_(double(object->size().z())));
        layer_height = std::min(layer_height, object->config().layer_height.value);
    }
    if (max_height < EPSILON)
        return m_wipe_tower_data;
 
    const WipeTowerFootprint footprint = estimate_wipe_tower_footprint(m_config, this->wipe_tower_type(), this->extruders(true), layer_height, max_height);
    WipeTowerData &data = const_cast<Print *>(this)->m_wipe_tower_data;
    data.depth      = float(footprint.depth);
    data.width      = float(footprint.width);
    data.brim_width = float(footprint.brim_width);
    return m_wipe_tower_data;
}

References Print(), Slic3r::WipeTowerData::brim_width, Slic3r::WipeTowerFootprint::brim_width, Slic3r::WipeTowerData::depth, Slic3r::WipeTowerFootprint::depth, EPSILON, Slic3r::estimate_wipe_tower_footprint(), extruders(), is_step_done(), Slic3r::layer_height(), m_config, m_objects, m_wipe_tower_data, PrintObject, Slic3r::psWipeTower, unscale_, Slic3r::WipeTowerData::width, Slic3r::WipeTowerFootprint::width, wipe_tower_data(), and wipe_tower_type().

Referenced by Slic3r::GCode::_do_export(), libvgcode::convert(), Slic3r::estimated_wipe_tower_footprint(), Slic3r::get_wipe_tower_extrusions_extents(), Slic3r::get_wipe_tower_priming_extrusions_extents(), Slic3r::layered_print_cleareance_valid(), Slic3r::GCode::process_layer_change_gcode(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance(), and wipe_tower_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wipe_tower_type()

WipeTowerType Slic3r::Print::wipe_tower_type ( ) const

inline

1343{ return is_BBL_printer() ? WipeTowerType::Type1 : m_config.wipe_tower_type.value; }

Slic3r::WipeTowerType::Type1

@ Type1

Definition PrintConfig.hpp:114

References is_BBL_printer(), m_config, and Slic3r::Type1.

Referenced by Slic3r::GCode::_do_export(), _make_wipe_tower(), first_layer_wipe_tower_corners(), Slic3r::layered_print_cleareance_valid(), validate_compacted_wipe_tower_clearance(), and wipe_tower_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GCode

friend class GCode

friend

References GCode.

Referenced by GCode.

◆ PrintObject

Member Data Documentation

◆ m_brimFilamentMap

std::map<ObjectID, unsigned int> Slic3r::Print::m_brimFilamentMap

private

Referenced by _make_skirt().

◆ m_brimMap

std::map<ObjectID, ExtrusionEntityCollection> Slic3r::Print::m_brimMap

private

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

◆ m_brimMapByInstance

std::map<ObjectInstanceID, ExtrusionEntityCollection> Slic3r::Print::m_brimMapByInstance

private

Referenced by _make_skirt().

◆ m_calib_params

Calib_Params Slic3r::Print::m_calib_params

private

Referenced by calib_mode(), calib_mode(), calib_params(), and set_calib_params().

◆ m_cancel_callback

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

privateinherited

580{};

Referenced by call_cancel_callback(), cancel_callback(), and set_cancel_callback().

◆ m_cancel_status

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

privateinherited

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

◆ m_config

PrintConfig Slic3r::Print::m_config

private

Referenced by _make_skirt(), _make_wipe_tower(), _plan_belt_purge(), append_tool_change_extruders(), apply_config_for_render(), brim_flow(), config(), enable_timelapse_print(), export_gcode(), first_layer_wipe_tower_corners(), Slic3r::GCode::generate_skirt(), get_config_index(), get_config_index(), get_extruder_printable_height(), get_extruder_printable_polygons(), get_extruder_shared_printable_polygon(), get_extruder_unprintable_polygons(), get_filament_config_indx(), get_filament_map_mode(), get_filament_maps(), get_filament_nozzle_maps(), get_filament_unprintable_flow(), get_filament_volume_maps(), get_physical_unprintable_filaments(), has_belt_purge_tower(), has_infinite_skirt(), has_skirt(), has_tilted_belt(), has_tpu_filament(), has_wipe_tower(), invalidate_state_by_config_options(), is_dynamic_group_reorder(), max_allowed_layer_height(), object_skirt_offset(), output_filename(), process(), skirt_first_layer_height(), skirt_flow(), support_material_extruders(), update_filament_maps_to_config(), update_filament_self_index_cache(), update_imex_slice_offset(), update_shrinkage_compensation(), update_to_config_by_nozzle_group_result(), validate(), validate_compacted_wipe_tower_clearance(), wipe_tower_data(), and wipe_tower_type().

◆ m_config_index_generation

size_t Slic3r::Print::m_config_index_generation {0}

private

1547{0};

Referenced by config_index_generation(), set_nozzle_group_result(), and update_filament_self_index_cache().

◆ m_conflict_result

ConflictResultOpt Slic3r::Print::m_conflict_result

private

Referenced by export_gcode(), get_conflict_result(), and get_conflict_string().

◆ m_default_object_config

PrintObjectConfig Slic3r::Print::m_default_object_config

private

Referenced by _make_wipe_tower(), default_object_config(), update_shrinkage_compensation(), and validate().

◆ m_default_region_config

PrintRegionConfig Slic3r::Print::m_default_region_config

private

Referenced by _make_wipe_tower(), default_region_config(), get_nozzle_config_index(), update_shrinkage_compensation(), and validate().

◆ m_extruder_filament_info

std::vector<std::vector<DynamicPrintConfig> > Slic3r::Print::m_extruder_filament_info

private

Referenced by get_extruder_filament_info(), and set_extruder_filament_info().

◆ m_fake_wipe_tower

FakeWipeTower Slic3r::Print::m_fake_wipe_tower

private

Referenced by _make_wipe_tower(), and get_fake_wipe_tower().

◆ m_filament_index_map

FilamentIndexMap Slic3r::Print::m_filament_index_map

private

Referenced by get_filament_config_indx(), and update_filament_self_index_cache().

◆ m_filament_self_index

std::vector<int> Slic3r::Print::m_filament_self_index

private

Referenced by get_filament_config_indx(), and update_filament_self_index_cache().

◆ m_first_layer_convex_hull

Polygon Slic3r::Print::m_first_layer_convex_hull

private

Referenced by finalize_first_layer_convex_hull(), and first_layer_convex_hull().

◆ m_full_print_config

DynamicPrintConfig Slic3r::PrintBase::m_full_print_config

protectedinherited

Referenced by PrintBase(), and full_print_config().

◆ m_geometric_unprintable_filaments

std::vector<std::set<int> > Slic3r::Print::m_geometric_unprintable_filaments

private

Referenced by get_geometric_unprintable_filaments(), and set_geometric_unprintable_filaments().

◆ m_has_auto_filament_map_result

bool Slic3r::Print::m_has_auto_filament_map_result {false}

private

1579{false};

Referenced by update_filament_maps_to_config(), and update_to_config_by_nozzle_group_result().

◆ m_has_shared_per_object_skirt

bool Slic3r::Print::m_has_shared_per_object_skirt { false }

private

1514{ false };

Referenced by _make_skirt(), and has_shared_per_object_skirt().

◆ m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

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

◆ m_imex_slice_offset

Vec2d Slic3r::Print::m_imex_slice_offset { Vec2d::Zero() }

private

1573{ Vec2d::Zero() };

Referenced by get_imex_slice_offset(), translate_to_print_space(), translate_to_print_space(), and update_imex_slice_offset().

◆ m_isBBLPrinter

bool Slic3r::Print::m_isBBLPrinter = false

private

Referenced by is_BBL_printer(), and is_BBL_printer().

◆ m_layered_nozzle_group_result

std::shared_ptr<MultiNozzleUtils::LayeredNozzleGroupResult> Slic3r::Print::m_layered_nozzle_group_result

private

Referenced by get_config_index(), get_config_index(), get_layered_nozzle_group_result(), and set_nozzle_group_result().

◆ m_missing_nozzle_group_logged

std::set<int> Slic3r::Print::m_missing_nozzle_group_logged

private

Referenced by get_config_index(), get_config_index(), and update_filament_self_index_cache().

◆ m_model

Model Slic3r::PrintBase::m_model

protectedinherited

Referenced by model(), output_filepath(), and update_object_placeholders().

◆ m_modified_count

int Slic3r::Print::m_modified_count {0}

private

1575{0};

Referenced by get_modified_count().

◆ m_need_check_multi_filaments_compatibility

bool Slic3r::Print::m_need_check_multi_filaments_compatibility {true}

private

1586{true};

Referenced by need_check_multi_filaments_compatibility(), and set_check_multi_filaments_compatibility().

◆ m_no_check

bool Slic3r::PrintBase::m_no_check = false

protectedinherited

Referenced by get_no_check_flag(), and set_no_check_flag().

◆ m_nozzle_group_result

std::shared_ptr<MultiNozzleUtils::NozzleGroupResultBase> Slic3r::Print::m_nozzle_group_result

private

Referenced by get_nozzle_group_result(), and set_nozzle_group_result().

◆ m_nozzle_index_map

PrintIndexMap Slic3r::Print::m_nozzle_index_map

private

Referenced by get_nozzle_config_index(), and update_filament_self_index_cache().

◆ m_objectBrimAreasByInstance

std::map<ObjectInstanceID, ExPolygons> Slic3r::Print::m_objectBrimAreasByInstance

private

Referenced by _make_skirt().

◆ m_objects

◆ m_ori_full_print_config

DynamicPrintConfig Slic3r::PrintBase::m_ori_full_print_config

protectedinherited

◆ m_origin

Vec3d Slic3r::Print::m_origin {0, 0, 0}

private

1570{0, 0, 0};

Referenced by _make_wipe_tower(), first_layer_wipe_tower_corners(), get_plate_origin(), set_plate_origin(), translate_to_print_space(), translate_to_print_space(), and validate_compacted_wipe_tower_clearance().

◆ m_pipeline_plugin_active

bool Slic3r::Print::m_pipeline_plugin_active { false }

private

1488{ false };

Referenced by process(), and run_pipeline_hook().

◆ m_placeholder_parser

PlaceholderParser Slic3r::PrintBase::m_placeholder_parser

protectedinherited

Referenced by PrintBase(), and placeholder_parser().

◆ m_plate_index

int Slic3r::PrintBase::m_plate_index { 0 }

protectedinherited

567{ 0 };

Referenced by get_plate_index(), and set_plate_index().

◆ m_plate_name

std::string Slic3r::PrintBase::m_plate_name

protectedinherited

Referenced by get_plate_name(), and set_plate_name().

◆ m_print_regions

PrintRegionPtrs Slic3r::Print::m_print_regions

private

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

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

bool Slic3r::Print::m_same_shrinkage_compensations { false }

private

1505{ false };

Referenced by clear(), has_same_shrinkage_compensations(), and update_shrinkage_compensation().

◆ m_sequential_dynamic_orderings

std::map<const PrintObject*, ToolOrdering> Slic3r::Print::m_sequential_dynamic_orderings

private

Referenced by sequential_dynamic_orderings().

◆ m_shrinkage_compensation

Vec3d Slic3r::Print::m_shrinkage_compensation { Vec3d::Ones() }

private

1506{ Vec3d::Ones() };

Referenced by clear(), shrinkage_compensation(), and update_shrinkage_compensation().

◆ m_skirt

ExtrusionEntityCollection Slic3r::Print::m_skirt

private

Referenced by _make_skirt(), and skirt().

◆ m_skirt_brim_groups

std::vector<SkirtBrimGroup> Slic3r::Print::m_skirt_brim_groups

private

Referenced by _make_skirt(), and skirt_brim_groups().

◆ m_skirt_convex_hull

Points Slic3r::Print::m_skirt_convex_hull

private

Referenced by _make_skirt(), and finalize_first_layer_convex_hull().

◆ m_slice_used_filaments

std::vector<unsigned int> Slic3r::Print::m_slice_used_filaments

private

Referenced by get_slice_used_filaments(), and set_slice_used_filaments().

◆ m_slice_used_filaments_first_layer

std::vector<unsigned int> Slic3r::Print::m_slice_used_filaments_first_layer

private

Referenced by get_slice_used_filaments(), and set_slice_used_filaments().

◆ m_slice_used_mixed_filaments

std::vector<unsigned int> Slic3r::Print::m_slice_used_mixed_filaments

private

Referenced by get_slice_used_mixed_filaments(), and set_slice_used_mixed_filaments().

◆ m_state

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

privateinherited

Referenced by active_step_add_warning(), invalidate_all_steps(), invalidate_step(), invalidate_steps(), invalidate_steps(), is_step_done(), is_step_done_unguarded(), is_step_started_unguarded(), set_done(), set_started(), step_state_with_timestamp(), and step_state_with_warnings().

◆ m_state_mutex

std::mutex Slic3r::PrintBase::m_state_mutex

mutableprivateinherited

Referenced by state_mutex().

◆ m_statistics_by_extruder_count

StatisticsByExtruderCount Slic3r::Print::m_statistics_by_extruder_count

private

Referenced by Slic3r::GCode::_do_export(), clear(), statistics_by_extruder(), and statistics_by_extruder().

◆ m_status_callback

status_callback_type Slic3r::PrintBase::m_status_callback

protectedinherited

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

◆ m_support_used

bool Slic3r::Print::m_support_used {false}

private

1561{false};

Referenced by apply(), and is_support_used().

◆ m_tool_ordering

ToolOrdering Slic3r::Print::m_tool_ordering

private

Referenced by tool_ordering().

◆ m_wipe_tower_data

WipeTowerData Slic3r::Print::m_wipe_tower_data {m_tool_ordering}

private

1557{m_tool_ordering};

Referenced by _make_wipe_tower(), _plan_belt_purge(), first_layer_wipe_tower_corners(), get_rib_offset(), get_tool_ordering(), get_wipe_tower_bbx(), get_wipe_tower_depth(), has_tpu_filament(), validate_compacted_wipe_tower_clearance(), and wipe_tower_data().

◆ PrintTryCancel

friend Slic3r::PrintBase::PrintTryCancel

privateinherited

Referenced by make_try_cancel().

◆ s_last_id

size_t Slic3r::ObjectBase::s_last_id = 0

staticprivateinherited

Referenced by generate_new_id().

◆ s_slicing_pipeline_hook_fn

Print::SlicingPipelineHookFn Slic3r::Print::s_slicing_pipeline_hook_fn = nullptr

staticprivate

Referenced by process(), run_pipeline_hook(), and set_slicing_pipeline_hook_fn().

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Print.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/BeltPurge.cpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Print.cpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/PrintApply.cpp

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Class Documentation

◆ Slic3r::Print::SkirtBrimGroup

Member Typedef Documentation

◆ cancel_callback_type

◆ FilamentIndexMap

◆ Inherited

◆ PrintIndexMap

◆ PrintObjectInfo

◆ SlicingPipelineHookFn

◆ status_callback_type

◆ Timestamp

Member Enumeration Documentation

◆ ApplyStatus

◆ CancelStatus

Constructor & Destructor Documentation

◆ Print()

◆ ~Print()

Member Function Documentation

◆ _align_belt_purge_layers()

◆ _make_skirt()

◆ _make_wipe_tower()

◆ _plan_belt_purge()

◆ active_step_add_warning()

◆ append_model_object_extruders()

◆ append_support_extruders()

◆ append_tool_change_extruders()

◆ append_wipe_tower_extruder()

◆ apply()

◆ apply_config_for_render()

◆ assign_new_unique_ids_recursive()

◆ auto_assign_extruders()

◆ brim_flow()

◆ calib_mode() [1/2]

◆ calib_mode() [2/2]

◆ calib_params()

◆ call_cancel_callback()

◆ cancel()

◆ cancel_callback()

◆ cancel_internal()

◆ cancel_status()

◆ canceled()

◆ check_multi_filament_valid()

◆ check_multi_filaments_compatibility()

◆ clear()

◆ collect_filament_variant_uses()

◆ compacted_wipe_tower_clearance_valid()

◆ config()

◆ config_index_generation()

◆ copy_id()

◆ default_object_config()

◆ default_region_config()

◆ empty()

◆ enable_timelapse_print()

◆ export_cached_data()

◆ export_gcode()

◆ export_gcode_from_previous_file()

◆ extruders()

◆ finalize()

◆ finalize_first_layer_convex_hull()

◆ finished()

◆ first_layer_convex_hull()

◆ first_layer_islands()

◆ first_layer_wipe_tower_corners()

◆ full_print_config()

◆ generate_new_id()

◆ get_brimMap()