libnest2d::placers::_NofitPolyPlacer< RawShape, TBin > Class Template Reference

#include <src/libnest2d/include/libnest2d/placers/nfpplacer.hpp>

Inheritance diagram for libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >:

Collaboration diagram for libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >:

Classes
class	Optimizer
struct	Optimum

Public Types
using	Pile = nfp::Shapes< RawShape >

Public Member Functions
	_NofitPolyPlacer (const BinType &bin)
	_NofitPolyPlacer (const _NofitPolyPlacer &)=default
_NofitPolyPlacer &	operator= (const _NofitPolyPlacer &)=default
	_NofitPolyPlacer (_NofitPolyPlacer &&)=default
_NofitPolyPlacer &	operator= (_NofitPolyPlacer &&)=default
	~_NofitPolyPlacer ()
void	clearItems ()
void	preload (const ItemGroup &packeditems)
template<class Range = ConstItemRange<typename Base::DefaultIter>>
PackResult	trypack (Item &item, const Range &remaining=Range())

Static Public Member Functions
static double	overfit (const Box &bb, const RawShape &bin)
static double	overfit (const RawShape &chull, const RawShape &bin)
static double	overfit (const RawShape &chull, const Box &bin)
static double	overfit (const Box &bb, const Box &bin)
static double	overfit (const Box &bb, const _Circle< Vertex > &bin)
static double	overfit (const RawShape &chull, const _Circle< Vertex > &bin)

Private Types
using	Base = PlacerBoilerplate< _NofitPolyPlacer< RawShape, TBin >, RawShape, TBin, NfpPConfig< RawShape > >
using	Box = _Box< TPoint< RawShape > >
using	MaxNfpLevel = nfp::MaxNfpLevel< RawShape >
using	Shapes = TMultiShape< RawShape >
using	Edges = EdgeCache< RawShape >

Private Member Functions
Shapes	calcnfp (const Item &trsh, Lvl< nfp::NfpLevel::CONVEX_ONLY >)
template<class Level >
Shapes	calcnfp (const Item &, Level)
void	finalAlign (const RawShape &pbin)
void	finalAlign (_Circle< TPoint< RawShape > > cbin)
void	finalAlign (Box bbin)
void	setInitialPosition (Item &item)
void	placeOutsideOfBin (Item &item)

Private Attributes
const double	norm_
Pile	merged_pile_

Detailed Description

template<class RawShape, class TBin = _Box<TPoint<RawShape>>>
class libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >

Member Typedef Documentation

Base

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

using libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::Base = PlacerBoilerplate<_NofitPolyPlacer<RawShape, TBin>, RawShape, TBin, NfpPConfig<RawShape> >

private

Box

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

using libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::Box = _Box<TPoint<RawShape> >

private

Edges

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

using libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::Edges = EdgeCache<RawShape>

private

MaxNfpLevel

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

using libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::MaxNfpLevel = nfp::MaxNfpLevel<RawShape>

private

Pile

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

using libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::Pile = nfp::Shapes<RawShape>

Shapes

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

using libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::Shapes = TMultiShape<RawShape>

private

Constructor & Destructor Documentation

_NofitPolyPlacer() [1/3]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::_NofitPolyPlacer ( const BinType &  bin )

inlineexplicit

                                                        :
        Base(bin),
        norm_(std::sqrt(sl::area(bin)))
    {
        // In order to not have items out of bin, it will be shrinked by an
        // very little empiric offset value.
        // sl::offset(bin_, 1e-5 * norm_);
    }

_NofitPolyPlacer() [2/3]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::_NofitPolyPlacer ( const _NofitPolyPlacer< RawShape, TBin > &  )

default

_NofitPolyPlacer() [3/3]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::_NofitPolyPlacer ( _NofitPolyPlacer< RawShape, TBin > &&  )

default

~_NofitPolyPlacer()

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::~_NofitPolyPlacer ( )

inline

                        {
        clearItems();
    }

References libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::clearItems().

Here is the call graph for this function:

Member Function Documentation

calcnfp() [1/2]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

template<class Level >

Shapes libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::calcnfp ( const Item &  , Level    )

inlineprivate

    { // Function for arbitrary level of nfp implementation
 
        // TODO: implement
        return {};
    }

calcnfp() [2/2]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

Shapes libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::calcnfp ( const Item &  trsh, Lvl< nfp::NfpLevel::CONVEX_ONLY >    )

