Slic3r::arrangement Namespace Reference

Classes
class	AutoArranger
class	CircleBed
	A geometry abstraction for a circular print bed. Similarly to BoundingBox. More...
struct	InfiniteBed
	Representing an unbounded bed. More...
struct	ArrangePolygon
	Input/Output structure for the arrange() function. The poly field will not be modified during arrangement. Instead, the translation and rotation fields will mark the needed transformation for the polygon to be in the arranged position. These can also be set to an initial offset and rotation. More...
struct	ArrangeParams

Typedefs
using	Item = _Item<ExPolygon>
using	Box = _Box<Point>
using	Circle = _Circle<Point>
using	MultiPolygon = ExPolygons
using	SpatElement = std::pair<Box, unsigned>
using	SpatIndex = bgi::rtree< SpatElement, bgi::rstar<16, 4> >
using	ItemGroup = std::vector<std::reference_wrapper<Item>>
using	ArrangePolygons = std::vector<ArrangePolygon>

Functions
static bool	z_ranges_overlap (double first_min, double first_max, double second_min, double second_max)
template<typename T>
static bool	bed_exclusion_applies_impl (const T &item, const T &fixed_item)
bool	has_bed_exclusion_regions (const ArrangePolygons &polygons)
bool	bed_exclusion_applies (const ArrangePolygon &item, const ArrangePolygon &fixed_item)
void	update_arrange_params (ArrangeParams &params, const DynamicPrintConfig *print_cfg, const ArrangePolygons &selected)
void	update_selected_items_inflation (ArrangePolygons &selected, const DynamicPrintConfig *print_cfg, ArrangeParams &params)
void	update_unselected_items_inflation (ArrangePolygons &unselected, const DynamicPrintConfig *print_cfg, const ArrangeParams &params)
void	update_selected_items_axis_align (ArrangePolygons &selected, const DynamicPrintConfig *print_cfg, const ArrangeParams &params)
Points	get_shrink_bedpts (const DynamicPrintConfig *print_cfg, const ArrangeParams &params)
template<class PConf>
void	fill_config (PConf &pcfg, const ArrangeParams &params)
static double	fixed_overfit (const std::tuple< double, Box > &result, const Box &binbb)
static double	fixed_overfit_topright_sliding (const std::tuple< double, Box > &result, const Box &binbb, const std::vector< Box > &excluded_boxes)
template<class Bin>
void	remove_large_items (std::vector< Item > &items, Bin &&bin)
template<class S>
Radians	min_area_boundingbox_rotation (const S &sh)
template<class S>
Radians	fit_into_box_rotation (const S &sh, const _Box< TPoint< S > > &box)
template<class BinT>
void	_arrange (std::vector< Item > &shapes, std::vector< Item > &excludes, const BinT &bin, const ArrangeParams &params, std::function< void(unsigned, std::string)> progressfn, std::function< bool()> stopfn)
Box	to_nestbin (const BoundingBox &bb)
Circle	to_nestbin (const CircleBed &c)
ExPolygon	to_nestbin (const Polygon &p)
Box	to_nestbin (const InfiniteBed &bed)
coord_t	width (const BoundingBox &box)
coord_t	height (const BoundingBox &box)
double	area (const BoundingBox &box)
double	poly_area (const Points &pts)
double	distance_to (const Point &p1, const Point &p2)
static CircleBed	to_circle (const Point &center, const Points &points)
static void	process_arrangeable (const ArrangePolygon &arrpoly, std::vector< Item > &outp)
template<class Fn>
auto	call_with_bed (const Points &bed, Fn &&fn)
template<>
void	arrange (ArrangePolygons &items, const ArrangePolygons &excludes, const Points &bed, const ArrangeParams &params)
template<class BedT>
void	arrange (ArrangePolygons &arrangables, const ArrangePolygons &excludes, const BedT &bed, const ArrangeParams &params)
template void	arrange (ArrangePolygons &items, const ArrangePolygons &excludes, const BoundingBox &bed, const ArrangeParams &params)
template void	arrange (ArrangePolygons &items, const ArrangePolygons &excludes, const CircleBed &bed, const ArrangeParams &params)
template void	arrange (ArrangePolygons &items, const ArrangePolygons &excludes, const Polygon &bed, const ArrangeParams &params)
template void	arrange (ArrangePolygons &items, const ArrangePolygons &excludes, const InfiniteBed &bed, const ArrangeParams &params)
template<class TBed>
void	arrange (ArrangePolygons &items, const ArrangePolygons &excludes, const TBed &bed, const ArrangeParams &params={})
	Arranges the input polygons.
template<>
void	arrange (ArrangePolygons &items, const ArrangePolygons &excludes, const Points &bed, const ArrangeParams &params)
void	arrange (ArrangePolygons &items, const Points &bed, const ArrangeParams &params={})
void	arrange (ArrangePolygons &items, const BoundingBox &bed, const ArrangeParams &params={})
void	arrange (ArrangePolygons &items, const CircleBed &bed, const ArrangeParams &params={})
void	arrange (ArrangePolygons &items, const Polygon &bed, const ArrangeParams &params={})
void	arrange (ArrangePolygons &items, const InfiniteBed &bed, const ArrangeParams &params={})

Variables
const double	BIG_ITEM_TRESHOLD = 0.02
static const constexpr int	UNARRANGED = -1
	A logical bed representing an object not being arranged. Either the arrange has not yet successfully run on this ArrangePolygon or it could not fit the object due to overly large size or invalid geometry.

Typedef Documentation

ArrangePolygons

using Slic3r::arrangement::ArrangePolygons = std::vector<ArrangePolygon>

