Collaboration diagram for Slic3r::arrangement::AutoArranger< TBin >:

Public Types
using	Placer = typename placers::_NofitPolyPlacer< ExPolygon, TBin >

using	Selector = selections::_FirstFitSelection< ExPolygon >

using	Packer = _Nester< Placer, Selector >

using	PConfig = typename Packer::PlacementConfig

using	Distance = TCoord< PointImpl >

Public Member Functions
	AutoArranger (const TBin &bin, const ArrangeParams &params, std::function< void(unsigned)> progressind, std::function< bool(void)> stopcond)

template<class It >
void	operator() (It from, It to)

PConfig &	config ()

const PConfig &	config () const

void	preload (std::vector< Item > &fixeditems)

Protected Member Functions
template<class T >
ArithmeticOnly< T, double >	norm (T val)

std::tuple< double, Box >	objfunc (const Item &item, const Point &bincenter)

std::function< double(const Item &)>	get_objfn ()

std::function< double(const Item &)>	get_objfn ()

std::function< double(const Item &)>	get_objfn ()

std::function< double(const Item &)>	get_objfn ()

Protected Attributes
Packer	m_pck

PConfig	m_pconf

TBin	m_bin

double	m_bin_area

SpatIndex	m_rtree

SpatIndex	m_smallsrtree

double	m_norm

MultiPolygon	m_merged_pile

Box	m_pilebb

ItemGroup	m_remaining

ItemGroup	m_items

size_t	m_item_count = 0

Detailed Description

template<class TBin>
class Slic3r::arrangement::AutoArranger< TBin >

Member Typedef Documentation

◆ Distance

template<class TBin >

using Slic3r::arrangement::AutoArranger< TBin >::Distance = TCoord<PointImpl>

◆ Packer

template<class TBin >

using Slic3r::arrangement::AutoArranger< TBin >::Packer = _Nester<Placer, Selector>

◆ PConfig

template<class TBin >

using Slic3r::arrangement::AutoArranger< TBin >::PConfig = typename Packer::PlacementConfig

◆ Placer

template<class TBin >

using Slic3r::arrangement::AutoArranger< TBin >::Placer = typename placers::_NofitPolyPlacer<ExPolygon, TBin>

◆ Selector

template<class TBin >

using Slic3r::arrangement::AutoArranger< TBin >::Selector = selections::_FirstFitSelection<ExPolygon>

Constructor & Destructor Documentation

◆ AutoArranger()

template<class TBin >

Slic3r::arrangement::AutoArranger< TBin >::AutoArranger	(	const TBin &	bin,
		const ArrangeParams &	params,
		std::function< void(unsigned)>	progressind,
		std::function< bool(void)>	stopcond
	)

inline

        : m_pck(bin, params.min_obj_distance)
        , m_bin(bin)
        , m_bin_area(sl::area(bin))
        , m_norm(std::sqrt(m_bin_area))
    {
        fill_config(m_pconf, params);
 
        // Set up a callback that is called just before arranging starts
        // This functionality is provided by the Nester class (m_pack).
        m_pconf.before_packing =
        [this](const MultiPolygon& merged_pile,            // merged pile
               const ItemGroup& items,             // packed items
               const ItemGroup& remaining)         // future items to be packed
        {
            m_items = items;
            m_merged_pile = merged_pile;
            m_remaining = remaining;
 
            m_pilebb = sl::boundingBox(merged_pile);
 
            m_rtree.clear();
            m_smallsrtree.clear();
            
            // We will treat big items (compared to the print bed) differently
            auto isBig = [this](double a) {
                return a / m_bin_area > BIG_ITEM_TRESHOLD ;
            };
 
            for(unsigned idx = 0; idx < items.size(); ++idx) {
                Item& itm = items[idx];
                if(isBig(itm.area())) m_rtree.insert({itm.boundingBox(), idx});
                m_smallsrtree.insert({itm.boundingBox(), idx});
            }
        };
        
        m_pconf.object_function = get_objfn();
 
        m_pconf.on_preload = [this](const ItemGroup &items, PConfig &cfg) {
            if (items.empty()) return;
 
            cfg.alignment = PConfig::Alignment::DONT_ALIGN;
            auto bb = sl::boundingBox(m_bin);
            auto bbcenter = bb.center();
            cfg.object_function = [this, bb, bbcenter](const Item &item) {
                return fixed_overfit(objfunc(item, bbcenter), bb);
            };
        };
 
        auto on_packed = params.on_packed;
        
        if (progressind || on_packed)
            m_pck.progressIndicator([this, progressind, on_packed](unsigned rem) {
 
            if (progressind)
                progressind(rem);
 
            if (on_packed) {
                int last_bed = m_pck.lastPackedBinId();
                if (last_bed >= 0) {
                    Item &last_packed = m_pck.lastResult()[last_bed].back();
                    ArrangePolygon ap;
                    ap.bed_idx = last_packed.binId();
                    ap.priority = last_packed.priority();
                    on_packed(ap);
                }
            }
        });
 
        if (stopcond) m_pck.stopCondition(stopcond);
 
        m_pck.configure(m_pconf);
    }