inlineprivate

    {
        using namespace nfp;
 
        Shapes nfps(items_.size());
 
        // /////////////////////////////////////////////////////////////////////
        // TODO: this is a workaround and should be solved in Item with mutexes
        // guarding the mutable members when writing them.
        // /////////////////////////////////////////////////////////////////////
        trsh.transformedShape();
        trsh.referenceVertex();
        trsh.rightmostTopVertex();
        trsh.leftmostBottomVertex();
 
        for(Item& itm : items_) {
            itm.transformedShape();
            itm.referenceVertex();
            itm.rightmostTopVertex();
            itm.leftmostBottomVertex();
        }
        // /////////////////////////////////////////////////////////////////////
 
        __parallel::enumerate(items_.begin(), items_.end(),
                              [&nfps, &trsh](const Item& sh, size_t n)
        {
            auto& fixedp = sh.transformedShape();
            auto& orbp = trsh.transformedShape();
            auto subnfp_r = noFitPolygon<NfpLevel::CONVEX_ONLY>(fixedp, orbp);
            correctNfpPosition(subnfp_r, sh, trsh);
            nfps[n] = subnfp_r.first;
        });
 
        return nfp::merge(nfps);
    }

References libnest2d::__parallel::enumerate(), libnest2d::_Item< RawShape >::leftmostBottomVertex(), libnest2d::nfp::merge(), libnest2d::_Item< RawShape >::referenceVertex(), libnest2d::_Item< RawShape >::rightmostTopVertex(), and libnest2d::_Item< RawShape >::transformedShape().

Referenced by libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::trypack().

Here is the call graph for this function:

Here is the caller graph for this function:

clearItems()

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

void libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::clearItems ( )

inline

                             {
        finalAlign(bin_);
        merged_pile_ = {};
        Base::clearItems();
    }