Box

using Slic3r::arrangement::Box = _Box<Point>

Circle

using Slic3r::arrangement::Circle = _Circle<Point>

Item

using Slic3r::arrangement::Item = _Item<ExPolygon>

ItemGroup

using Slic3r::arrangement::ItemGroup = std::vector<std::reference_wrapper<Item>>

MultiPolygon

using Slic3r::arrangement::MultiPolygon = ExPolygons

SpatElement

using Slic3r::arrangement::SpatElement = std::pair<Box, unsigned>

SpatIndex

using Slic3r::arrangement::SpatIndex = bgi::rtree< SpatElement, bgi::rstar<16, 4> >

Function Documentation

_arrange()

template<class BinT>

void Slic3r::arrangement::_arrange	(	std::vector< Item > &	shapes,
		std::vector< Item > &	excludes,
		const BinT &	bin,
		const ArrangeParams &	params,
		std::function< void(unsigned, std::string)>	progressfn,
		std::function< bool()>	stopfn )

{
    // Integer ceiling the min distance from the bed perimeters
    coord_t md = params.min_obj_distance;
    md = md / 2;
 
    auto corrected_bin = bin;
    //sl::offset(corrected_bin, md);
    ArrangeParams mod_params = params;
    mod_params.min_obj_distance = 0;  // items are already inflated
 
    AutoArranger<BinT> arranger{corrected_bin, mod_params, progressfn, stopfn};
 
    remove_large_items(excludes, corrected_bin);
 
    // If there is something on the plate
    if (!excludes.empty()) arranger.preload(excludes);
 
    std::vector<std::reference_wrapper<Item>> inp;
    inp.reserve(shapes.size() + excludes.size());
    for (auto &itm : shapes  ) inp.emplace_back(itm);
    for (auto &itm : excludes) inp.emplace_back(itm);
 
    // Use the minimum bounding box rotation as a starting point.
    // TODO: This only works for convex hull. If we ever switch to concave
    // polygon nesting, a convex hull needs to be calculated.
    if (params.allow_rotations) {
        for (auto &itm : shapes) {
            itm.rotation(min_area_boundingbox_rotation(itm.transformedShape()));
 
            // If the item is too big, try to find a rotation that makes it fit
            if constexpr (std::is_same_v<BinT, Box>) {
                auto bb = itm.boundingBox();
                if (bb.width() >= bin.width() || bb.height() >= bin.height())
                    itm.rotate(fit_into_box_rotation(itm.transformedShape(), bin));
            }
        }
    }
 
    arranger(inp.begin(), inp.end());
    for (Item &itm : inp) itm.inflation(0);
}

References _arrange(), Slic3r::arrangement::ArrangeParams::allow_rotations, fit_into_box_rotation(), min_area_boundingbox_rotation(), Slic3r::arrangement::ArrangeParams::min_obj_distance, Slic3r::arrangement::AutoArranger< TBin >::preload(), and remove_large_items().

Referenced by _arrange(), and arrange().

Here is the call graph for this function:

Here is the caller graph for this function:

area()

double Slic3r::arrangement::area ( const BoundingBox & box )

inline

{ return double(width(box)) * height(box); }

References height(), and width().

Here is the call graph for this function:

arrange() [1/13]

template<class BedT>

void Slic3r::arrangement::arrange	(	ArrangePolygons &	arrangables,
		const ArrangePolygons &	excludes,
		const BedT &	bed,
		const ArrangeParams &	params )

{
    std::vector<Item> items, fixeditems;
    items.reserve(arrangables.size());
 
    for (ArrangePolygon &arrangeable : arrangables)
        process_arrangeable(arrangeable, items);
 
    for (const ArrangePolygon &fixed: excludes)
        process_arrangeable(fixed, fixeditems);
 
    for (Item &itm : fixeditems) itm.inflate(scaled(-2. * EPSILON));
 
    _arrange(items, fixeditems, to_nestbin(bed), params, params.progressind, params.stopcondition);
 
    for(size_t i = 0; i < items.size(); ++i) {
        Point tr = items[i].translation();
        arrangables[i].translation = {coord_t(tr.x()), coord_t(tr.y())};
        arrangables[i].rotation    = items[i].rotation();
        arrangables[i].bed_idx     = items[i].binId();
        arrangables[i].itemid      = items[i].itemId();  // arrange order is useful for sequential printing
    }
}

References _arrange(), EPSILON, process_arrangeable(), Slic3r::arrangement::ArrangeParams::progressind, Slic3r::scaled(), Slic3r::arrangement::ArrangeParams::stopcondition, and to_nestbin().

Here is the call graph for this function:

arrange() [2/13]

template void Slic3r::arrangement::arrange	(	ArrangePolygons &	items,
		const ArrangePolygons &	excludes,
		const BoundingBox &	bed,
		const ArrangeParams &	params )

arrange() [3/13]

template void Slic3r::arrangement::arrange	(	ArrangePolygons &	items,
		const ArrangePolygons &	excludes,
		const CircleBed &	bed,
		const ArrangeParams &	params )

arrange() [4/13]

template void Slic3r::arrangement::arrange	(	ArrangePolygons &	items,
		const ArrangePolygons &	excludes,
		const InfiniteBed &	bed,
		const ArrangeParams &	params )

arrange() [5/13]

template<>

void Slic3r::arrangement::arrange	(	ArrangePolygons &	items,
		const ArrangePolygons &	excludes,
		const Points &	bed,
		const ArrangeParams &	params )

{
    call_with_bed(bed, [&](const auto &bin) {
        arrange(items, excludes, bin, params);
    });
}

