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

Collaboration diagram for Slic3r::SupportParameters:

Public Member Functions
	SupportParameters ()=delete
	SupportParameters (const PrintObject &object)
bool	has_contacts () const
bool	has_interfaces () const
bool	has_base_interfaces () const
size_t	num_top_interface_layers_only () const
size_t	num_bottom_interface_layers_only () const
float	raft_interface_angle (size_t interface_id) const
float	support_interface_angle (size_t interface_id) const

Public Attributes
bool	zero_gap_interface_top
bool	zero_gap_interface_bottom
bool	has_top_contacts
bool	has_bottom_contacts
size_t	num_top_interface_layers
size_t	num_bottom_interface_layers
size_t	num_top_base_interface_layers
size_t	num_bottom_base_interface_layers
Flow	first_layer_flow
Flow	support_material_flow
Flow	support_material_interface_flow
Flow	support_material_bottom_interface_flow
Flow	raft_interface_flow
coordf_t	support_extrusion_width
bool	can_merge_support_regions
coordf_t	support_layer_height_min
coordf_t	gap_xy
coordf_t	gap_xy_first_layer
float	base_angle
float	interface_angle
coordf_t	top_interface_spacing
coordf_t	bottom_interface_spacing
coordf_t	support_expansion =0
coordf_t	top_interface_density
coordf_t	bottom_interface_density
coordf_t	raft_interface_density
coordf_t	support_spacing
coordf_t	support_density
SupportMaterialStyle	support_style = smsDefault
SupportMaterialInterfacePattern	support_interface_pattern = smipAuto
InfillPattern	base_fill_pattern
InfillPattern	interface_fill_pattern
InfillPattern	raft_interface_fill_pattern
InfillPattern	contact_fill_pattern
bool	with_sheath
double	tree_branch_diameter_double_wall_area_scaled = 0.25 * sqr(scaled<double>(5.0)) * M_PI
float	raft_angle_1st_layer
float	raft_angle_base
float	raft_angle_interface
bool	independent_layer_height = false
const double	thresh_big_overhang = Slic3r::sqr(scale_(10))
bool	ironing
Flow	ironing_flow
InfillPattern	ironing_pattern
float	ironing_spacing

Detailed Description

Constructor & Destructor Documentation

◆ SupportParameters() [1/2]

Slic3r::SupportParameters::SupportParameters ( )

delete

◆ SupportParameters() [2/2]

Slic3r::SupportParameters::SupportParameters ( const PrintObject & object )