Here is the call graph for this function:

Member Function Documentation

◆ config() [1/2]

template<class TBin >

PConfig & Slic3r::arrangement::AutoArranger< TBin >::config ( )

inline

399{ return m_pconf; }

◆ config() [2/2]

template<class TBin >

const PConfig & Slic3r::arrangement::AutoArranger< TBin >::config ( ) const

inline

400{ return m_pconf; }

◆ get_objfn() [1/4]

template<class TBin >

std::function< double(const Item &)> Slic3r::arrangement::AutoArranger< TBin >::get_objfn ( )

protected

◆ get_objfn() [2/4]

std::function< double(const Item &)> Slic3r::arrangement::AutoArranger< Box >::get_objfn ( )

protected

{
    auto bincenter = m_bin.center();
 
    return [this, bincenter](const Item &itm) {
        auto result = objfunc(itm, bincenter);
        
        double score = std::get<0>(result);
        auto& fullbb = std::get<1>(result);
 
        double miss = Placer::overfit(fullbb, m_bin);
        miss = miss > 0? miss : 0;
        score += miss * miss;
        
        return score;
    };
}

◆ get_objfn() [3/4]

std::function< double(const Item &)> Slic3r::arrangement::AutoArranger< Circle >::get_objfn ( )

protected

{
    auto bincenter = m_bin.center();
    return [this, bincenter](const Item &item) {
 
        auto result = objfunc(item, bincenter);
 
        double score = std::get<0>(result);
 
        return score;
    };
}

◆ get_objfn() [4/4]

std::function< double(const Item &)> Slic3r::arrangement::AutoArranger< ExPolygon >::get_objfn ( )

protected

{
    auto bincenter = sl::boundingBox(m_bin).center();
    return [this, bincenter](const Item &item) {
        return std::get<0>(objfunc(item, bincenter));
    };
}

◆ norm()

template<class TBin >

template<class T >

ArithmeticOnly< T, double > Slic3r::arrangement::AutoArranger< TBin >::norm ( T val )

inlineprotected

    {
        return double(val) / m_norm;
    }

References Slic3r::arrangement::AutoArranger< TBin >::m_norm.

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

Here is the caller graph for this function:

◆ objfunc()

template<class TBin >

std::tuple< double, Box > Slic3r::arrangement::AutoArranger< TBin >::objfunc	(	const Item &	item,
		const Point &	bincenter
	)