References Slic3r::Geometry::arrange(), and call_with_bed().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::arrange_objects(), Slic3r::duplicate(), Slic3r::GUI::Plater::find_new_position(), Slic3r::ImexArranger::finish(), Slic3r::GUI::ArrangeJob::process(), Slic3r::GUI::FillBedJob::process(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

arrange() [6/13]

template<>

void Slic3r::arrangement::arrange	(	ArrangePolygons &	items,
		const ArrangePolygons &	excludes,
		const Points &	bed,
		const ArrangeParams &	params )

{
    call_with_bed(bed, [&](const auto &bin) {
        arrange(items, excludes, bin, params);
    });
}

References Slic3r::Geometry::arrange(), and call_with_bed().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::arrange_objects(), Slic3r::duplicate(), Slic3r::GUI::Plater::find_new_position(), Slic3r::ImexArranger::finish(), Slic3r::GUI::ArrangeJob::process(), Slic3r::GUI::FillBedJob::process(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

arrange() [7/13]

template void Slic3r::arrangement::arrange	(	ArrangePolygons &	items,
		const ArrangePolygons &	excludes,
		const Polygon &	bed,
		const ArrangeParams &	params )

arrange() [8/13]

template<class TBed>

void Slic3r::arrangement::arrange	(	ArrangePolygons &	items,
		const ArrangePolygons &	excludes,
		const TBed &	bed,
		const ArrangeParams &	params = {} )

Arranges the input polygons.

WARNING: Currently, only convex polygons are supported by the libnest2d library which is used to do the arrangement. This might change in the future this is why the interface contains a general polygon capable to have holes.

Parameters

items

Input vector of ArrangePolygons. The transformation, rotation and bin_idx fields will be changed after the call finished and can be used to apply the result on the input polygon.

arrange() [9/13]

void Slic3r::arrangement::arrange ( ArrangePolygons & items, const BoundingBox & bed, const ArrangeParams & params = {} )

inline

{}) { arrange(items, {}, bed, params); }

arrange() [10/13]

void Slic3r::arrangement::arrange ( ArrangePolygons & items, const CircleBed & bed, const ArrangeParams & params = {} )

inline

{}) { arrange(items, {}, bed, params); }

arrange() [11/13]

void Slic3r::arrangement::arrange ( ArrangePolygons & items, const InfiniteBed & bed, const ArrangeParams & params = {} )

inline

{}) { arrange(items, {}, bed, params); }

arrange() [12/13]

void Slic3r::arrangement::arrange ( ArrangePolygons & items, const Points & bed, const ArrangeParams & params = {} )

inline

{}) { arrange(items, {}, bed, params); }

arrange() [13/13]

void Slic3r::arrangement::arrange ( ArrangePolygons & items, const Polygon & bed, const ArrangeParams & params = {} )

inline

{}) { arrange(items, {}, bed, params); }

bed_exclusion_applies()

bool Slic3r::arrangement::bed_exclusion_applies	(	const ArrangePolygon &	item,
		const ArrangePolygon &	fixed_item )

{
    return bed_exclusion_applies_impl(item, fixed_item);
}

References bed_exclusion_applies_impl().

Here is the call graph for this function:

bed_exclusion_applies_impl()

template<typename T>

bool Slic3r::arrangement::bed_exclusion_applies_impl ( const T & item, const T & fixed_item )

static

{
    if (!fixed_item.is_bed_exclusion)
        return false;
    if (item.has_z_range && fixed_item.has_z_range &&
        !z_ranges_overlap(item.z_min, item.z_max, fixed_item.z_min, fixed_item.z_max))
        return false;
 
    // Shared volumes and unresolved object mappings apply conservatively to
    // every nozzle. Otherwise only the owning physical nozzle participates.
    return fixed_item.bed_exclusion_extruder_id < 0 || item.bed_exclusion_extruder_ids.empty() ||
           std::find(item.bed_exclusion_extruder_ids.begin(), item.bed_exclusion_extruder_ids.end(),
                     fixed_item.bed_exclusion_extruder_id) != item.bed_exclusion_extruder_ids.end();
}

References z_ranges_overlap().

Referenced by bed_exclusion_applies(), and fill_config().

Here is the call graph for this function:

Here is the caller graph for this function:

call_with_bed()

template<class Fn>

auto Slic3r::arrangement::call_with_bed	(	const Points &	bed,
		Fn &&	fn )

{
    if (bed.empty())
        return fn(InfiniteBed{});
    else if (bed.size() == 1)
        return fn(InfiniteBed{bed.front()});
    else {
        auto      bb    = BoundingBox(bed);
        CircleBed circ  = to_circle(bb.center(), bed);
        auto      parea = poly_area(bed);
 
        if ((1.0 - parea / area(bb)) < 1e-3)
            return fn(bb);
        else if (!std::isnan(circ.radius()))
            return fn(circ);
        else
            return fn(Polygon(bed));
    }
}

References Slic3r::area(), call_with_bed(), poly_area(), Slic3r::arrangement::CircleBed::radius(), and to_circle().

Referenced by arrange(), and call_with_bed().

Here is the call graph for this function:

Here is the caller graph for this function:

distance_to()

double Slic3r::arrangement::distance_to ( const Point & p1, const Point & p2 )

inline

{
    double dx = p2.x() - p1.x();
    double dy = p2.y() - p1.y();
    return std::sqrt(dx*dx + dy*dy);
}

References distance_to().

Referenced by distance_to(), and to_circle().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_config()

template<class PConf>