inline

    {
        const PrintConfig& print_config = object.print()->config();
        const PrintObjectConfig& object_config = object.config();
        const SlicingParameters& slicing_params = object.slicing_parameters();
 
        this->zero_gap_interface_top = slicing_params.zero_gap_interface_top;
        this->zero_gap_interface_bottom = slicing_params.zero_gap_interface_bottom;
        const bool soluble_interface_non_soluble_base =
            // Interface extruder soluble.
            object_config.support_interface_filament.value > 0 && print_config.filament_soluble.get_at(object_config.support_interface_filament.value - 1) &&
            // Base extruder: Either "print with active extruder" not soluble.
            (object_config.support_filament.value == 0 || ! print_config.filament_soluble.get_at(object_config.support_filament.value - 1));
        const bool non_soluble_base_top = this->zero_gap_interface_top && soluble_interface_non_soluble_base;
        const bool non_soluble_base_bottom = this->zero_gap_interface_bottom && soluble_interface_non_soluble_base;
 
      {
          this->num_top_interface_layers    = std::max(0, object_config.support_interface_top_layers.value);
          this->num_bottom_interface_layers = std::max(0, number_of_support_interface_bottom_layers(object_config));
          this->has_top_contacts              = num_top_interface_layers    > 0;
          this->has_bottom_contacts           = num_bottom_interface_layers > 0;
            // BBS: if support interface and support base do not use the same filament, add a base layer to improve their adhesion
            // Note: support materials (such as Supp.W) can't be used as support base now, so support interface and base are still using different filaments even if
            // support_filament==0
            bool different_support_interface_filament = object_config.support_interface_filament != 0 &&
                                                       object_config.support_interface_filament != object_config.support_filament;
 
            if (non_soluble_base_top) { // ORCA: Try to support soluble dense interfaces with non-soluble dense interfaces.
                this->num_top_base_interface_layers = size_t(std::min(int(num_top_interface_layers) / 2, 2));
            } else {
                // Keep at least one configured layer on the interface filament.
                this->num_top_base_interface_layers = different_support_interface_filament && num_top_interface_layers > 1 ? 1 : 0;
            }
 
            if (non_soluble_base_bottom) { // ORCA: Try to support soluble dense interfaces with non-soluble dense interfaces.
                this->num_bottom_base_interface_layers = size_t(std::min(int(num_bottom_interface_layers) / 2, 2));
            } else {
                // Keep at least one configured layer on the interface filament.
                this->num_bottom_base_interface_layers = different_support_interface_filament && num_bottom_interface_layers > 1 ? 1 : 0;
            }
      }
        this->first_layer_flow = Slic3r::support_material_1st_layer_flow(&object, float(slicing_params.first_print_layer_height));
        this->support_material_flow = Slic3r::support_material_flow(&object, float(slicing_params.layer_height));
        this->support_material_interface_flow = Slic3r::support_material_interface_flow(&object, float(slicing_params.layer_height));
      this->raft_interface_flow                = support_material_interface_flow;
 
        this->ironing = object_config.support_ironing;
        this->ironing_flow = support_material_interface_flow.with_height(support_material_interface_flow.height() * 0.01 * object_config.support_ironing_flow.value);
        this->ironing_spacing = std::max(IRONING_SPACING_MIN, object_config.support_ironing_spacing.value);
        this->ironing_pattern = object_config.support_ironing_pattern;
 
        // Calculate a minimum support layer height as a minimum over all extruders, but not smaller than 10um.
        this->support_layer_height_min = scaled<coord_t>(0.01);
        for (auto lh : print_config.min_layer_height.values)
            this->support_layer_height_min = std::min(this->support_layer_height_min, std::max(0.01, lh));
        for (auto layer : object.layers())
            this->support_layer_height_min = std::min(this->support_layer_height_min, std::max(0.01, layer->height));
        
        if (this->num_top_interface_layers == 0 && this->num_bottom_interface_layers == 0) {
            // No interface layers allowed, print everything with the base support pattern.
            this->support_material_interface_flow = this->support_material_flow;
        }
        
        // Evaluate the XY gap between the object outer perimeters and the support structures.
        // Evaluate the XY gap between the object outer perimeters and the support structures.
        coordf_t external_perimeter_width = 0.;
        coordf_t bridge_flow_ratio = 0;
        for (size_t region_id = 0; region_id < object.num_printing_regions(); ++ region_id) {
            const PrintRegion &region = object.printing_region(region_id);
            external_perimeter_width = std::max(external_perimeter_width, coordf_t(region.flow(object, frExternalPerimeter, slicing_params.layer_height).width()));
            bridge_flow_ratio += region.config().bridge_flow;
        }
        this->gap_xy = object_config.support_object_xy_distance.value;
        this->gap_xy_first_layer = object_config.support_object_first_layer_gap.value;
        bridge_flow_ratio /= object.num_printing_regions();
 
        this->support_material_bottom_interface_flow = this->zero_gap_interface_bottom || !object_config.thick_bridges ?
            this->support_material_interface_flow.with_flow_ratio(bridge_flow_ratio) :
            Flow::bridging_flow(bridge_flow_ratio * this->support_material_interface_flow.nozzle_diameter(), this->support_material_interface_flow.nozzle_diameter());
        
        this->can_merge_support_regions = object_config.support_filament.value == object_config.support_interface_filament.value;
        if (!this->can_merge_support_regions && (object_config.support_filament.value == 0 || object_config.support_interface_filament.value == 0)) {
            // One of the support extruders is of "don't care" type.
            auto object_extruders = object.object_extruders();
            if (object_extruders.size() == 1 &&
                *object_extruders.begin() == std::max<unsigned int>(object_config.support_filament.value, object_config.support_interface_filament.value))
                // Object is printed with the same extruder as the support.
                this->can_merge_support_regions = true;
        }
 
 
        this->base_angle = Geometry::deg2rad(float(object_config.support_angle.value));
        this->interface_angle = Geometry::deg2rad(float(object_config.support_angle.value + 90.));
        // ORCA: split top/bottom interface spacing and density, and force solid top when ironing.
        this->top_interface_spacing = (this->ironing ? 0 : object_config.support_interface_spacing.value) + this->support_material_interface_flow.spacing();
        this->top_interface_density = std::min(1., this->support_material_interface_flow.spacing() / this->top_interface_spacing);
        // ORCA: bottom interface spacing/density separated from top settings.
        this->bottom_interface_spacing = object_config.support_bottom_interface_spacing.value + this->support_material_interface_flow.spacing();
        this->bottom_interface_density = std::min(1., this->support_material_interface_flow.spacing() / this->bottom_interface_spacing);
        // ORCA: force solid raft interface when ironing (top spacing).
        double raft_interface_spacing = (this->ironing ? 0 : object_config.support_interface_spacing.value) + this->raft_interface_flow.spacing();
        this->raft_interface_density = std::min(1., this->raft_interface_flow.spacing() / raft_interface_spacing);
        this->support_spacing = object_config.support_base_pattern_spacing.value + this->support_material_flow.spacing();
        this->support_density = std::min(1., this->support_material_flow.spacing() / this->support_spacing);
        if (this->num_top_interface_layers == 0) {
            // No top interface layers allowed; keep unused top interface parameters aligned with base support.
            this->top_interface_spacing = this->support_spacing;
            this->top_interface_density = this->support_density;
        }
 
        SupportMaterialPattern  support_pattern = object_config.support_base_pattern;
        this->with_sheath = object_config.tree_support_wall_count > 0;
        this->base_fill_pattern =
            support_pattern == smpHoneycomb ? ipHoneycomb :
            this->support_density > 0.95 || this->with_sheath ? ipRectilinear : ipSupportBase;
        this->interface_fill_pattern = (this->top_interface_density > 0.95 ? ipRectilinear : ipSupportBase);
        this->raft_interface_fill_pattern = this->raft_interface_density > 0.95 ? ipRectilinear : ipSupportBase;
        const coordf_t contact_interface_density = this->num_top_interface_layers > 0 ?
            this->top_interface_density : this->bottom_interface_density;
        const bool zero_gap_contact_interface = this->num_top_interface_layers > 0 ?
            this->zero_gap_interface_top : this->zero_gap_interface_bottom;
        if (object_config.support_interface_pattern == smipGrid)
            this->contact_fill_pattern = ipGrid;
        else if (object_config.support_interface_pattern == smipRectilinearInterlaced)
            this->contact_fill_pattern = ipRectilinear;
        else if (object_config.support_interface_pattern == smipSpiralInset)
            this->contact_fill_pattern = ipSpiralInset;
        else
            this->contact_fill_pattern =
            (object_config.support_interface_pattern == smipAuto && zero_gap_contact_interface) ||
            object_config.support_interface_pattern == smipConcentric ?
            ipConcentric :
            (contact_interface_density > 0.95 ? ipRectilinear : ipSupportBase);
 
        this->raft_angle_1st_layer  = 0.f;
        this->raft_angle_base       = 0.f;
        this->raft_angle_interface  = 0.f;
        if (slicing_params.base_raft_layers > 1) {
            assert(slicing_params.raft_layers() >= 4);
            // There are all raft layer types (1st layer, base, interface & contact layers) available.
            this->raft_angle_1st_layer  = this->interface_angle;
            this->raft_angle_base       = this->base_angle;
            this->raft_angle_interface  = this->interface_angle;
            if ((slicing_params.interface_raft_layers & 1) == 0)
                // Allign the 1st raft interface layer so that the object 1st layer is hatched perpendicularly to the raft contact interface.
                this->raft_angle_interface += float(0.5 * M_PI);
        } else if (slicing_params.base_raft_layers == 1 || slicing_params.interface_raft_layers > 1) {
            assert(slicing_params.raft_layers() == 2 || slicing_params.raft_layers() == 3);
            // 1st layer, interface & contact layers available.
            this->raft_angle_1st_layer  = this->base_angle;
            this->raft_angle_interface  = this->interface_angle + 0.5 * M_PI;
        } else if (slicing_params.interface_raft_layers == 1) {
            // Only the contact raft layer is non-empty, which will be printed as the 1st layer.
            assert(slicing_params.base_raft_layers == 0);
            assert(slicing_params.interface_raft_layers == 1);
            assert(slicing_params.raft_layers() == 1);
            this->raft_angle_1st_layer = float(0.5 * M_PI);
            this->raft_angle_interface = this->raft_angle_1st_layer;
        } else {
            // No raft.
            assert(slicing_params.base_raft_layers == 0);
            assert(slicing_params.interface_raft_layers == 0);
            assert(slicing_params.raft_layers() == 0);
        }
 
      const auto     nozzle_diameter = print_config.nozzle_diameter.get_at(object_config.support_interface_filament - 1);
        const coordf_t extrusion_width = object_config.line_width.get_abs_value(nozzle_diameter);
        support_extrusion_width        = object_config.support_line_width.get_abs_value(nozzle_diameter);
        support_extrusion_width        = support_extrusion_width > 0 ? support_extrusion_width : extrusion_width;
 
        independent_layer_height = print_config.independent_support_layer_height;
 
        // force double walls everywhere if wall count is larger than 1        
        tree_branch_diameter_double_wall_area_scaled = object_config.tree_support_wall_count.value > 1  ? 0.1 :
                                                       object_config.tree_support_wall_count.value == 0 ? 0.25 * sqr(scaled<double>(5.0)) * M_PI :
                                                                                                          std::numeric_limits<double>::max();
 
        support_style = object_config.support_style;
        support_interface_pattern = object_config.support_interface_pattern;
        if (support_style != smsDefault) {
            if ((support_style == smsSnug || support_style == smsGrid) && is_tree(object_config.support_type)) support_style = smsDefault;
            if ((support_style == smsTreeSlim || support_style == smsTreeStrong || support_style == smsTreeHybrid || support_style == smsTreeOrganic) &&
                !is_tree(object_config.support_type))
                support_style = smsDefault;
        }
        if (support_style == smsDefault) {
            if (is_tree(object_config.support_type)) {
                // Orca: use organic as default
                support_style = smsTreeOrganic;
            } else {
                support_style = smsGrid;
            }
        }
    }

