This struct contains settings used in the tree support. Thanks to this most functions do not need to know of meshes etc. Also makes the code shorter. More...

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

Collaboration diagram for Slic3r::TreeSupport3D::TreeSupportSettings:

Public Member Functions
	TreeSupportSettings ()=default
	TreeSupportSettings (const TreeSupportMeshGroupSettings &mesh_group_settings, const SlicingParameters &slicing_params)
bool	operator== (const TreeSupportSettings &other) const
coord_t	getRadius (size_t distance_to_top, const double elephant_foot_increases=0) const
	Get the Radius part will have based on numeric values.
coord_t	recommendedMinRadius (LayerIndex layer_idx) const
	Get the Radius an element should at least have at a given layer.

Public Attributes
coord_t	support_line_width
	Width of a single line of support.
coord_t	layer_height
	Height of a single layer.
coord_t	branch_radius
	Radius of a branch when it has left the tip.
coord_t	min_radius
	smallest allowed radius, required to ensure that even at DTT 0 every circle will still be printed
coord_t	maximum_move_distance
	How far an influence area may move outward every layer at most.
coord_t	maximum_move_distance_slow
	How far every influence area will move outward every layer if possible.
size_t	support_bottom_layers
	Amount of bottom layers. 0 if disabled.
size_t	tip_layers
	Amount of effectiveDTT increases are required to reach branch radius.
double	branch_radius_increase_per_layer
	How much a branch radius increases with each layer to guarantee the prescribed tree widening.
coord_t	max_to_model_radius_increase
	How much a branch resting on the model may grow in radius by merging with branches that can reach the buildplate.
size_t	min_dtt_to_model
	If smaller (in layers) than that, all branches to model will be deleted.
coord_t	increase_radius_until_radius
	Increase radius in the resulting drawn branches, even if the avoidance does not allow it. Will be cut later to still fit.
size_t	increase_radius_until_layer
	Same as increase_radius_until_radius, but contains the DTT at which the radius will be reached.
bool	support_rests_on_model
	True if the branches may connect to the model.
coord_t	xy_distance
	How far should support be from the model.
coord_t	bp_radius
	A minimum radius a tree trunk should expand to at the buildplate if possible.
LayerIndex	layer_start_bp_radius
	The layer index at which an increase in radius may be required to reach the bp_radius.
double	bp_radius_increase_per_layer
	How much one is allowed to increase the tree branch radius close to print bed to reach the required bp_radius at layer 0. Note that this radius increase will not happen in the tip, to ensure the tip is structurally sound.
coord_t	xy_min_distance
	minimum xy_distance. Only relevant when Z overrides XY, otherwise equal to xy_distance-
size_t	z_distance_top_layers
	Amount of layers distance required the top of the support to the model.
size_t	z_distance_bottom_layers
	Amount of layers distance required from the top of the model to the bottom of a support structure.
std::vector< double >	support_roof_angles
	User specified angles for the support infill.
SupportMaterialInterfacePattern	roof_pattern
	Pattern used in the support roof. May contain non relevant data if support roof is disabled.
SupportMaterialPattern	support_pattern
	Pattern used in the support infill.
coord_t	support_roof_line_width
	Line width of the support roof.
coord_t	support_line_spacing
	Distance between support infill lines.
coord_t	support_bottom_offset
	Offset applied to the support floor area.
int	support_wall_count
coord_t	resolution
coord_t	support_roof_line_distance
InterfacePreference	interface_preference
TreeSupportMeshGroupSettings	settings
coord_t	min_feature_size
std::vector< coordf_t >	raft_layers

Static Public Attributes
static bool	zero_top_z_gap = false

Detailed Description

This struct contains settings used in the tree support. Thanks to this most functions do not need to know of meshes etc. Also makes the code shorter.

Constructor & Destructor Documentation

◆ TreeSupportSettings() [1/2]

Slic3r::TreeSupport3D::TreeSupportSettings::TreeSupportSettings ( )

default

Referenced by operator==().

Here is the caller graph for this function:

◆ TreeSupportSettings() [2/2]

Slic3r::TreeSupport3D::TreeSupportSettings::TreeSupportSettings	(	const TreeSupportMeshGroupSettings &	mesh_group_settings,
		const SlicingParameters &	slicing_params )

