Slic3r::arrangement Namespace Reference

Classes
struct	ArrangeParams
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...
class	AutoArranger
class	CircleBed
	A geometry abstraction for a circular print bed. Similarly to BoundingBox. More...
struct	InfiniteBed
	Representing an unbounded bed. More...
struct	IrregularBed
struct	RectangleBed
struct	SegmentedRectangleBed

Typedefs
using	Item = _Item< ExPolygon >
using	Box = _Box< Point >
using	Circle = _Circle< Point >
using	Segment = _Segment< 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	ArrangeBed = boost::variant< InfiniteBed, RectangleBed, CircleBed, SegmentedRectangleBed, IrregularBed >
using	ArrangePolygons = std::vector< ArrangePolygon >

Enumerations
enum class	Pivots {   Center , TopLeft , BottomLeft , BottomRight ,   TopRight }

Functions
template<class PConf >
void	fill_config (PConf &pcfg, const ArrangeParams &params)
static double	fixed_overfit (const std::tuple< double, Box > &result, const Box &binbb)
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)> 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)
bool	is_box (const Points &bed)
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)
ArrangeBed	to_arrange_bed (const Points &bedpts)
void	arrange (ArrangePolygons &items, const ArrangePolygons &excludes, const SegmentedRectangleBed &bed, const ArrangeParams &params)
BoundingBox	bounding_box (const InfiniteBed &bed)
BoundingBox	bounding_box (const RectangleBed &b)
BoundingBox	bounding_box (const SegmentedRectangleBed &b)
BoundingBox	bounding_box (const CircleBed &b)
BoundingBox	bounding_box (const ArrangeBed &b)
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 ArrangePolygons &excludes, const RectangleBed &bed, const ArrangeParams &params)
void	arrange (ArrangePolygons &items, const ArrangePolygons &excludes, const IrregularBed &bed, const ArrangeParams &params)
void	arrange (ArrangePolygons &items, const ArrangePolygons &excludes, const ArrangeBed &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.

---

Class Documentation

Slic3r::arrangement::IrregularBed

struct Slic3r::arrangement::IrregularBed

Collaboration diagram for Slic3r::arrangement::IrregularBed:

Class Members
ExPolygon	poly

Slic3r::arrangement::RectangleBed

struct Slic3r::arrangement::RectangleBed

Collaboration diagram for Slic3r::arrangement::RectangleBed:

Class Members
BoundingBox	bb

Typedef Documentation

ArrangeBed

using Slic3r::arrangement::ArrangeBed = typedef boost::variant<InfiniteBed, RectangleBed, CircleBed, SegmentedRectangleBed, IrregularBed>

ArrangePolygons

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

Box

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

Circle

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

Item

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

ItemGroup

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

MultiPolygon

using Slic3r::arrangement::MultiPolygon = typedef ExPolygons

Segment

using Slic3r::arrangement::Segment = typedef _Segment<Point>

SpatElement

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

SpatIndex

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

Enumeration Type Documentation

Pivots

enum class Slic3r::arrangement::Pivots

strong

Enumerator
Center
TopLeft
BottomLeft
BottomRight
TopRight

                  {
    Center, TopLeft, BottomLeft, BottomRight, TopRight
};

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)>	progressfn,
		std::function< bool()>	stopfn
	)

{
    // Integer ceiling the min distance from the bed perimeters
    coord_t md = params.min_obj_distance;
    md = md / 2 - params.min_bed_distance;
    
    auto corrected_bin = bin;
    sl::offset(corrected_bin, md);
    ArrangeParams mod_params = params;
    mod_params.min_obj_distance = 0;
 
    AutoArranger<BinT> arranger{corrected_bin, mod_params, progressfn, stopfn};
 
    auto infl = coord_t(std::ceil(params.min_obj_distance / 2.0));
    for (Item& itm : shapes) itm.inflate(infl);
    for (Item& itm : excludes) itm.inflate(infl);
 
    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.rawShape()));
 
            // 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));
            }
        }
    }
 
    if (sl::area(corrected_bin) > 0)
        arranger(inp.begin(), inp.end());
    else {
        for (Item &itm : inp)
            itm.binId(BIN_ID_UNSET);
    }
 
    for (Item &itm : inp) itm.inflate(-infl);
}