References base_angle, base_fill_pattern, Slic3r::SlicingParameters::base_raft_layers, bottom_interface_density, bottom_interface_spacing, Slic3r::Flow::bridging_flow(), can_merge_support_regions, Slic3r::PrintRegion::config(), contact_fill_pattern, Slic3r::Geometry::deg2rad(), first_layer_flow, Slic3r::SlicingParameters::first_print_layer_height, Slic3r::PrintRegion::flow(), Slic3r::frExternalPerimeter, gap_xy, gap_xy_first_layer, has_bottom_contacts, has_top_contacts, independent_layer_height, interface_angle, interface_fill_pattern, Slic3r::SlicingParameters::interface_raft_layers, Slic3r::ipConcentric, Slic3r::ipGrid, Slic3r::ipHoneycomb, Slic3r::ipRectilinear, Slic3r::ipSpiralInset, Slic3r::ipSupportBase, ironing, ironing_flow, ironing_pattern, ironing_spacing, Slic3r::IRONING_SPACING_MIN, Slic3r::is_tree(), Slic3r::SlicingParameters::layer_height, M_PI, Slic3r::nozzle_diameter(), num_bottom_base_interface_layers, num_bottom_interface_layers, num_top_base_interface_layers, num_top_interface_layers, Slic3r::number_of_support_interface_bottom_layers(), Slic3r::PrintObjectConfig, raft_angle_1st_layer, raft_angle_base, raft_angle_interface, raft_interface_density, raft_interface_fill_pattern, raft_interface_flow, Slic3r::SlicingParameters::raft_layers(), Slic3r::scaled(), Slic3r::smipAuto, Slic3r::smipConcentric, Slic3r::smipGrid, Slic3r::smipRectilinearInterlaced, Slic3r::smipSpiralInset, Slic3r::smpHoneycomb, Slic3r::smsDefault, Slic3r::smsGrid, Slic3r::smsSnug, Slic3r::smsTreeHybrid, Slic3r::smsTreeOrganic, Slic3r::smsTreeSlim, Slic3r::smsTreeStrong, Slic3r::sqr(), support_density, support_extrusion_width, support_interface_pattern, support_layer_height_min, Slic3r::support_material_1st_layer_flow(), support_material_bottom_interface_flow, Slic3r::support_material_flow(), support_material_flow, Slic3r::support_material_interface_flow(), support_material_interface_flow, support_spacing, support_style, top_interface_density, top_interface_spacing, tree_branch_diameter_double_wall_area_scaled, Slic3r::Flow::width(), with_sheath, Slic3r::SlicingParameters::zero_gap_interface_bottom, zero_gap_interface_bottom, Slic3r::SlicingParameters::zero_gap_interface_top, and zero_gap_interface_top.