inlineexplicit

        : support_line_width(mesh_group_settings.support_line_width),
          layer_height(mesh_group_settings.layer_height),
          branch_radius(mesh_group_settings.support_tree_branch_diameter / 2),
          min_radius(mesh_group_settings.support_tree_tip_diameter / 2), // The actual radius is 50 microns larger as the resulting branches will be increased by 50 microns to avoid rounding errors effectively increasing the xydistance
          maximum_move_distance((mesh_group_settings.support_tree_angle < M_PI / 2.) ? (coord_t)(tan(mesh_group_settings.support_tree_angle) * layer_height) : std::numeric_limits<coord_t>::max()),
          maximum_move_distance_slow((mesh_group_settings.support_tree_angle_slow < M_PI / 2.) ? (coord_t)(tan(mesh_group_settings.support_tree_angle_slow) * layer_height) : std::numeric_limits<coord_t>::max()),
          support_bottom_layers(mesh_group_settings.support_bottom_enable ? (mesh_group_settings.support_bottom_height + layer_height / 2) / layer_height : 0),
          // Ensure lines always stack nicely even if layer height is large.
          tip_layers(std::max((branch_radius - min_radius) / (support_line_width / 3), branch_radius / layer_height)),
          branch_radius_increase_per_layer(tan(mesh_group_settings.support_tree_branch_diameter_angle) * layer_height),
          max_to_model_radius_increase(mesh_group_settings.support_tree_max_diameter_increase_by_merges_when_support_to_model / 2),
          min_dtt_to_model(round_up_divide(mesh_group_settings.support_tree_min_height_to_model, layer_height)),
          increase_radius_until_radius(mesh_group_settings.support_tree_branch_diameter / 2),
          increase_radius_until_layer(increase_radius_until_radius <= branch_radius ? tip_layers * (increase_radius_until_radius / branch_radius) : (increase_radius_until_radius - branch_radius) / branch_radius_increase_per_layer),
          support_rests_on_model(! mesh_group_settings.support_material_buildplate_only),
          xy_distance(mesh_group_settings.support_xy_distance),
          xy_min_distance(std::min(mesh_group_settings.support_xy_distance, mesh_group_settings.support_xy_distance_overhang)),
          bp_radius(mesh_group_settings.support_tree_bp_diameter / 2),
          // Increase by half a line overlap, but not faster than 40 degrees angle (0 degrees means zero increase in radius).
          bp_radius_increase_per_layer(std::min(tan(0.7) * layer_height, 0.5 * support_line_width)),
          z_distance_bottom_layers(size_t(round(double(mesh_group_settings.support_bottom_distance) / double(layer_height)))),
          z_distance_top_layers(size_t(round(double(mesh_group_settings.support_top_distance) / double(layer_height)))),
    //              support_infill_angles(mesh_group_settings.support_infill_angles),
          support_roof_angles(mesh_group_settings.support_roof_angles),
          roof_pattern(mesh_group_settings.support_roof_pattern),
          support_pattern(mesh_group_settings.support_pattern),
          support_roof_line_width(mesh_group_settings.support_roof_line_width),
          support_line_spacing(mesh_group_settings.support_line_spacing),
          support_bottom_offset(mesh_group_settings.support_bottom_offset),
          support_wall_count(mesh_group_settings.support_wall_count),
          resolution(mesh_group_settings.resolution),
          support_roof_line_distance(mesh_group_settings.support_roof_line_distance), // in the end the actual infill has to be calculated to subtract interface from support areas according to interface_preference.
          settings(mesh_group_settings),
          min_feature_size(mesh_group_settings.min_feature_size)
    {
        // At least one tip layer must be defined.
        assert(tip_layers > 0);
    
        layer_start_bp_radius = (bp_radius - branch_radius) / bp_radius_increase_per_layer;
    
        if (TreeSupportSettings::zero_top_z_gap) {
            // safeOffsetInc can only work in steps of the size xy_min_distance in the worst case => xy_min_distance has to be a bit larger than 0 in this worst case and should be large enough for performance to not suffer extremely
            // When for all meshes the z bottom and top distance is more than one layer though the worst case is xy_min_distance + min_feature_size
            // This is not the best solution, but the only one to ensure areas can not lag though walls at high maximum_move_distance.
            xy_min_distance = std::max(xy_min_distance, scaled<coord_t>(0.1));
            xy_distance     = std::max(xy_distance, xy_min_distance);
        }
    
    //            const std::unordered_map<std::string, InterfacePreference> interface_map = { { "support_area_overwrite_interface_area", InterfacePreference::SupportAreaOverwritesInterface }, { "interface_area_overwrite_support_area", InterfacePreference::InterfaceAreaOverwritesSupport }, { "support_lines_overwrite_interface_area", InterfacePreference::SupportLinesOverwriteInterface }, { "interface_lines_overwrite_support_area", InterfacePreference::InterfaceLinesOverwriteSupport }, { "nothing", InterfacePreference::Nothing } };
    //            interface_preference = interface_map.at(mesh_group_settings.get<std::string>("support_interface_priority"));
    //FIXME this was the default
    //            interface_preference = InterfacePreference::SupportLinesOverwriteInterface;
        //interface_preference = InterfacePreference::SupportAreaOverwritesInterface;
        interface_preference = InterfacePreference::InterfaceAreaOverwritesSupport;
    
        if (slicing_params.raft_layers() > 0) {
            // Fill in raft_layers with the heights of the layers below the first object layer.
            // First layer
            double z = slicing_params.first_print_layer_height;
            this->raft_layers.emplace_back(z);
            // Raft base layers
            for (size_t i = 1; i < slicing_params.base_raft_layers; ++ i) {
                z += slicing_params.base_raft_layer_height;
                this->raft_layers.emplace_back(z);
            }
            // Raft interface layers
            for (size_t i = 0; i + 1 < slicing_params.interface_raft_layers; ++ i) {
                z += slicing_params.interface_raft_layer_height;
                this->raft_layers.emplace_back(z);
            }
            // Raft contact layer
            if (slicing_params.raft_layers() > 1) {
                z = slicing_params.raft_contact_top_z;
                this->raft_layers.emplace_back(z);
            }
            if (double dist_to_go = slicing_params.object_print_z_min - z; dist_to_go > EPSILON) {
                // Layers between the raft contacts and bottom of the object.
                // ORCA: Bias by EPSILON so near-equal gaps do not get an extra split from FP noise.
                auto nsteps = int(ceil((dist_to_go - EPSILON) / slicing_params.max_suport_layer_height));
                double step = dist_to_go / nsteps;
                for (int i = 0; i < nsteps; ++ i) {
                    z += step;
                    this->raft_layers.emplace_back(z);
                }
            }
        }
    }