References libnest2d::placers::PlacerBoilerplate< Subclass, RawShape, TBin, Cfg >::clearItems(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::finalAlign(), and libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::merged_pile_.

Referenced by libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::~_NofitPolyPlacer().

Here is the call graph for this function:

Here is the caller graph for this function:

finalAlign() [1/3]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

void libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::finalAlign ( _Circle< TPoint< RawShape > >  cbin )

inlineprivate

                                                           {
        if(items_.empty() ||
                config_.alignment == Config::Alignment::DONT_ALIGN) return;
 
        nfp::Shapes<RawShape> m;
        m.reserve(items_.size());
        for(Item& item : items_) m.emplace_back(item.transformedShape());
 
        auto c = boundingCircle(sl::convexHull(m));
 
        auto d = cbin.center() - c.center();
        for(Item& item : items_) item.translate(d);
    }

References libnest2d::placers::boundingCircle(), libnest2d::shapelike::convexHull(), libnest2d::_Item< RawShape >::transformedShape(), and libnest2d::_Item< RawShape >::translate().

Here is the call graph for this function:

finalAlign() [2/3]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

void libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::finalAlign ( Box  bbin )

inlineprivate

                                     {
        if(items_.empty() ||
                config_.alignment == Config::Alignment::DONT_ALIGN) return;
 
        Box bb = items_.front().get().boundingBox();
        for(Item& item : items_)
            bb = sl::boundingBox(item.boundingBox(), bb);
 
        Vertex ci, cb;
 
        switch(config_.alignment) {
        case Config::Alignment::CENTER: {
            ci = bb.center();
            cb = bbin.center();
            break;
        }
        case Config::Alignment::BOTTOM_LEFT: {
            ci = bb.minCorner();
            cb = bbin.minCorner();
            break;
        }
        case Config::Alignment::BOTTOM_RIGHT: {
            ci = {getX(bb.maxCorner()), getY(bb.minCorner())};
            cb = {getX(bbin.maxCorner()), getY(bbin.minCorner())};
            break;
        }
        case Config::Alignment::TOP_LEFT: {
            ci = {getX(bb.minCorner()), getY(bb.maxCorner())};
            cb = {getX(bbin.minCorner()), getY(bbin.maxCorner())};
            break;
        }
        case Config::Alignment::TOP_RIGHT: {
            ci = bb.maxCorner();
            cb = bbin.maxCorner();
            break;
        }
        default: ; // DONT_ALIGN
        }
 
        auto d = cb - ci;
        for(Item& item : items_) item.translate(d);
    }

References libnest2d::_Item< RawShape >::boundingBox(), libnest2d::shapelike::boundingBox(), libnest2d::_Box< P >::center(), libnest2d::getX(), libnest2d::getY(), libnest2d::_Box< P >::maxCorner(), libnest2d::_Box< P >::minCorner(), and libnest2d::_Item< RawShape >::translate().

Here is the call graph for this function:

finalAlign() [3/3]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

void libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::finalAlign ( const RawShape &  pbin )

inlineprivate

                                                 {
        auto bbin = sl::boundingBox(pbin);
        finalAlign(bbin);
    }

References libnest2d::shapelike::boundingBox().

Referenced by libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::clearItems().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

_NofitPolyPlacer & libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::operator= ( _NofitPolyPlacer< RawShape, TBin > &&  )

default

operator=() [2/2]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

_NofitPolyPlacer & libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::operator= ( const _NofitPolyPlacer< RawShape, TBin > &  )

default

overfit() [1/6]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

static double libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit ( const Box &  bb, const _Circle< Vertex > &  bin  )

inlinestatic

    {
        double boxr = 0.5*pl::distance(bb.minCorner(), bb.maxCorner());
        double diff = boxr - bin.radius();
        return diff;
    }

References libnest2d::pointlike::distance(), libnest2d::_Box< P >::maxCorner(), libnest2d::_Box< P >::minCorner(), and libnest2d::_Circle< P >::radius().

Here is the call graph for this function:

overfit() [2/6]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

static double libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit ( const Box &  bb, const Box &  bin  )

inlinestatic

    {
        auto wdiff = TCompute<RawShape>(bb.width()) - bin.width();
        auto hdiff = TCompute<RawShape>(bb.height()) - bin.height();
        double diff = .0;
        if(wdiff > 0) diff += double(wdiff);
        if(hdiff > 0) diff += double(hdiff);
 
        return diff;
    }

References libnest2d::_Box< P >::height(), and libnest2d::_Box< P >::width().

Here is the call graph for this function:

overfit() [3/6]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

static double libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit ( const Box &  bb, const RawShape &  bin  )

inlinestatic

                                                                     {
        auto bbin = sl::boundingBox(bin);
        auto d = bbin.center() - bb.center();
        _Rectangle<RawShape> rect(bb.width(), bb.height());
        rect.translate(bb.minCorner() + d);
        return sl::isInside(rect.transformedShape(), bin) ? -1.0 : 1;
    }

References libnest2d::shapelike::boundingBox(), libnest2d::_Box< P >::center(), libnest2d::_Box< P >::height(), libnest2d::shapelike::isInside(), libnest2d::_Box< P >::minCorner(), libnest2d::_Item< RawShape >::transformedShape(), libnest2d::_Item< RawShape >::translate(), and libnest2d::_Box< P >::width().

Referenced by libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit(), and libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::trypack().

Here is the call graph for this function:

Here is the caller graph for this function:

overfit() [4/6]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

static double libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit ( const RawShape &  chull, const _Circle< Vertex > &  bin  )

inlinestatic

    {
        double r = boundingCircle(chull).radius();
        double diff = r - bin.radius();
        return diff;
    }

References libnest2d::placers::boundingCircle(), and libnest2d::_Circle< P >::radius().

Here is the call graph for this function:

overfit() [5/6]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

static double libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit ( const RawShape &  chull, const Box &  bin  )

inlinestatic

    {
        auto bbch = sl::boundingBox(chull);
        return overfit(bbch, bin);
    }

References libnest2d::shapelike::boundingBox(), and libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit().

Here is the call graph for this function:

overfit() [6/6]

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

static double libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit ( const RawShape &  chull, const RawShape &  bin  )

inlinestatic

                                                                             {
        auto bbch = sl::boundingBox(chull);
        auto bbin = sl::boundingBox(bin);
        auto d =  bbch.center() - bbin.center();
        auto chullcpy = chull;
        sl::translate(chullcpy, d);
        return sl::isInside(chullcpy, bin) ? -1.0 : 1.0;
    }

References libnest2d::shapelike::boundingBox(), libnest2d::shapelike::isInside(), and libnest2d::shapelike::translate().

Here is the call graph for this function:

placeOutsideOfBin()

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

void libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::placeOutsideOfBin ( Item &  item )

inlineprivate

                                       {
        auto&& bb = item.boundingBox();
        Box binbb = sl::boundingBox(bin_);
 
        Vertex v = { getX(bb.maxCorner()), getY(bb.minCorner()) };
 
        Coord dx = getX(binbb.maxCorner()) - getX(v);
        Coord dy = getY(binbb.maxCorner()) - getY(v);
 
        item.translate({dx, dy});
    }

References libnest2d::_Item< RawShape >::boundingBox(), libnest2d::shapelike::boundingBox(), libnest2d::getX(), libnest2d::getY(), libnest2d::_Box< P >::maxCorner(), and libnest2d::_Item< RawShape >::translate().

Referenced by libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::trypack().

Here is the call graph for this function:

Here is the caller graph for this function:

preload()

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

void libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::preload ( const ItemGroup &  packeditems )

inline

                                               {
        Base::preload(packeditems);
 
        for (const Item& itm : packeditems)
            merged_pile_.emplace_back(itm.transformedShape());
 
        nfp::merge(merged_pile_);
 
        if (config_.on_preload)
            config_.on_preload(packeditems, config_);
    }

References libnest2d::nfp::merge(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::merged_pile_, and libnest2d::placers::PlacerBoilerplate< Subclass, RawShape, TBin, Cfg >::preload().

Here is the call graph for this function:

setInitialPosition()

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

void libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::setInitialPosition ( Item &  item )

inlineprivate

                                        {
        Box bb = item.boundingBox();
        
        Vertex ci, cb;
        auto bbin = sl::boundingBox(bin_);
 
        switch(config_.starting_point) {
        case Config::Alignment::CENTER: {
            ci = bb.center();
            cb = bbin.center();
            break;
        }
        case Config::Alignment::BOTTOM_LEFT: {
            ci = bb.minCorner();
            cb = bbin.minCorner();
            break;
        }
        case Config::Alignment::BOTTOM_RIGHT: {
            ci = {getX(bb.maxCorner()), getY(bb.minCorner())};
            cb = {getX(bbin.maxCorner()), getY(bbin.minCorner())};
            break;
        }
        case Config::Alignment::TOP_LEFT: {
            ci = {getX(bb.minCorner()), getY(bb.maxCorner())};
            cb = {getX(bbin.minCorner()), getY(bbin.maxCorner())};
            break;
        }
        case Config::Alignment::TOP_RIGHT: {
            ci = bb.maxCorner();
            cb = bbin.maxCorner();
            break;
        }
        default:;
        }
 
        auto d = cb - ci;
        item.translate(d);
    }

References libnest2d::_Item< RawShape >::boundingBox(), libnest2d::shapelike::boundingBox(), libnest2d::_Box< P >::center(), libnest2d::getX(), libnest2d::getY(), libnest2d::_Box< P >::maxCorner(), libnest2d::_Box< P >::minCorner(), and libnest2d::_Item< RawShape >::translate().

Referenced by libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::trypack().

Here is the call graph for this function:

Here is the caller graph for this function:

trypack()

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

template<class Range = ConstItemRange<typename Base::DefaultIter>>

PackResult libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::trypack ( Item &  item, const Range &  remaining = Range()  )

inline

                                              {
 
        PackResult ret;
 
        bool can_pack = false;
        double best_overfit = std::numeric_limits<double>::max();
 
        ItemGroup remlist;
        if(remaining.valid) {
            remlist.insert(remlist.end(), remaining.from, remaining.to);
        }
 
        double global_score = std::numeric_limits<double>::max();
 
        auto initial_tr = item.translation();
        auto initial_rot = item.rotation();
        Vertex final_tr = {0, 0};
        Radians final_rot = initial_rot;
        Shapes nfps;
 
        auto& bin = bin_;
        double norm = norm_;
        auto pbb = sl::boundingBox(merged_pile_);
        auto binbb = sl::boundingBox(bin);
 
        // This is the kernel part of the object function that is
        // customizable by the library client
        std::function<double(const Item&)> _objfunc;
        if(config_.object_function) _objfunc = config_.object_function;
        else {
 
            // Inside check has to be strict if no alignment was enabled
            std::function<double(const Box&)> ins_check;
            if(config_.alignment == Config::Alignment::DONT_ALIGN)
                ins_check = [&binbb, norm](const Box& fullbb) {
                    double ret = 0;
                    if(!sl::isInside(fullbb, binbb))
                        ret += norm;
                    return ret;
                };
            else
                ins_check = [&bin](const Box& fullbb) {
                    double miss = overfit(fullbb, bin);
                    miss = miss > 0? miss : 0;
                    return std::pow(miss, 2);
                };
 
            _objfunc = [norm, binbb, pbb, ins_check](const Item& item)
            {
                auto ibb = item.boundingBox();
                auto fullbb = sl::boundingBox(pbb, ibb);
 
                double score = pl::distance(ibb.center(),
                                            binbb.center());
                score /= norm;
 
                score += ins_check(fullbb);
 
                return score;
            };
        }
 
        if(items_.empty()) {
            setInitialPosition(item);
            auto best_tr = item.translation();
            auto best_rot = item.rotation();
            best_overfit = overfit(item.transformedShape(), bin_);
 
            for(auto rot : config_.rotations) {
                item.translation(initial_tr);
                item.rotation(initial_rot + rot);
                setInitialPosition(item);
                double of = 0.;
                if ((of = overfit(item.transformedShape(), bin_)) < best_overfit) {
                    best_overfit = of;
                    best_tr = item.translation();
                    best_rot = item.rotation();
                }
            }
 
            can_pack = best_overfit <= 0;
            item.rotation(best_rot);
            item.translation(best_tr);
        } else {
 
            Pile merged_pile = merged_pile_;
 
            for(auto rot : config_.rotations) {
 
                item.translation(initial_tr);
                item.rotation(initial_rot + rot);
                item.boundingBox(); // fill the bb cache
 
                // place the new item outside of the print bed to make sure
                // it is disjunct from the current merged pile
                placeOutsideOfBin(item);
 
                nfps = calcnfp(item, Lvl<MaxNfpLevel::value>());
 
                auto iv = item.referenceVertex();
 
                auto startpos = item.translation();
 
                std::vector<Edges> ecache;
                ecache.reserve(nfps.size());
 
                for(auto& nfp : nfps ) {
                    ecache.emplace_back(nfp);
                    ecache.back().accuracy(config_.accuracy);
                }
 
                // Our object function for placement
                auto rawobjfunc = [_objfunc, iv, startpos]
                        (Vertex v, Item& itm)
                {
                    auto d = (v - iv) + startpos;
                    itm.translation(d);
                    return _objfunc(itm);
                };
 
                auto getNfpPoint = [&ecache](const Optimum& opt)
                {
                    return opt.hidx < 0? ecache[opt.nfpidx].coords(opt.relpos) :
                            ecache[opt.nfpidx].coords(opt.hidx, opt.relpos);
                };
 
                auto alignment = config_.alignment;
 
                auto boundaryCheck = [alignment, &merged_pile, &getNfpPoint,
                        &item, &bin, &iv, &startpos] (const Optimum& o)
                {
                    auto v = getNfpPoint(o);
                    auto d = (v - iv) + startpos;
                    item.translation(d);
 
                    merged_pile.emplace_back(item.transformedShape());
                    auto chull = sl::convexHull(merged_pile);
                    merged_pile.pop_back();
 
                    double miss = 0;
                    if(alignment == Config::Alignment::DONT_ALIGN)
                       miss = sl::isInside(chull, bin) ? -1.0 : 1.0;
                    else miss = overfit(chull, bin);
 
                    return miss;
                };
 
                Optimum optimum(0, 0);
                double best_score = std::numeric_limits<double>::max();
                std::launch policy = std::launch::deferred;
                if(config_.parallel) policy |= std::launch::async;
 
                if(config_.before_packing)
                    config_.before_packing(merged_pile, items_, remlist);
 
                using OptResult = opt::Result<double>;
                using OptResults = std::vector<OptResult>;
 
                // Local optimization with the four polygon corners as
                // starting points
                for(unsigned ch = 0; ch < ecache.size(); ch++) {
                    auto& cache = ecache[ch];
 
                    OptResults results(cache.corners().size());
 
                    auto& rofn = rawobjfunc;
                    auto& nfpoint = getNfpPoint;
                    float accuracy = config_.accuracy;
 
                    __parallel::enumerate(
                                cache.corners().begin(),
                                cache.corners().end(),
                                [&results, &item, &rofn, &nfpoint, ch, accuracy]
                                (double pos, size_t n)
                    {
                        Optimizer solver(accuracy);
 
                        Item itemcpy = item;
                        auto contour_ofn = [&rofn, &nfpoint, ch, &itemcpy]
                                (double relpos)
                        {
                            Optimum op(relpos, ch);
                            return rofn(nfpoint(op), itemcpy);
                        };
 
                        try {
                            results[n] = solver.optimize_min(contour_ofn,
                                            opt::initvals<double>(pos),
                                            opt::bound<double>(0, 1.0)
                                            );
                        } catch(std::exception& e) {
                            derr() << "ERROR: " << e.what() << "\n";
                        }
                    }, policy);
 
                    auto resultcomp =
                            []( const OptResult& r1, const OptResult& r2 ) {
                        return r1.score < r2.score;
                    };
 
                    auto mr = *std::min_element(results.begin(), results.end(),
                                                resultcomp);
 
                    if(mr.score < best_score) {
                        Optimum o(std::get<0>(mr.optimum), ch, -1);
                        double miss = boundaryCheck(o);
                        if(miss <= 0) {
                            best_score = mr.score;
                            optimum = o;
                        } else {
                            best_overfit = std::min(miss, best_overfit);
                        }
                    }
 
                    for(unsigned hidx = 0; hidx < cache.holeCount(); ++hidx) {
                        results.clear();
                        results.resize(cache.corners(hidx).size());
 
                        // TODO : use parallel for
                        __parallel::enumerate(cache.corners(hidx).begin(),
                                      cache.corners(hidx).end(),
                                      [&results, &item, &nfpoint,
                                       &rofn, ch, hidx, accuracy]
                                      (double pos, size_t n)
                        {
                            Optimizer solver(accuracy);
 
                            Item itmcpy = item;
                            auto hole_ofn =
                                    [&rofn, &nfpoint, ch, hidx, &itmcpy]
                                    (double pos)
                            {
                                Optimum opt(pos, ch, hidx);
                                return rofn(nfpoint(opt), itmcpy);
                            };
 
                            try {
                                results[n] = solver.optimize_min(hole_ofn,
                                                opt::initvals<double>(pos),
                                                opt::bound<double>(0, 1.0)
                                                );
 
                            } catch(std::exception& e) {
                                derr() << "ERROR: " << e.what() << "\n";
                            }
                        }, policy);
 
                        auto hmr = *std::min_element(results.begin(),
                                                    results.end(),
                                                    resultcomp);
 
                        if(hmr.score < best_score) {
                            Optimum o(std::get<0>(hmr.optimum),
                                      ch, hidx);
                            double miss = boundaryCheck(o);
                            if(miss <= 0.0) {
                                best_score = hmr.score;
                                optimum = o;
                            } else {
                                best_overfit = std::min(miss, best_overfit);
                            }
                        }
                    }
                }
 
                if( best_score < global_score ) {
                    auto d = (getNfpPoint(optimum) - iv) + startpos;
                    final_tr = d;
                    final_rot = initial_rot + rot;
                    can_pack = true;
                    global_score = best_score;
                }
            }
 
            item.translation(final_tr);
            item.rotation(final_rot);
        }
 
        if(can_pack) {
            ret = PackResult(item);
            item.onPacked();
            merged_pile_ = nfp::merge(merged_pile_, item.transformedShape());
        } else {
            ret = PackResult(best_overfit);
        }
 
        return ret;
    }

References libnest2d::_Item< RawShape >::boundingBox(), libnest2d::shapelike::boundingBox(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::calcnfp(), libnest2d::shapelike::convexHull(), libnest2d::derr(), libnest2d::pointlike::distance(), libnest2d::__parallel::enumerate(), libnest2d::shapelike::isInside(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::merged_pile_, libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::norm_, libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::placeOutsideOfBin(), libnest2d::_Item< RawShape >::referenceVertex(), libnest2d::_Item< RawShape >::rotation(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::setInitialPosition(), libnest2d::_Item< RawShape >::transformedShape(), and libnest2d::_Item< RawShape >::translation().

Here is the call graph for this function:

Member Data Documentation

merged_pile_

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

Pile libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::merged_pile_

private

Referenced by libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::clearItems(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::preload(), and libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::trypack().

norm_

template<class RawShape , class TBin = _Box<TPoint<RawShape>>>

const double libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::norm_

private

Referenced by libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::trypack().

---

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

• src/libnest2d/include/libnest2d/placers/nfpplacer.hpp