Here is the call graph for this function:

Member Function Documentation

◆ has_base_interfaces()

bool Slic3r::SupportParameters::has_base_interfaces ( ) const

inline

243{ return this->num_top_base_interface_layers + this->num_bottom_base_interface_layers > 0; }

Referenced by Slic3r::generate_interface_layers(), and Slic3r::TreeSupport3D::generate_support_areas().

Here is the caller graph for this function:

◆ has_contacts()

bool Slic3r::SupportParameters::has_contacts ( ) const

inline

241{ return this->has_top_contacts || this->has_bottom_contacts; }

◆ has_interfaces()

bool Slic3r::SupportParameters::has_interfaces ( ) const

inline

242{ return this->num_top_interface_layers + this->num_bottom_interface_layers > 0; }

Referenced by Slic3r::generate_interface_layers(), and Slic3r::TreeSupport3D::generate_support_areas().

Here is the caller graph for this function:

◆ num_bottom_interface_layers_only()

size_t Slic3r::SupportParameters::num_bottom_interface_layers_only ( ) const

inline

245{ return this->num_bottom_interface_layers - this->num_bottom_base_interface_layers; }

◆ num_top_interface_layers_only()

size_t Slic3r::SupportParameters::num_top_interface_layers_only ( ) const

inline

244{ return this->num_top_interface_layers - this->num_top_base_interface_layers; }

◆ raft_interface_angle()

float Slic3r::SupportParameters::raft_interface_angle ( size_t interface_id ) const

inline

304 { return this->raft_angle_interface + ((interface_id & 1) ? float(- M_PI_4) : float(+ M_PI_4)); }

Referenced by Slic3r::generate_support_toolpaths().

Here is the caller graph for this function:

◆ support_interface_angle()

float Slic3r::SupportParameters::support_interface_angle ( size_t interface_id ) const

inline

      { 
            float angle;
            
            switch (this->support_interface_pattern) {
                case SupportMaterialInterfacePattern::smipRectilinear:
                    angle = support_style == SupportMaterialStyle::smsSnug ? this->interface_angle - float(M_PI_4) : this->interface_angle;
                    break;
                case SupportMaterialInterfacePattern::smipRectilinearInterlaced:
                    angle = this->interface_angle + ((interface_id & 1) ? float(M_PI_4) : float(-M_PI_4));
                    break;
                case SupportMaterialInterfacePattern::smipGrid:
                    angle = this->base_angle;
                    break;
                default:
                    angle = this->interface_angle;
                    break;
            }
 
            return angle;
        }