Here is the call graph for this function:

Member Function Documentation

◆ getRadius()

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::getRadius	(	size_t	distance_to_top,
		const double	elephant_foot_increases = 0 ) const

inlinenodiscard

Get the Radius part will have based on numeric values.

Parameters

distance_to_top[in]	The effective distance_to_top of the element
elephant_foot_increases[in]	The elephant_foot_increases of the element.

Returns: The radius an element with these attributes would have.

    {
        return (distance_to_top <= tip_layers ? min_radius + (branch_radius - min_radius) * distance_to_top / tip_layers : // tip
                       branch_radius + // base
                       (distance_to_top - tip_layers) * branch_radius_increase_per_layer)
               + // gradual increase
               elephant_foot_increases * (std::max(bp_radius_increase_per_layer - branch_radius_increase_per_layer, 0.0));
    }

References bp_radius_increase_per_layer, branch_radius, branch_radius_increase_per_layer, min_radius, and tip_layers.

Referenced by Slic3r::TreeSupport3D::TreeModelVolumes::TreeModelVolumes(), Slic3r::TreeSupport3D::convert_lines_to_internal(), Slic3r::TreeSupport3D::evaluate_point_for_next_layer_function(), Slic3r::TreeSupport3D::increase_single_area(), Slic3r::TreeSupport3D::TreeModelVolumes::precalculate(), Slic3r::TreeSupport3D::sample_overhang_area(), Slic3r::TreeSupport3D::support_element_collision_radius(), and Slic3r::TreeSupport3D::support_element_radius().

Here is the caller graph for this function:

◆ operator==()