void Slic3r::arrangement::fill_config	(	PConf &	pcfg,
		const ArrangeParams &	params )

                                                           {
 
        if (params.is_belt) {
            // Pack from the end of the belt that prints first.
            pcfg.starting_point = !params.belt_reversed    ? PConf::Alignment::BOTTOM_LEFT :
                                  params.belt_axis == 1    ? PConf::Alignment::TOP_LEFT :
                                                             PConf::Alignment::BOTTOM_RIGHT;
        }
        else if (params.is_seq_print) {
            // Start placing the items from the center of the print bed
            pcfg.starting_point = PConf::Alignment::BOTTOM_LEFT;
        }
        else {
            // Start placing the items from the center of the print bed
            pcfg.starting_point = PConf::Alignment::TOP_RIGHT;
        }
 
    if (params.do_final_align) {
        // Align the arranged pile into the center of the bin
        pcfg.alignment = PConf::Alignment::CENTER;
    }else
        pcfg.alignment = PConf::Alignment::DONT_ALIGN;
 
 
    // Try 4 angles (45 degree step) and find the one with min cost
    if (params.allow_rotations)
        pcfg.rotations = {0., PI / 4., PI/2, 3. * PI / 4. };
    else
        pcfg.rotations = {0.};
 
    // The accuracy of optimization.
    // Goes from 0.0 to 1.0 and scales performance as well
    pcfg.accuracy = params.accuracy;
 
    // Allow parallel execution.
    pcfg.parallel = params.parallel;
 
    pcfg.should_check_collision = [](const Item &candidate, const Item &packed) {
        if (packed.is_bed_exclusion)
            return bed_exclusion_applies_impl(candidate, packed);
        if (candidate.is_bed_exclusion)
            return bed_exclusion_applies_impl(packed, candidate);
        return true;
    };
 
    // BBS: excluded regions in BBS bed
    for (auto& poly : params.excluded_regions)
        process_arrangeable(poly, pcfg.m_excluded_regions);
    // BBS: nonprefered regions in BBS bed
    for (auto& poly : params.nonprefered_regions)
        process_arrangeable(poly, pcfg.m_nonprefered_regions);
    for (auto& itm : pcfg.m_excluded_regions) {
        itm.markAsFixedInBin(0);
        itm.inflate(scaled(-2. * EPSILON));
    }
}

References Slic3r::arrangement::ArrangeParams::accuracy, Slic3r::arrangement::ArrangeParams::allow_rotations, bed_exclusion_applies_impl(), Slic3r::arrangement::ArrangeParams::belt_axis, Slic3r::arrangement::ArrangeParams::belt_reversed, Slic3r::arrangement::ArrangeParams::do_final_align, EPSILON, Slic3r::arrangement::ArrangeParams::excluded_regions, fill_config(), Slic3r::arrangement::ArrangeParams::is_belt, Slic3r::arrangement::ArrangeParams::is_seq_print, Slic3r::arrangement::ArrangeParams::nonprefered_regions, Slic3r::arrangement::ArrangeParams::parallel, PI, process_arrangeable(), and Slic3r::scaled().

Referenced by Slic3r::arrangement::AutoArranger< TBin >::AutoArranger(), and fill_config().

Here is the call graph for this function:

Here is the caller graph for this function:

fit_into_box_rotation()

template<class S>

Radians Slic3r::arrangement::fit_into_box_rotation	(	const S &	sh,
		const _Box< TPoint< S > > &	box )

{
    return fitIntoBoxRotation<S, TCompute<S>, boost::rational<LargeInt>>(sh, box);
}

References fit_into_box_rotation().

Referenced by _arrange(), and fit_into_box_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

fixed_overfit()

double Slic3r::arrangement::fixed_overfit ( const std::tuple< double, Box > & result, const Box & binbb )

static

{
    double score = std::get<0>(result);
    Box pilebb  = std::get<1>(result);
    Box fullbb  = sl::boundingBox(pilebb, binbb);
    auto diff = double(fullbb.area()) - binbb.area();
    if(diff > 0) score += diff;
 
    return score;
}

References Slic3r::diff(), and fixed_overfit().

Referenced by Slic3r::arrangement::AutoArranger< TBin >::AutoArranger(), and fixed_overfit().

Here is the call graph for this function:

Here is the caller graph for this function:

fixed_overfit_topright_sliding()

double Slic3r::arrangement::fixed_overfit_topright_sliding ( const std::tuple< double, Box > & result, const Box & binbb, const std::vector< Box > & excluded_boxes )

static

{
    double score = std::get<0>(result);
    Box pilebb = std::get<1>(result);
 
    auto shift = binbb.maxCorner() - pilebb.maxCorner();
    shift.x() = std::max((coord_t)0, shift.x()); // do not allow left shift
    shift.y() = std::max((coord_t)0, shift.y()); // do not allow bottom shift
    pilebb.minCorner() += shift;
    pilebb.maxCorner() += shift;
 
    Box fullbb = sl::boundingBox(pilebb, binbb);
    auto diff = double(fullbb.area()) - binbb.area();
    if (diff > 0) score += diff;
 
    // excluded regions and nonprefered regions should not intersect the translated pilebb
    for (auto &bb : excluded_boxes) {
        auto area_ = pilebb.intersection(bb).area();
        if (area_ > 0) score += area_;
    }
 
    return score;
}

References Slic3r::diff(), and fixed_overfit_topright_sliding().

Referenced by fixed_overfit_topright_sliding().

Here is the call graph for this function:

Here is the caller graph for this function:

get_shrink_bedpts()

Points Slic3r::arrangement::get_shrink_bedpts	(	const DynamicPrintConfig *	print_cfg,
		const ArrangeParams &	params )