References _arrange(), Slic3r::arrangement::ArrangeParams::allow_rotations, fit_into_box_rotation(), min_area_boundingbox_rotation(), Slic3r::arrangement::ArrangeParams::min_bed_distance, Slic3r::arrangement::ArrangeParams::min_obj_distance, 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/17]

template<class BedT >

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

{
    namespace clppr = Slic3r::ClipperLib;
    
    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));
    
    auto &cfn = params.stopcondition;
    auto &pri = params.progressind;
    
    _arrange(items, fixeditems, to_nestbin(bed), params, pri, cfn);
    
    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();
    }
}

References _arrange(), 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/17]

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

inline

{
    auto call_arrange = [&](const auto &realbed) { arrange(items, excludes, realbed, params); };
    boost::apply_visitor(call_arrange, bed);
}

References arrange().

Here is the call graph for this function:

arrange() [3/17]

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

References arrange().

Here is the call graph for this function:

arrange() [4/17]

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

References arrange().

Here is the call graph for this function:

arrange() [5/17]

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

References arrange().

Here is the call graph for this function:

arrange() [6/17]

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

inline

{
    arrange(items, excludes, bed.poly.contour, params);
}

References arrange(), Slic3r::ExPolygon::contour, and Slic3r::arrangement::IrregularBed::poly.

Here is the call graph for this function:

arrange() [7/17]

template<>

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

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

References arrange(), and to_arrange_bed().

Referenced by arrange(), arrange(), arrange(), arrange(), arrange(), arrange(), arrange(), arrange(), arrange(), arrange(), Slic3r::arrange_objects(), Slic3r::duplicate(), Slic3r::GUI::ArrangeJob::process(), and Slic3r::GUI::FillBedJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

arrange() [8/17]

template<>

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

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

References arrange(), and to_arrange_bed().

Referenced by arrange(), arrange(), arrange(), arrange(), arrange(), arrange(), arrange(), arrange(), arrange(), arrange(), Slic3r::arrange_objects(), Slic3r::duplicate(), Slic3r::GUI::ArrangeJob::process(), and Slic3r::GUI::FillBedJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

arrange() [9/17]

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

References arrange().

Here is the call graph for this function:

arrange() [10/17]

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

inline

{
    arrange(items, excludes, bed.bb, params);
}

References arrange(), and Slic3r::arrangement::RectangleBed::bb.

Here is the call graph for this function:

arrange() [11/17]

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

{
    arrange(items, excludes, bed.bb, params);
 
    if (! excludes.empty())
        return;
 
    auto it = std::max_element(items.begin(), items.end(),
                               [](auto &i1, auto &i2) {
                                   return i1.bed_idx < i2.bed_idx;
                               });
 
    size_t beds = 0;
    if (it != items.end())
        beds = it->bed_idx + 1;
 
    std::vector<BoundingBox> pilebb(beds);
 
    for (auto &itm : items) {
        if (itm.bed_idx >= 0)
            pilebb[itm.bed_idx].merge(get_extents(itm.transformed_poly()));
    }
 
    auto piecesz = unscaled(bed.bb).size();
    piecesz.x() /= bed.segments.x();
    piecesz.y() /= bed.segments.y();
 
    for (size_t bedidx = 0; bedidx < beds; ++bedidx) {
        BoundingBox bb;
        auto pilesz = unscaled(pilebb[bedidx]).size();
        bb.max.x() = scaled(std::ceil(pilesz.x() / piecesz.x()) * piecesz.x());
        bb.max.y() = scaled(std::ceil(pilesz.y() / piecesz.y()) * piecesz.y());
        switch (params.alignment) {
        case Pivots::BottomLeft:
            bb.translate(bed.bb.min - bb.min);
            break;
        case Pivots::TopRight:
            bb.translate(bed.bb.max - bb.max);
            break;
        case Pivots::BottomRight: {
            Point bedref{bed.bb.max.x(), bed.bb.min.y()};
            Point bbref {bb.max.x(), bb.min.y()};
            bb.translate(bedref - bbref);
            break;
        }
        case Pivots::TopLeft: {
            Point bedref{bed.bb.min.x(), bed.bb.max.y()};
            Point bbref {bb.min.x(), bb.max.y()};
            bb.translate(bedref - bbref);
            break;
        }
        case Pivots::Center: {
            bb.translate(bed.bb.center() - bb.center());
            break;
        }
        }
 
        Vec2crd d = bb.center() - pilebb[bedidx].center();
 
        auto bedbb = bed.bb;
        bedbb.offset(-params.min_bed_distance);
        auto pilebbx = pilebb[bedidx];
        pilebbx.translate(d);
 
        Point corr{0, 0};
        corr.x() = -std::min(0, pilebbx.min.x() - bedbb.min.x())
                   -std::max(0, pilebbx.max.x() - bedbb.max.x());
        corr.y() = -std::min(0, pilebbx.min.y() - bedbb.min.y())
                   -std::max(0, pilebbx.max.y() - bedbb.max.y());
 
        d += corr;
 
        for (auto &itm : items)
            if (itm.bed_idx == int(bedidx))
                itm.translation += d;
    }
}