bool Slic3r::TreeSupport3D::TreeSupportSettings::operator== ( const TreeSupportSettings & other ) const

inline

    {
        return branch_radius == other.branch_radius && tip_layers == other.tip_layers && branch_radius_increase_per_layer == other.branch_radius_increase_per_layer && layer_start_bp_radius == other.layer_start_bp_radius && bp_radius == other.bp_radius && 
               // as a recalculation of the collision areas is required to set a new min_radius.
               bp_radius_increase_per_layer == other.bp_radius_increase_per_layer && min_radius == other.min_radius && xy_min_distance == other.xy_min_distance &&
               xy_distance - xy_min_distance == other.xy_distance - other.xy_min_distance && // if the delta of xy_min_distance and xy_distance is different the collision areas have to be recalculated.
               support_rests_on_model == other.support_rests_on_model && increase_radius_until_layer == other.increase_radius_until_layer && min_dtt_to_model == other.min_dtt_to_model && max_to_model_radius_increase == other.max_to_model_radius_increase && maximum_move_distance == other.maximum_move_distance && maximum_move_distance_slow == other.maximum_move_distance_slow && z_distance_bottom_layers == other.z_distance_bottom_layers && support_line_width == other.support_line_width && 
               support_line_spacing == other.support_line_spacing && support_roof_line_width == other.support_roof_line_width && // can not be set on a per-mesh basis currently, so code to enable processing different roof line width in the same iteration seems useless.
               support_bottom_offset == other.support_bottom_offset && support_wall_count == other.support_wall_count && support_pattern == other.support_pattern && roof_pattern == other.roof_pattern && // can not be set on a per-mesh basis currently, so code to enable processing different roof patterns in the same iteration seems useless.
               support_roof_angles == other.support_roof_angles && 
               //support_infill_angles == other.support_infill_angles && 
               increase_radius_until_radius == other.increase_radius_until_radius && support_bottom_layers == other.support_bottom_layers && layer_height == other.layer_height && z_distance_top_layers == other.z_distance_top_layers && resolution == other.resolution && // Infill generation depends on deviation and resolution.
               support_roof_line_distance == other.support_roof_line_distance && interface_preference == other.interface_preference
               && min_feature_size == other.min_feature_size // interface_preference should be identical to ensure the tree will correctly interact with the roof.
               // The infill class now wants the settings object and reads a lot of settings, and as the infill class is used to calculate support roof lines for interface-preference. Not all of these may be required to be identical, but as I am not sure, better safe than sorry
#if 0
                && (interface_preference == InterfacePreference::InterfaceAreaOverwritesSupport || interface_preference == InterfacePreference::SupportAreaOverwritesInterface
                // Perimeter generator parameters
                   || 
                        (settings.get<bool>("fill_outline_gaps") == other.settings.get<bool>("fill_outline_gaps") && 
                         settings.get<coord_t>("min_bead_width") == other.settings.get<coord_t>("min_bead_width") && 
                         settings.get<double>("wall_transition_angle") == other.settings.get<double>("wall_transition_angle") && 
                         settings.get<coord_t>("wall_transition_length") == other.settings.get<coord_t>("wall_transition_length") && 
                         settings.get<Ratio>("wall_split_middle_threshold") == other.settings.get<Ratio>("wall_split_middle_threshold") && 
                         settings.get<Ratio>("wall_add_middle_threshold") == other.settings.get<Ratio>("wall_add_middle_threshold") && 
                         settings.get<int>("wall_distribution_count") == other.settings.get<int>("wall_distribution_count") && 
                         settings.get<coord_t>("wall_transition_filter_distance") == other.settings.get<coord_t>("wall_transition_filter_distance") && 
                         settings.get<coord_t>("wall_transition_filter_deviation") == other.settings.get<coord_t>("wall_transition_filter_deviation") && 
                         settings.get<coord_t>("wall_line_width_x") == other.settings.get<coord_t>("wall_line_width_x") && 
                         settings.get<int>("meshfix_maximum_extrusion_area_deviation") == other.settings.get<int>("meshfix_maximum_extrusion_area_deviation"))
                    )
#endif
               && raft_layers == other.raft_layers
            ;
    }

