#include <src/libslic3r/Slicing.hpp>

Public Member Functions
	SlicingParameters ()=default

bool	has_raft () const

size_t	raft_layers () const

bool	first_object_layer_height_fixed () const

coordf_t	object_print_z_height () const

Static Public Member Functions
static SlicingParameters	create_from_config (const PrintConfig &print_config, const PrintObjectConfig &object_config, coordf_t object_height, const std::vector< unsigned int > &object_extruders)

Public Attributes
bool	valid { false }

size_t	base_raft_layers { 0 }

size_t	interface_raft_layers { 0 }

coordf_t	base_raft_layer_height { 0 }

coordf_t	interface_raft_layer_height { 0 }

coordf_t	contact_raft_layer_height { 0 }

coordf_t	layer_height { 0 }

coordf_t	min_layer_height { 0 }

coordf_t	max_layer_height { 0 }

coordf_t	max_suport_layer_height { 0 }

coordf_t	first_print_layer_height { 0 }

coordf_t	first_object_layer_height { 0 }

bool	first_object_layer_bridging { false }

bool	soluble_interface { false }

coordf_t	gap_raft_object { 0 }

coordf_t	gap_object_support { 0 }

coordf_t	gap_support_object { 0 }

coordf_t	raft_base_top_z { 0 }

coordf_t	raft_interface_top_z { 0 }

coordf_t	raft_contact_top_z { 0 }

coordf_t	object_print_z_min { 0 }

coordf_t	object_print_z_max { 0 }

Detailed Description

Constructor & Destructor Documentation

◆ SlicingParameters()

Slic3r::SlicingParameters::SlicingParameters ( )

default

Member Function Documentation

◆ create_from_config()

SlicingParameters Slic3r::SlicingParameters::create_from_config	(	const PrintConfig &	print_config,
		const PrintObjectConfig &	object_config,
		coordf_t	object_height,
		const std::vector< unsigned int > &	object_extruders
	)

static

{
    assert(! print_config.first_layer_height.percent);
    coordf_t first_layer_height                      = (print_config.first_layer_height.value <= 0) ? 
        object_config.layer_height.value : print_config.first_layer_height.value;
    // If object_config.support_material_extruder == 0 resp. object_config.support_material_interface_extruder == 0,
    // print_config.nozzle_diameter.get_at(size_t(-1)) returns the 0th nozzle diameter,
    // which is consistent with the requirement that if support_material_extruder == 0 resp. support_material_interface_extruder == 0,
    // support will not trigger tool change, but it will use the current nozzle instead.
    // In that case all the nozzles have to be of the same diameter.
    coordf_t support_material_extruder_dmr           = print_config.nozzle_diameter.get_at(object_config.support_material_extruder.value - 1);
    coordf_t support_material_interface_extruder_dmr = print_config.nozzle_diameter.get_at(object_config.support_material_interface_extruder.value - 1);
    bool     soluble_interface                       = object_config.support_material_contact_distance.value == 0.;
 
    SlicingParameters params;
    params.layer_height = object_config.layer_height.value;
    params.first_print_layer_height = first_layer_height;
    params.first_object_layer_height = first_layer_height;
    params.object_print_z_min = 0.;
    params.object_print_z_max = object_height;
    params.base_raft_layers = object_config.raft_layers.value;
    params.soluble_interface = soluble_interface;
 
    // Miniumum/maximum of the minimum layer height over all extruders.
    params.min_layer_height = MIN_LAYER_HEIGHT;
    params.max_layer_height = std::numeric_limits<double>::max();
    if (object_config.support_material.value || params.base_raft_layers > 0 || object_config.support_material_enforce_layers > 0) {
        // Has some form of support. Add the support layers to the minimum / maximum layer height limits.
        params.min_layer_height = std::max(
            min_layer_height_from_nozzle(print_config, object_config.support_material_extruder), 
            min_layer_height_from_nozzle(print_config, object_config.support_material_interface_extruder));
        params.max_layer_height = std::min(
            max_layer_height_from_nozzle(print_config, object_config.support_material_extruder), 
            max_layer_height_from_nozzle(print_config, object_config.support_material_interface_extruder));
        params.max_suport_layer_height = params.max_layer_height;
    }
    if (object_extruders.empty()) {
        params.min_layer_height = std::max(params.min_layer_height, min_layer_height_from_nozzle(print_config, 0));
        params.max_layer_height = std::min(params.max_layer_height, max_layer_height_from_nozzle(print_config, 0));
    } else {
        for (unsigned int extruder_id : object_extruders) {
            params.min_layer_height = std::max(params.min_layer_height, min_layer_height_from_nozzle(print_config, extruder_id));
            params.max_layer_height = std::min(params.max_layer_height, max_layer_height_from_nozzle(print_config, extruder_id));
        }
    }
    params.min_layer_height = std::min(params.min_layer_height, params.layer_height);
    params.max_layer_height = std::max(params.max_layer_height, params.layer_height);
 
    if (! soluble_interface) {
        params.gap_raft_object    = object_config.raft_contact_distance.value;
        params.gap_object_support = object_config.support_material_bottom_contact_distance.value;
        params.gap_support_object = object_config.support_material_contact_distance.value;
        if (params.gap_object_support <= 0)
            params.gap_object_support = params.gap_support_object;
    }
 
    if (params.base_raft_layers > 0) {
    params.interface_raft_layers = (params.base_raft_layers + 1) / 2;
        params.base_raft_layers -= params.interface_raft_layers;
        // Use as large as possible layer height for the intermediate raft layers.
        params.base_raft_layer_height       = std::max(params.layer_height, 0.75 * support_material_extruder_dmr);
        params.interface_raft_layer_height  = std::max(params.layer_height, 0.75 * support_material_interface_extruder_dmr);
        params.first_object_layer_bridging  = false;
        params.contact_raft_layer_height    = std::max(params.layer_height, 0.75 * support_material_interface_extruder_dmr);
        params.first_object_layer_height    = params.layer_height;
    }
 
    if (params.has_raft()) {
        // Raise first object layer Z by the thickness of the raft itself plus the extra distance required by the support material logic.
        //FIXME The last raft layer is the contact layer, which shall be printed with a bridging flow for ease of separation. Currently it is not the case.
    if (params.raft_layers() == 1) {
            // There is only the contact layer.
            params.contact_raft_layer_height = first_layer_height;
            params.raft_contact_top_z        = first_layer_height;
    } else {
            assert(params.base_raft_layers > 0);
            assert(params.interface_raft_layers > 0);
            // Number of the base raft layers is decreased by the first layer.
            params.raft_base_top_z       = first_layer_height + coordf_t(params.base_raft_layers - 1) * params.base_raft_layer_height;
            // Number of the interface raft layers is decreased by the contact layer.
            params.raft_interface_top_z  = params.raft_base_top_z + coordf_t(params.interface_raft_layers - 1) * params.interface_raft_layer_height;
      params.raft_contact_top_z    = params.raft_interface_top_z + params.contact_raft_layer_height;
    }
        coordf_t print_z = params.raft_contact_top_z + params.gap_raft_object;
        params.object_print_z_min  = print_z;
        params.object_print_z_max += print_z;
    }
 
    params.valid = true;
    return params;
}