inlineprotected

    {
        const double bin_area = m_bin_area;
        const SpatIndex& spatindex = m_rtree;
        const SpatIndex& smalls_spatindex = m_smallsrtree;
        
        // We will treat big items (compared to the print bed) differently
        auto isBig = [bin_area](double a) {
            return a/bin_area > BIG_ITEM_TRESHOLD ;
        };
        
        // Candidate item bounding box
        auto ibb = item.boundingBox();
        
        // Calculate the full bounding box of the pile with the candidate item
        auto fullbb = sl::boundingBox(m_pilebb, ibb);
        
        // The bounding box of the big items (they will accumulate in the center
        // of the pile
        Box bigbb;
        if(spatindex.empty()) bigbb = fullbb;
        else {
            auto boostbb = spatindex.bounds();
            boost::geometry::convert(boostbb, bigbb);
        }
        
        // Will hold the resulting score
        double score = 0;
        
        // Density is the pack density: how big is the arranged pile
        double density = 0;
        
        // Distinction of cases for the arrangement scene
        enum e_cases {
            // This branch is for big items in a mixed (big and small) scene
            // OR for all items in a small-only scene.
            BIG_ITEM,
            
            // This branch is for the last big item in a mixed scene
            LAST_BIG_ITEM,
            
            // For small items in a mixed scene.
            SMALL_ITEM
        } compute_case;
        
        bool bigitems = isBig(item.area()) || spatindex.empty();
        if(bigitems && !m_remaining.empty()) compute_case = BIG_ITEM;
        else if (bigitems && m_remaining.empty()) compute_case = LAST_BIG_ITEM;
        else compute_case = SMALL_ITEM;
        
        switch (compute_case) {
        case BIG_ITEM: {
            const Point& minc = ibb.minCorner(); // bottom left corner
            const Point& maxc = ibb.maxCorner(); // top right corner
 
            // top left and bottom right corners
            Point top_left{getX(minc), getY(maxc)};
            Point bottom_right{getX(maxc), getY(minc)};
 
            // Now the distance of the gravity center will be calculated to the
            // five anchor points and the smallest will be chosen.
            std::array<double, 5> dists;
            auto cc = fullbb.center(); // The gravity center
            dists[0] = pl::distance(minc, cc);
            dists[1] = pl::distance(maxc, cc);
            dists[2] = pl::distance(ibb.center(), cc);
            dists[3] = pl::distance(top_left, cc);
            dists[4] = pl::distance(bottom_right, cc);
 
            // The smalles distance from the arranged pile center:
            double dist = norm(*(std::min_element(dists.begin(), dists.end())));
            double bindist = norm(pl::distance(ibb.center(), bincenter));
            dist = 0.8 * dist + 0.2 * bindist;
 
            // Prepare a variable for the alignment score.
            // This will indicate: how well is the candidate item
            // aligned with its neighbors. We will check the alignment
            // with all neighbors and return the score for the best
            // alignment. So it is enough for the candidate to be
            // aligned with only one item.
            auto alignment_score = 1.0;
 
            auto query = bgi::intersects(ibb);
            auto& index = isBig(item.area()) ? spatindex : smalls_spatindex;
 
            // Query the spatial index for the neighbors
            std::vector<SpatElement> result;
            result.reserve(index.size());
 
            index.query(query, std::back_inserter(result));
 
            // now get the score for the best alignment
            for(auto& e : result) { 
                auto idx = e.second;
                Item& p = m_items[idx];
                auto parea = p.area();
                if(std::abs(1.0 - parea/item.area()) < 1e-6) {
                    auto bb = sl::boundingBox(p.boundingBox(), ibb);
                    auto bbarea = bb.area();
                    auto ascore = 1.0 - (item.area() + parea)/bbarea;
 
                    if(ascore < alignment_score) alignment_score = ascore;
                }
            }
            
            density = std::sqrt(norm(fullbb.width()) * norm(fullbb.height()));
            double R = double(m_remaining.size()) / m_item_count;
            
            // The final mix of the score is the balance between the
            // distance from the full pile center, the pack density and
            // the alignment with the neighbors
            if (result.empty())
                score = 0.50 * dist + 0.50 * density;
            else
                // Let the density matter more when fewer objects remain
                score = 0.50 * dist + (1.0 - R) * 0.20 * density +
                        0.30 * alignment_score;
 
            break;
        }
        case LAST_BIG_ITEM: {
            score = norm(pl::distance(ibb.center(), m_pilebb.center()));
            break;
        }
        case SMALL_ITEM: {
            // Here there are the small items that should be placed around the
            // already processed bigger items.
            // No need to play around with the anchor points, the center will be
            // just fine for small items
            score = norm(pl::distance(ibb.center(), bigbb.center()));
            break;
        }            
        }
        
        return std::make_tuple(score, fullbb);
    }

Here is the call graph for this function:

◆ operator()()

template<class TBin >

template<class It >

void Slic3r::arrangement::AutoArranger< TBin >::operator()	(	It	from,
		It	to
	)

inline

                                                              {
        m_rtree.clear();
        m_item_count += size_t(to - from);
        m_pck.execute(from, to);
        m_item_count = 0;
    }

References libnest2d::_Nester< PlacementStrategy, SelectionStrategy >::execute().

Here is the call graph for this function:

◆ preload()

template<class TBin >

void Slic3r::arrangement::AutoArranger< TBin >::preload ( std::vector< Item > & fixeditems )

inline

                                                     {        
        for(unsigned idx = 0; idx < fixeditems.size(); ++idx) {
            Item& itm = fixeditems[idx];
            itm.markAsFixedInBin(itm.binId());
        }
 
        m_item_count += fixeditems.size();
    }