References TreeSupportSettings(), bp_radius, bp_radius_increase_per_layer, branch_radius, branch_radius_increase_per_layer, increase_radius_until_layer, increase_radius_until_radius, interface_preference, Slic3r::TreeSupport3D::InterfaceAreaOverwritesSupport, layer_height, layer_start_bp_radius, max_to_model_radius_increase, maximum_move_distance, maximum_move_distance_slow, min_dtt_to_model, min_feature_size, min_radius, raft_layers, resolution, roof_pattern, settings, support_bottom_layers, support_bottom_offset, support_line_spacing, support_line_width, support_pattern, support_rests_on_model, support_roof_angles, support_roof_line_distance, support_roof_line_width, support_wall_count, Slic3r::TreeSupport3D::SupportAreaOverwritesInterface, tip_layers, xy_distance, xy_min_distance, z_distance_bottom_layers, and z_distance_top_layers.

Here is the call graph for this function:

◆ recommendedMinRadius()

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::recommendedMinRadius ( LayerIndex layer_idx ) const

inlinenodiscard

Get the Radius an element should at least have at a given layer.

Parameters

layer_idx[in] The layer.

Returns: The radius every element should aim to achieve.

    {
        double num_layers_widened = layer_start_bp_radius - layer_idx;
        return num_layers_widened > 0 ? branch_radius + num_layers_widened * bp_radius_increase_per_layer : 0;
    }

References bp_radius_increase_per_layer, branch_radius, and layer_start_bp_radius.

Referenced by Slic3r::TreeSupport3D::increase_single_area(), and Slic3r::TreeSupport3D::TreeModelVolumes::precalculate().

Here is the caller graph for this function:

Member Data Documentation

◆ bp_radius

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::bp_radius

A minimum radius a tree trunk should expand to at the buildplate if possible.

Referenced by TreeSupportSettings(), and operator==().

◆ bp_radius_increase_per_layer

double Slic3r::TreeSupport3D::TreeSupportSettings::bp_radius_increase_per_layer

How much one is allowed to increase the tree branch radius close to print bed to reach the required bp_radius at layer 0. Note that this radius increase will not happen in the tip, to ensure the tip is structurally sound.

Referenced by TreeSupportSettings(), getRadius(), Slic3r::TreeSupport3D::increase_single_area(), Slic3r::TreeSupport3D::merge_support_element_states(), operator==(), and recommendedMinRadius().

◆ branch_radius

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::branch_radius

Radius of a branch when it has left the tip.

Referenced by TreeSupportSettings(), getRadius(), Slic3r::TreeSupport3D::increase_single_area(), operator==(), Slic3r::TreeSupport3D::TreeModelVolumes::precalculate(), and recommendedMinRadius().

◆ branch_radius_increase_per_layer

double Slic3r::TreeSupport3D::TreeSupportSettings::branch_radius_increase_per_layer

How much a branch radius increases with each layer to guarantee the prescribed tree widening.

Referenced by TreeSupportSettings(), getRadius(), Slic3r::TreeSupport3D::increase_single_area(), Slic3r::TreeSupport3D::merge_support_element_states(), and operator==().

◆ increase_radius_until_layer

size_t Slic3r::TreeSupport3D::TreeSupportSettings::increase_radius_until_layer

Same as increase_radius_until_radius, but contains the DTT at which the radius will be reached.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::getEffectiveDTT(), and operator==().

◆ increase_radius_until_radius

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::increase_radius_until_radius

Increase radius in the resulting drawn branches, even if the avoidance does not allow it. Will be cut later to still fit.

Referenced by Slic3r::TreeSupport3D::TreeModelVolumes::TreeModelVolumes(), TreeSupportSettings(), Slic3r::TreeSupport3D::increase_single_area(), and operator==().

◆ interface_preference

InterfacePreference Slic3r::TreeSupport3D::TreeSupportSettings::interface_preference

Referenced by TreeSupportSettings(), and operator==().

◆ layer_height

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::layer_height

Height of a single layer.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::create_layer_pathing(), Slic3r::TreeSupport3D::generate_initial_areas(), Slic3r::TreeSupport::move_bounds_to_contact_nodes(), and operator==().

◆ layer_start_bp_radius