References Slic3r::arrangement::ArrangeParams::alignment, arrange(), Slic3r::arrangement::SegmentedRectangleBed::bb, Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::get_extents(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::arrangement::ArrangeParams::min_bed_distance, Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::scaled(), Slic3r::arrangement::SegmentedRectangleBed::segments, Slic3r::BoundingBoxBase< PointType, APointsType >::translate(), and Slic3r::unscaled().

Here is the call graph for this function:

arrange() [12/17]

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() [13/17]

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

inline

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

arrange() [14/17]

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

inline

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

arrange() [15/17]

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

inline

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

arrange() [16/17]

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

inline

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

arrange() [17/17]

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

inline

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

bounding_box() [1/5]

BoundingBox Slic3r::arrangement::bounding_box ( const ArrangeBed &  b )

inline

{
    BoundingBox ret;
    auto visitor = [&ret](const auto &b) { ret = bounding_box(b); };
    boost::apply_visitor(visitor, b);
 
    return ret;
}

References bounding_box().

Here is the call graph for this function:

bounding_box() [2/5]

BoundingBox Slic3r::arrangement::bounding_box ( const CircleBed &  b )

inline

{
    auto r = static_cast<coord_t>(std::round(b.radius()));
    Point R{r, r};
 
    return {b.center() - R, b.center() + R};
}

bounding_box() [3/5]

BoundingBox Slic3r::arrangement::bounding_box

(

const InfiniteBed &

bed

)

{
    BoundingBox ret;
    using C = coord_t;
 
    // It is important for Mx and My to be strictly less than half of the
    // range of type C. width(), height() and area() will not overflow this way.
    C Mx = C((std::numeric_limits<C>::lowest() + 2 * bed.center.x()) / 4.01);
    C My = C((std::numeric_limits<C>::lowest() + 2 * bed.center.y()) / 4.01);
 
    ret.max = bed.center - Point{Mx, My};
    ret.min = bed.center + Point{Mx, My};
 
    return ret;
}

References Slic3r::arrangement::InfiniteBed::center, Slic3r::BoundingBoxBase< PointType, APointsType >::max, and Slic3r::BoundingBoxBase< PointType, APointsType >::min.

Referenced by bounding_box().

Here is the caller graph for this function:

bounding_box() [4/5]

BoundingBox Slic3r::arrangement::bounding_box ( const RectangleBed &  b )

inline

{ return b.bb; }

bounding_box() [5/5]

BoundingBox Slic3r::arrangement::bounding_box ( const SegmentedRectangleBed &  b )

inline

{ return b.bb; }

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(RectangleBed{bb});
        else if (!std::isnan(circ.radius()))
            return fn(circ);
        else
            return fn(IrregularBed{ExPolygon(bed)});
    }
}

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