{
    Points bedpts = get_bed_shape(*print_cfg);
    // shrink bed by moving to center by dist
    auto shrinkFun = [](Points& bedpts, double dist, int direction) {
#define SGN(x) ((x) >= 0 ? 1 : -1)
        Point center = Polygon(bedpts).bounding_box().center();
        for (auto& pt : bedpts) pt[direction] += dist * SGN(center[direction] - pt[direction]);
    };
    shrinkFun(bedpts, scaled(params.bed_shrink_x), 0);
    shrinkFun(bedpts, scaled(params.bed_shrink_y), 1);
    return bedpts;
}

References Slic3r::arrangement::ArrangeParams::bed_shrink_x, Slic3r::arrangement::ArrangeParams::bed_shrink_y, Slic3r::MultiPoint::bounding_box(), Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::center(), Slic3r::Geometry::dist(), Slic3r::get_bed_shape(), get_shrink_bedpts(), Slic3r::scaled(), and SGN.

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), and get_shrink_bedpts().

Here is the call graph for this function:

Here is the caller graph for this function:

has_bed_exclusion_regions()

bool Slic3r::arrangement::has_bed_exclusion_regions

(

const ArrangePolygons &

polygons

)

{
    return std::any_of(polygons.begin(), polygons.end(), [](const ArrangePolygon &polygon) {
        return polygon.is_bed_exclusion;
    });
}

height()

coord_t Slic3r::arrangement::height ( const BoundingBox & box )

inline

{ return box.max.y() - box.min.y(); }