LayerIndex Slic3r::TreeSupport3D::TreeSupportSettings::layer_start_bp_radius

The layer index at which an increase in radius may be required to reach the bp_radius.

Referenced by TreeSupportSettings(), operator==(), and recommendedMinRadius().

◆ max_to_model_radius_increase

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::max_to_model_radius_increase

How much a branch resting on the model may grow in radius by merging with branches that can reach the buildplate.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::merge_influence_areas_two_elements(), and operator==().

◆ maximum_move_distance

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::maximum_move_distance

How far an influence area may move outward every layer at most.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::create_layer_pathing(), Slic3r::TreeSupport3D::generate_support_areas(), and operator==().

◆ maximum_move_distance_slow

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::maximum_move_distance_slow

How far every influence area will move outward every layer if possible.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::create_layer_pathing(), Slic3r::TreeSupport3D::generate_support_areas(), operator==(), and Slic3r::TreeSupport3D::organic_smooth_branches_avoid_collisions().

◆ min_dtt_to_model

size_t Slic3r::TreeSupport3D::TreeSupportSettings::min_dtt_to_model

If smaller (in layers) than that, all branches to model will be deleted.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::create_nodes_from_area(), Slic3r::TreeSupport3D::merge_influence_areas_two_elements(), and operator==().

◆ min_feature_size

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::min_feature_size

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::increase_single_area(), and operator==().

◆ min_radius

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::min_radius

smallest allowed radius, required to ensure that even at DTT 0 every circle will still be printed

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::generate_initial_areas(), getRadius(), operator==(), and Slic3r::TreeSupport3D::sample_overhang_area().

◆ raft_layers

std::vector<coordf_t> Slic3r::TreeSupport3D::TreeSupportSettings::raft_layers

Referenced by Slic3r::TreeSupport3D::TreeModelVolumes::TreeModelVolumes(), TreeSupportSettings(), Slic3r::TreeSupport3D::generate_initial_areas(), Slic3r::TreeSupport3D::generate_raft_contact(), Slic3r::TreeSupport3D::generate_support_areas(), Slic3r::TreeSupport3D::layer_idx_ceil(), Slic3r::TreeSupport3D::layer_idx_floor(), Slic3r::TreeSupport3D::layer_z(), operator==(), and Slic3r::TreeSupport3D::precalculate().

◆ resolution

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::resolution

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::generate_support_infill_lines(), and operator==().

◆ roof_pattern

SupportMaterialInterfacePattern Slic3r::TreeSupport3D::TreeSupportSettings::roof_pattern

Pattern used in the support roof. May contain non relevant data if support roof is disabled.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::generate_support_infill_lines(), and operator==().

◆ settings

TreeSupportMeshGroupSettings Slic3r::TreeSupport3D::TreeSupportSettings::settings

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::generate_support_infill_lines(), and operator==().

◆ support_bottom_layers

size_t Slic3r::TreeSupport3D::TreeSupportSettings::support_bottom_layers

Amount of bottom layers. 0 if disabled.

Referenced by TreeSupportSettings(), and operator==().

◆ support_bottom_offset

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::support_bottom_offset

Offset applied to the support floor area.

Referenced by TreeSupportSettings(), and operator==().

◆ support_line_spacing

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::support_line_spacing

Distance between support infill lines.

Referenced by TreeSupportSettings(), and operator==().

◆ support_line_width

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::support_line_width

Width of a single line of support.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::generate_initial_areas(), Slic3r::TreeSupport3D::generate_support_infill_lines(), operator==(), and Slic3r::TreeSupport3D::sample_overhang_area().

◆ support_pattern

SupportMaterialPattern Slic3r::TreeSupport3D::TreeSupportSettings::support_pattern

Pattern used in the support infill.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::generate_support_infill_lines(), and operator==().

◆ support_rests_on_model

bool Slic3r::TreeSupport3D::TreeSupportSettings::support_rests_on_model

True if the branches may connect to the model.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::convert_lines_to_internal(), Slic3r::TreeSupport3D::evaluate_point_for_next_layer_function(), Slic3r::TreeSupport3D::get_avoidance_status(), Slic3r::TreeSupport3D::increase_single_area(), Slic3r::TreeSupport3D::merge_influence_areas_two_elements(), operator==(), and Slic3r::TreeSupport3D::sample_overhang_area().

