Slic3r::ArrangeParams Struct Reference

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

Collaboration diagram for Slic3r::ArrangeParams:

Public Member Functions
	ArrangeParams ()=default
	ArrangeParams (coord_t md)
std::string	to_json () const

Public Attributes
coord_t	min_obj_distance = 0
	The minimum distance which is allowed for any pair of items on the print bed in any direction.
float	accuracy = 1.f
	The accuracy of optimization. Goes from 0.0 to 1.0 and scales performance as well.
bool	parallel = true
	Allow parallel execution.
bool	allow_rotations = false
bool	do_final_align = true
bool	allow_multi_materials_on_same_plate = true
bool	avoid_extrusion_cali_region = true
bool	is_seq_print = false
bool	align_to_y_axis = false
float	bed_shrink_x = 1
float	bed_shrink_y = 1
float	brim_skirt_distance = 0
float	clearance_height_to_rod = 0
float	clearance_height_to_lid = 0
float	clearance_radius = 0
float	object_skirt_offset = 0
float	nozzle_height = 0
float	printable_height = 256.0
Vec2d	align_center { 0.5,0.5 }
bool	is_belt = false
int	belt_axis = 1
bool	belt_reversed = false
float	belt_tilt_slope = 1.f
ArrangePolygons	excluded_regions
ArrangePolygons	nonprefered_regions
std::function< void(unsigned, std::string)>	progressind
	Progress indicator callback called when an object gets packed. The unsigned argument is the number of items remaining to pack.
std::function< void(const ArrangePolygon &)>	on_packed
std::function< bool(void)>	stopcondition
	A predicate returning true if abort is needed.

Detailed Description

Constructor & Destructor Documentation

ArrangeParams() [1/2]

Slic3r::arrangement::ArrangeParams::ArrangeParams ( )

default

ArrangeParams() [2/2]

Slic3r::arrangement::ArrangeParams::ArrangeParams ( coord_t md )

inlineexplicit

: min_obj_distance(md) {}

Member Function Documentation

to_json()

std::string Slic3r::arrangement::ArrangeParams::to_json ( ) const

inline

                             {
        std::string ret = "{";
        ret += "\"min_obj_distance\":" + std::to_string(min_obj_distance) + ",";
        ret += "\"accuracy\":" + std::to_string(accuracy) + ",";
        ret += "\"parallel\":" + std::to_string(parallel) + ",";
        ret += "\"allow_rotations\":" + std::to_string(allow_rotations) + ",";
        ret += "\"do_final_align\":" + std::to_string(do_final_align) + ",";
        ret += "\"allow_multi_materials_on_same_plate\":" + std::to_string(allow_multi_materials_on_same_plate) + ",";
        ret += "\"avoid_extrusion_cali_region\":" + std::to_string(avoid_extrusion_cali_region) + ",";
        ret += "\"is_seq_print\":" + std::to_string(is_seq_print) + ",";
        ret += "\"bed_shrink_x\":" + std::to_string(bed_shrink_x) + ",";
        ret += "\"bed_shrink_y\":" + std::to_string(bed_shrink_y) + ",";
        ret += "\"brim_skirt_distance\":" + std::to_string(brim_skirt_distance) + ",";
        ret += "\"clearance_height_to_rod\":" + std::to_string(clearance_height_to_rod) + ",";
        ret += "\"clearance_height_to_lid\":" + std::to_string(clearance_height_to_lid) + ",";
        ret += "\"clearance_radius\":" + std::to_string(clearance_radius) + ",";
        ret += "\"printable_height\":" + std::to_string(printable_height) + ",";
        return ret;
    }

Member Data Documentation

accuracy

float Slic3r::arrangement::ArrangeParams::accuracy = 1.f

The accuracy of optimization. Goes from 0.0 to 1.0 and scales performance as well.

align_center

Vec2d Slic3r::arrangement::ArrangeParams::align_center { 0.5,0.5 }

{ 0.5,0.5 };

align_to_y_axis

bool Slic3r::arrangement::ArrangeParams::align_to_y_axis = false

allow_multi_materials_on_same_plate

bool Slic3r::arrangement::ArrangeParams::allow_multi_materials_on_same_plate = true

allow_rotations

bool Slic3r::arrangement::ArrangeParams::allow_rotations = false

avoid_extrusion_cali_region

bool Slic3r::arrangement::ArrangeParams::avoid_extrusion_cali_region = true

bed_shrink_x

float Slic3r::arrangement::ArrangeParams::bed_shrink_x = 1

bed_shrink_y

float Slic3r::arrangement::ArrangeParams::bed_shrink_y = 1

belt_axis

int Slic3r::arrangement::ArrangeParams::belt_axis = 1

belt_reversed

bool Slic3r::arrangement::ArrangeParams::belt_reversed = false

belt_tilt_slope

float Slic3r::arrangement::ArrangeParams::belt_tilt_slope = 1.f

brim_skirt_distance

float Slic3r::arrangement::ArrangeParams::brim_skirt_distance = 0

clearance_height_to_lid

float Slic3r::arrangement::ArrangeParams::clearance_height_to_lid = 0

clearance_height_to_rod

float Slic3r::arrangement::ArrangeParams::clearance_height_to_rod = 0

clearance_radius

float Slic3r::arrangement::ArrangeParams::clearance_radius = 0

do_final_align

bool Slic3r::arrangement::ArrangeParams::do_final_align = true

excluded_regions

ArrangePolygons Slic3r::arrangement::ArrangeParams::excluded_regions

is_belt

bool Slic3r::arrangement::ArrangeParams::is_belt = false

is_seq_print

bool Slic3r::arrangement::ArrangeParams::is_seq_print = false

min_obj_distance

coord_t Slic3r::arrangement::ArrangeParams::min_obj_distance = 0

The minimum distance which is allowed for any pair of items on the print bed in any direction.

nonprefered_regions

ArrangePolygons Slic3r::arrangement::ArrangeParams::nonprefered_regions

nozzle_height

float Slic3r::arrangement::ArrangeParams::nozzle_height = 0

object_skirt_offset

float Slic3r::arrangement::ArrangeParams::object_skirt_offset = 0

on_packed

std::function<void(const ArrangePolygon &)> Slic3r::arrangement::ArrangeParams::on_packed

parallel

bool Slic3r::arrangement::ArrangeParams::parallel = true

Allow parallel execution.

printable_height

float Slic3r::arrangement::ArrangeParams::printable_height = 256.0

progressind

std::function<void(unsigned, std::string)> Slic3r::arrangement::ArrangeParams::progressind

Initial value:

= [](unsigned st, std::string str = "") {
        std::cout << "st=" << st << ", " << str << std::endl;
    }

Progress indicator callback called when an object gets packed. The unsigned argument is the number of items remaining to pack.

                                                                                             {
        std::cout << "st=" << st << ", " << str << std::endl;
    };

stopcondition

std::function<bool(void)> Slic3r::arrangement::ArrangeParams::stopcondition

A predicate returning true if abort is needed.

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Arrange.hpp