References height(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, and Slic3r::BoundingBoxBase< PointType, APointsType >::min.

Referenced by area(), and height().

Here is the call graph for this function:

Here is the caller graph for this function:

min_area_boundingbox_rotation()

template<class S>

Radians Slic3r::arrangement::min_area_boundingbox_rotation

(

const S &

sh

)

{
    try {
        return minAreaBoundingBox<S, TCompute<S>, boost::rational<LargeInt>>(sh)
            .angleToX();
    }
    catch (const std::exception& e) {
        // min_area_boundingbox_rotation may throw exception of dividing 0 if the object is already perfectly aligned to X
        BOOST_LOG_TRIVIAL(error) << "arranging min_area_boundingbox_rotation fails, msg=" << e.what();
        return 0.0;
    }
}

References min_area_boundingbox_rotation().

Referenced by _arrange(), and min_area_boundingbox_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

poly_area()

double Slic3r::arrangement::poly_area ( const Points & pts )

inline

{ return std::abs(Polygon::area(pts)); }

References Slic3r::Polygon::area(), and poly_area().

Referenced by call_with_bed(), and poly_area().

Here is the call graph for this function:

Here is the caller graph for this function:

process_arrangeable()

void Slic3r::arrangement::process_arrangeable ( const ArrangePolygon & arrpoly, std::vector< Item > & outp )

static

{
    Polygon        p        = arrpoly.poly.contour;
    const Vec2crd &offs     = arrpoly.translation;
    double         rotation = arrpoly.rotation;
 
    if (p.is_counter_clockwise()) p.reverse();
 
    if (p.size() < 3)
        return;
 
    outp.emplace_back(std::move(p));
    Item& item = outp.back();
    item.rotation(rotation);
    item.translation({offs.x(), offs.y()});
    item.binId(arrpoly.bed_idx);
    item.priority(arrpoly.priority);
    item.itemId(arrpoly.itemid);
    item.extrude_ids = arrpoly.extrude_ids;
    item.height = arrpoly.height;
    item.z_min = arrpoly.z_min;
    item.z_max = arrpoly.z_max;
    item.has_z_range = arrpoly.has_z_range;
    item.is_bed_exclusion = arrpoly.is_bed_exclusion;
    item.bed_exclusion_extruder_ids = arrpoly.bed_exclusion_extruder_ids;
    item.bed_exclusion_extruder_id = arrpoly.bed_exclusion_extruder_id;
    item.name = arrpoly.name;
    //BBS: add virtual object logic
    item.is_virt_object = arrpoly.is_virt_object;
    item.is_wipe_tower = arrpoly.is_wipe_tower;
    item.bed_temp = arrpoly.first_bed_temp;
    item.print_temp = arrpoly.print_temp;
    item.vitrify_temp = arrpoly.vitrify_temp;
    item.inflation(arrpoly.inflation);
    item.filament_temp_type = arrpoly.filament_temp_type;
}

References Slic3r::arrangement::ArrangePolygon::bed_exclusion_extruder_id, Slic3r::arrangement::ArrangePolygon::bed_exclusion_extruder_ids, Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::ExPolygon::contour, Slic3r::arrangement::ArrangePolygon::extrude_ids, Slic3r::arrangement::ArrangePolygon::filament_temp_type, Slic3r::arrangement::ArrangePolygon::first_bed_temp, Slic3r::arrangement::ArrangePolygon::has_z_range, Slic3r::arrangement::ArrangePolygon::height, Slic3r::arrangement::ArrangePolygon::inflation, Slic3r::arrangement::ArrangePolygon::is_bed_exclusion, Slic3r::Polygon::is_counter_clockwise(), Slic3r::arrangement::ArrangePolygon::is_virt_object, Slic3r::arrangement::ArrangePolygon::is_wipe_tower, Slic3r::arrangement::ArrangePolygon::itemid, Slic3r::arrangement::ArrangePolygon::name, Slic3r::arrangement::ArrangePolygon::poly, Slic3r::arrangement::ArrangePolygon::print_temp, Slic3r::arrangement::ArrangePolygon::priority, process_arrangeable(), Slic3r::MultiPoint::reverse(), Slic3r::arrangement::ArrangePolygon::rotation, Slic3r::MultiPoint::size(), Slic3r::arrangement::ArrangePolygon::translation, Slic3r::arrangement::ArrangePolygon::vitrify_temp, Slic3r::arrangement::ArrangePolygon::z_max, and Slic3r::arrangement::ArrangePolygon::z_min.

Referenced by arrange(), fill_config(), and process_arrangeable().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_large_items()

template<class Bin>

void Slic3r::arrangement::remove_large_items	(	std::vector< Item > &	items,
		Bin &&	bin )

{
    auto it = items.begin();
    while (it != items.end())
    {
        //BBS: skip virtual object
        if (!it->is_virt_object && !sl::isInside(it->transformedShape(), bin))
            it = items.erase(it);
        else
            it++;
    }
}

References remove_large_items().

Referenced by _arrange(), and remove_large_items().

Here is the call graph for this function:

Here is the caller graph for this function:

to_circle()

CircleBed Slic3r::arrangement::to_circle ( const Point & center, const Points & points )

static

                                                                      {
    std::vector<double> vertex_distances;
    double avg_dist = 0;
 
    for (auto pt : points)
    {
        double distance = distance_to(center, pt);
        vertex_distances.push_back(distance);
        avg_dist += distance;
    }
 
    avg_dist /= vertex_distances.size();
 
    CircleBed ret(center, avg_dist);
    for(auto el : vertex_distances)
    {
        if (std::abs(el - avg_dist) > 10 * SCALED_EPSILON) {
            ret = {};
            break;
        }
    }
 
    return ret;
}

References Slic3r::center(), distance_to(), SCALED_EPSILON, and to_circle().

Referenced by call_with_bed(), and to_circle().

Here is the call graph for this function:

Here is the caller graph for this function:

to_nestbin() [1/4]

Box Slic3r::arrangement::to_nestbin ( const BoundingBox & bb )

inline

{ return Box{{bb.min(X), bb.min(Y)}, {bb.max(X), bb.max(Y)}};}

References Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, to_nestbin(), Slic3r::X, and Slic3r::Y.

Referenced by arrange(), to_nestbin(), to_nestbin(), to_nestbin(), and to_nestbin().

Here is the call graph for this function:

Here is the caller graph for this function:

to_nestbin() [2/4]

Circle Slic3r::arrangement::to_nestbin ( const CircleBed & c )

inline

{ return Circle({c.center()(0), c.center()(1)}, c.radius()); }

References Slic3r::arrangement::CircleBed::center(), Slic3r::Circle, Slic3r::arrangement::CircleBed::radius(), and to_nestbin().

Here is the call graph for this function:

to_nestbin() [3/4]

Box Slic3r::arrangement::to_nestbin ( const InfiniteBed & bed )

inline

{
    const coord_t r = coord_t(1) << 50;
    return Box{{bed.center.x() - r, bed.center.y() - r}, {bed.center.x() + r, bed.center.y() + r}};
}

References Slic3r::arrangement::InfiniteBed::center, and to_nestbin().

Here is the call graph for this function:

to_nestbin() [4/4]

ExPolygon Slic3r::arrangement::to_nestbin ( const Polygon & p )

inline

{ return ExPolygon{p}; }

References to_nestbin().

Here is the call graph for this function:

update_arrange_params()

void Slic3r::arrangement::update_arrange_params	(	ArrangeParams &	params,
		const DynamicPrintConfig *	print_cfg,
		const ArrangePolygons &	selected )

{
    double                             skirt_distance = get_real_skirt_dist(*print_cfg);
    // Note: skirt_distance is now defined between outermost brim and skirt, not the object and skirt.
    // So we can't do max but do adding instead.
    params.brim_skirt_distance = skirt_distance;
    params.bed_shrink_x += params.brim_skirt_distance;
    params.bed_shrink_y += params.brim_skirt_distance;
    // for sequential print, we need to inflate the bed because clearance_radius is so large
    if (params.is_seq_print) {
        params.bed_shrink_x -= params.clearance_radius / 2;
        params.bed_shrink_y -= params.clearance_radius / 2;
    }
}

References Slic3r::arrangement::ArrangeParams::bed_shrink_x, Slic3r::arrangement::ArrangeParams::bed_shrink_y, Slic3r::arrangement::ArrangeParams::brim_skirt_distance, Slic3r::arrangement::ArrangeParams::clearance_radius, Slic3r::get_real_skirt_dist(), and Slic3r::arrangement::ArrangeParams::is_seq_print.

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

Here is the call graph for this function:

Here is the caller graph for this function:

update_selected_items_axis_align()

void Slic3r::arrangement::update_selected_items_axis_align	(	ArrangePolygons &	selected,
		const DynamicPrintConfig *	print_cfg,
		const ArrangeParams &	params )

{
    // now only need to consider "Align to x axis"
    if (!params.align_to_y_axis)
        return;
 
    for (ArrangePolygon& ap : selected) {
        bool   validResult = false;
        double angle = 0.0;
        {
            const auto& pts = ap.transformed_poly().contour;
            int         lpt = pts.size();
            double      a00 = 0, a10 = 0, a01 = 0, a20 = 0, a11 = 0, a02 = 0, a30 = 0, a21 = 0, a12 = 0, a03 = 0;
            double      xi, yi, xi2, yi2, xi_1, yi_1, xi_12, yi_12, dxy, xii_1, yii_1;
            xi_1 = pts.back().x();
            yi_1 = pts.back().y();
 
            xi_12 = xi_1 * xi_1;
            yi_12 = yi_1 * yi_1;
 
            for (int i = 0; i < lpt; i++) {
                xi = pts[i].x();
                yi = pts[i].y();
 
                xi2 = xi * xi;
                yi2 = yi * yi;
                dxy = xi_1 * yi - xi * yi_1;
                xii_1 = xi_1 + xi;
                yii_1 = yi_1 + yi;
 
                a00 += dxy;
                a10 += dxy * xii_1;
                a01 += dxy * yii_1;
                a20 += dxy * (xi_1 * xii_1 + xi2);
                a11 += dxy * (xi_1 * (yii_1 + yi_1) + xi * (yii_1 + yi));
                a02 += dxy * (yi_1 * yii_1 + yi2);
                a30 += dxy * xii_1 * (xi_12 + xi2);
                a03 += dxy * yii_1 * (yi_12 + yi2);
                a21 += dxy * (xi_12 * (3 * yi_1 + yi) + 2 * xi * xi_1 * yii_1 + xi2 * (yi_1 + 3 * yi));
                a12 += dxy * (yi_12 * (3 * xi_1 + xi) + 2 * yi * yi_1 * xii_1 + yi2 * (xi_1 + 3 * xi));
                xi_1 = xi;
                yi_1 = yi;
                xi_12 = xi2;
                yi_12 = yi2;
            }
 
            if (std::abs(a00) > EPSILON) {
                double db1_2, db1_6, db1_12, db1_24, db1_20, db1_60;
                double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
                if (a00 > 0) {
                    db1_2 = 0.5;
                    db1_6 = 0.16666666666666666666666666666667;
                    db1_12 = 0.083333333333333333333333333333333;
                    db1_24 = 0.041666666666666666666666666666667;
                    db1_20 = 0.05;
                    db1_60 = 0.016666666666666666666666666666667;
                }
                else {
                    db1_2 = -0.5;
                    db1_6 = -0.16666666666666666666666666666667;
                    db1_12 = -0.083333333333333333333333333333333;
                    db1_24 = -0.041666666666666666666666666666667;
                    db1_20 = -0.05;
                    db1_60 = -0.016666666666666666666666666666667;
                }
                m00 = a00 * db1_2;
                m10 = a10 * db1_6;
                m01 = a01 * db1_6;
                m20 = a20 * db1_12;
                m11 = a11 * db1_24;
                m02 = a02 * db1_12;
                m30 = a30 * db1_20;
                m21 = a21 * db1_60;
                m12 = a12 * db1_60;
                m03 = a03 * db1_20;
 
                double cx = m10 / m00;
                double cy = m01 / m00;
 
                double a = m20 / m00 - cx * cx;
                double b = m11 / m00 - cx * cy;
                double c = m02 / m00 - cy * cy;
 
                //if a and c are close, there is no dominant axis, then do not rotate
                // ratio is always no more than 1
                double ratio = std::abs(a) > std::abs(c) ? std::abs(c / a) :
                    std::abs(c) > 0 ? std::abs(a / c) : 0;
                if (ratio>0.66) {
                    validResult = false;
                }
                else {
                    angle = std::atan2(2 * b, (a - c)) / 2;
                    angle = PI / 2 - angle;
                    // if the angle is close to PI or -PI, it means the object is vertical, then do not rotate
                    if (std::abs(std::abs(angle) - PI) < 0.01)
                        angle = 0;
                    validResult = true;
                }
            }
        }
        if (validResult) { ap.rotation += angle; }
    }
}

References Slic3r::arrangement::ArrangeParams::align_to_y_axis, Slic3r::angle(), EPSILON, PI, and update_selected_items_axis_align().

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

Here is the call graph for this function:

Here is the caller graph for this function:

update_selected_items_inflation()

void Slic3r::arrangement::update_selected_items_inflation	(	ArrangePolygons &	selected,
		const DynamicPrintConfig *	print_cfg,
		ArrangeParams &	params )

                                                                                                                            {
    // do not inflate brim_width. Objects are allowed to have overlapped brim.
    // A brim reaching the printable area's edge is fine, so measure against the full bed.
    BoundingBox bedbb = Polygon(get_bed_shape(*print_cfg)).bounding_box();
    // set obj distance for auto seq_print
    if (params.is_seq_print) {
        bool all_objects_are_short = std::all_of(selected.begin(), selected.end(), [&](ArrangePolygon& ap) { return ap.height < params.nozzle_height; });
        if (all_objects_are_short) {
            params.min_obj_distance = std::max(params.min_obj_distance, scaled(std::max(MAX_OUTER_NOZZLE_DIAMETER/2.f, params.object_skirt_offset*2)+0.001));
        }
        else
            params.min_obj_distance = std::max(params.min_obj_distance, scaled(params.clearance_radius + 0.001)); // +0.001mm to avoid clearance check fail due to rounding error
    }
    double brim_max = 0;
    bool plate_has_tree_support = false;
    std::for_each(selected.begin(), selected.end(), [&](ArrangePolygon& ap) {
        brim_max = std::max(brim_max, ap.brim_width);
        if (ap.has_tree_support) plate_has_tree_support = true; });
    std::for_each(selected.begin(), selected.end(), [&](ArrangePolygon& ap) {
        // 1. if user input a distance, use it
        // 2. if there is an object with tree support, all objects use the max tree branch radius (brim_max=branch diameter)
        // 3. otherwise, use each object's own brim width
        ap.inflation = params.min_obj_distance != 0 ? params.min_obj_distance / 2 :
            plate_has_tree_support ? scaled(brim_max / 2) : scaled(ap.brim_width);
        if (params.min_obj_distance != 0)
            return; // an explicit object distance is the user's call, not ours to shrink
        // An item cannot be larger than the printable area, inflation included. Inflating
        // an almost bed filling item would leave it too big to ever be placed.
        BoundingBox apbb   = ap.poly.contour.bounding_box();
        auto        diffx  = bedbb.size().x() - apbb.size().x();
        auto        diffy  = bedbb.size().y() - apbb.size().y();
        ap.inflation = std::max<coord_t>(0, std::min({ ap.inflation, diffx / 2, diffy / 2 }));
        });
 
    // Give the bed margin, which the arrange bed keeps from the printable area, back
    // where the largest item needs it. The skirt keeps its room: pushing a skirt off
    // the bed is worse than saying the item does not fit.
    if (!selected.empty()) {
        coord_t max_width = 0, max_height = 0;
        for (const ArrangePolygon &ap : selected) {
            BoundingBox apbb = ap.poly.contour.bounding_box();
            max_width        = std::max(max_width, apbb.size().x() + 2 * ap.inflation);
            max_height       = std::max(max_height, apbb.size().y() + 2 * ap.inflation);
        }
        auto margin = [](coord_t bed, coord_t item) { return std::max(0., unscale<double>(bed - item) / 2.); };
        params.bed_shrink_x = std::min<double>(params.bed_shrink_x, std::max<double>(params.brim_skirt_distance, margin(bedbb.size().x(), max_width)));
        params.bed_shrink_y = std::min<double>(params.bed_shrink_y, std::max<double>(params.brim_skirt_distance, margin(bedbb.size().y(), max_height)));
    }
}

References Slic3r::MultiPoint::bounding_box(), Slic3r::arrangement::ArrangeParams::clearance_radius, Slic3r::get_bed_shape(), Slic3r::arrangement::ArrangeParams::is_seq_print, MAX_OUTER_NOZZLE_DIAMETER, Slic3r::arrangement::ArrangeParams::min_obj_distance, Slic3r::arrangement::ArrangeParams::object_skirt_offset, and Slic3r::scaled().

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

Here is the call graph for this function:

Here is the caller graph for this function:

update_unselected_items_inflation()

void Slic3r::arrangement::update_unselected_items_inflation	(	ArrangePolygons &	unselected,
		const DynamicPrintConfig *	print_cfg,
		const ArrangeParams &	params )

{
    float exclusion_gap = 1.f;
    if (params.is_seq_print) {
        // bed_shrink_x is typically (-params.clearance_radius / 2+5) for seq_print
        exclusion_gap = std::max(exclusion_gap, params.clearance_radius / 2 + params.bed_shrink_x + 1.f);  // +1mm gap so the exclusion region is not too close
        // dont forget to move the excluded region
        for (auto& region : unselected) {
            if (region.is_virt_object) region.poly.translate(scaled(params.bed_shrink_x), scaled(params.bed_shrink_y));
        }
    }
    // For occulusion regions, inflation should be larger to prevent genrating brim on them.
    // However, extrusion cali regions are exceptional, since we can allow brim overlaps them.
    // 屏蔽区域只需要膨胀brim宽度，防止brim长过去；挤出标定区域不需要膨胀，brim可以长过去。
    // 以前我们认为还需要膨胀clearance_radius/2，这其实是不需要的，因为这些区域并不会真的摆放物体，
    // 其他物体的膨胀轮廓是可以跟它们重叠的。
    std::for_each(unselected.begin(), unselected.end(),
        [&](auto& ap) { ap.inflation = !ap.is_virt_object ? (params.min_obj_distance == 0 ? scaled(ap.brim_width) : params.min_obj_distance / 2)
        : (ap.is_extrusion_cali_object ? 0 : scale_(exclusion_gap)); });
}

References Slic3r::arrangement::ArrangeParams::bed_shrink_x, Slic3r::arrangement::ArrangeParams::bed_shrink_y, Slic3r::arrangement::ArrangeParams::clearance_radius, Slic3r::arrangement::ArrangeParams::is_seq_print, Slic3r::scaled(), and update_unselected_items_inflation().

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

Here is the call graph for this function:

Here is the caller graph for this function:

width()

coord_t Slic3r::arrangement::width ( const BoundingBox & box )

inline

{ return box.max.x() - box.min.x(); }

References Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, and width().

Referenced by area(), and width().

Here is the call graph for this function:

Here is the caller graph for this function:

z_ranges_overlap()

bool Slic3r::arrangement::z_ranges_overlap ( double first_min, double first_max, double second_min, double second_max )

static

{
    if (first_min > first_max)
        std::swap(first_min, first_max);
    if (second_min > second_max)
        std::swap(second_min, second_max);
 
    // Touching a volume is treated as a collision. Arrangement may leave some
    // usable space empty, but it must not create a marginally unsafe placement.
    return first_max >= second_min - EPSILON && second_max >= first_min - EPSILON;
}

References EPSILON.

Referenced by bed_exclusion_applies_impl().

Here is the caller graph for this function:

Variable Documentation

BIG_ITEM_TRESHOLD

const double Slic3r::arrangement::BIG_ITEM_TRESHOLD = 0.02

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

UNARRANGED

const constexpr int Slic3r::arrangement::UNARRANGED = -1

staticconstexpr

A logical bed representing an object not being arranged. Either the arrange has not yet successfully run on this ArrangePolygon or it could not fit the object due to overly large size or invalid geometry.

Referenced by Slic3r::ImexArranger::finish(), Slic3r::arrangement::ArrangePolygon::is_arranged(), Slic3r::GUI::PartPlateList::postprocess_arrange_polygon(), and Slic3r::GUI::FillBedJob::process().