◆ support_roof_angles

std::vector<double> Slic3r::TreeSupport3D::TreeSupportSettings::support_roof_angles

User specified angles for the support infill.

User specified angles for the support roof infill.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::generate_support_infill_lines(), and operator==().

◆ support_roof_line_distance

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::support_roof_line_distance

Referenced by TreeSupportSettings(), and operator==().

◆ support_roof_line_width

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::support_roof_line_width

Line width of the support roof.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::generate_support_infill_lines(), and operator==().

◆ support_wall_count

int Slic3r::TreeSupport3D::TreeSupportSettings::support_wall_count

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::generate_support_infill_lines(), and operator==().

◆ tip_layers

size_t Slic3r::TreeSupport3D::TreeSupportSettings::tip_layers

Amount of effectiveDTT increases are required to reach branch radius.

Referenced by TreeSupportSettings(), getRadius(), operator==(), and Slic3r::TreeSupport3D::TreeModelVolumes::precalculate().

◆ xy_distance

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::xy_distance

How far should support be from the model.

◆ xy_min_distance

coord_t Slic3r::TreeSupport3D::TreeSupportSettings::xy_min_distance

minimum xy_distance. Only relevant when Z overrides XY, otherwise equal to xy_distance-

Referenced by Slic3r::TreeSupport3D::RichInterfacePlacer::RichInterfacePlacer(), Slic3r::TreeSupport3D::TreeModelVolumes::TreeModelVolumes(), TreeSupportSettings(), Slic3r::TreeSupport3D::convert_lines_to_internal(), Slic3r::TreeSupport3D::evaluate_point_for_next_layer_function(), Slic3r::TreeSupport3D::generate_initial_areas(), Slic3r::TreeSupport3D::get_avoidance_status(), Slic3r::TreeSupport3D::increase_single_area(), operator==(), and Slic3r::TreeSupport3D::sample_overhang_area().

◆ z_distance_bottom_layers

size_t Slic3r::TreeSupport3D::TreeSupportSettings::z_distance_bottom_layers

Amount of layers distance required from the top of the model to the bottom of a support structure.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::increase_single_area(), and operator==().

◆ z_distance_top_layers

size_t Slic3r::TreeSupport3D::TreeSupportSettings::z_distance_top_layers

Amount of layers distance required the top of the support to the model.

Referenced by TreeSupportSettings(), Slic3r::TreeSupport3D::generate_initial_areas(), Slic3r::TreeSupport3D::increase_single_area(), operator==(), and Slic3r::TreeSupport3D::precalculate().

◆ zero_top_z_gap

bool Slic3r::TreeSupport3D::TreeSupportSettings::zero_top_z_gap = false

inlinestatic

Referenced by TreeSupportSettings(), and Slic3r::TreeSupport3D::group_meshes().

The documentation for this struct was generated from the following file:

/home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Support/TreeSupportCommon.hpp

	OrcaSlicer latest OrcaSlicer

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TreeSupportSettings() [1/2]

◆ TreeSupportSettings() [2/2]

Member Function Documentation

◆ getRadius()

◆ operator==()

◆ recommendedMinRadius()

Member Data Documentation

◆ bp_radius

◆ bp_radius_increase_per_layer

◆ branch_radius

◆ branch_radius_increase_per_layer

◆ increase_radius_until_layer

◆ increase_radius_until_radius

◆ interface_preference

◆ layer_height

◆ layer_start_bp_radius

◆ max_to_model_radius_increase

◆ maximum_move_distance

◆ maximum_move_distance_slow

◆ min_dtt_to_model

◆ min_feature_size

◆ min_radius

◆ raft_layers

◆ resolution

◆ roof_pattern

◆ settings

◆ support_bottom_layers

◆ support_bottom_offset

◆ support_line_spacing

◆ support_line_width

◆ support_pattern

◆ support_rests_on_model

◆ support_roof_angles

◆ support_roof_line_distance

◆ support_roof_line_width

◆ support_wall_count

◆ tip_layers

◆ xy_distance

◆ xy_min_distance

◆ z_distance_bottom_layers

◆ z_distance_top_layers

◆ zero_top_z_gap