Referenced by call_with_bed(), and to_arrange_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
	)

                                                           {
 
    // Align the arranged pile into the center of the bin
    switch (params.alignment) {
    case Pivots::Center: pcfg.alignment = PConf::Alignment::CENTER; break;
    case Pivots::BottomLeft: pcfg.alignment = PConf::Alignment::BOTTOM_LEFT; break;
    case Pivots::BottomRight: pcfg.alignment = PConf::Alignment::BOTTOM_RIGHT; break;
    case Pivots::TopLeft: pcfg.alignment = PConf::Alignment::TOP_LEFT; break;
    case Pivots::TopRight: pcfg.alignment = PConf::Alignment::TOP_RIGHT; break;
    }
 
    // Start placing the items from the center of the print bed
    pcfg.starting_point = PConf::Alignment::CENTER;
 
    // TODO cannot use rotations until multiple objects of same geometry can
    // handle different rotations.
    if (params.allow_rotations)
        pcfg.rotations = {0., PI / 2., PI, 3. * PI / 2. };
    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;
}

References Slic3r::arrangement::ArrangeParams::accuracy, Slic3r::arrangement::ArrangeParams::alignment, Slic3r::arrangement::ArrangeParams::allow_rotations, BottomLeft, BottomRight, Center, Slic3r::arrangement::ArrangeParams::parallel, PI, TopLeft, and TopRight.

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

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()

static 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 libnest2d::_Box< P >::area(), libnest2d::shapelike::boundingBox(), and Slic3r::diff().

Here is the call graph for this function:

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:

is_box()

bool Slic3r::arrangement::is_box

(

const Points &

bed

)

{
    return !bed.empty() &&
           ((1.0 - poly_area(bed) / area(BoundingBox(bed))) < 1e-3);
}

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

Referenced by Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), and is_box().

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

)

{
    return minAreaBoundingBox<S, TCompute<S>, boost::rational<LargeInt>>(sh)
        .angleToX();
}

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(), is_box(), and poly_area().

Here is the call graph for this function:

Here is the caller graph for this function:

process_arrangeable()

static 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;
 
    outp.emplace_back(std::move(p));
    outp.back().rotation(rotation);
    outp.back().translation({offs.x(), offs.y()});
    outp.back().inflate(arrpoly.inflation);
    outp.back().binId(arrpoly.bed_idx);
    outp.back().priority(arrpoly.priority);
    outp.back().setOnPackedFn([&arrpoly](Item &itm){
        itm.inflate(-arrpoly.inflation);
    });
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::ExPolygon::contour, libnest2d::_Item< RawShape >::inflate(), Slic3r::arrangement::ArrangePolygon::inflation, Slic3r::arrangement::ArrangePolygon::poly, Slic3r::arrangement::ArrangePolygon::priority, process_arrangeable(), Slic3r::arrangement::ArrangePolygon::rotation, and Slic3r::arrangement::ArrangePolygon::translation.

Referenced by arrange(), 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())
        sl::isInside(it->transformedShape(), bin) ?
            ++it : it = items.erase(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_arrange_bed()

ArrangeBed Slic3r::arrangement::to_arrange_bed

(

const Points &

bedpts

)

{
    ArrangeBed ret;
 
    call_with_bed(bedpts, [&](const auto &bed) {
        ret = bed;
    });
 
    return ret;
}

References call_with_bed(), and to_arrange_bed().

Referenced by arrange(), Slic3r::get_bed_shape(), Slic3r::GUI::FillBedJob::prepare(), and to_arrange_bed().

Here is the call graph for this function:

Here is the caller graph for this function:

to_circle()

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

static

                                                                      {
    std::vector<double> vertex_distances;
    double avg_dist = 0;
    
    for (const Point& 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 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::Circle, and to_nestbin().

Here is the call graph for this function:

to_nestbin() [3/4]

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

inline

{ return Box::infinite({bed.center.x(), bed.center.y()}); }

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:

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:

Variable Documentation

BIG_ITEM_TRESHOLD

const double Slic3r::arrangement::BIG_ITEM_TRESHOLD = 0.02

Referenced by Slic3r::arrangement::AutoArranger< TBin >::AutoArranger(), 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::GUI::assign_logical_beds(), Slic3r::GUI::FillBedJob::finalize(), Slic3r::arrangement::ArrangePolygon::is_arranged(), and Slic3r::GUI::FillBedJob::prepare().