libnest2d::placers Namespace Reference

Classes
class	_BottomLeftPlacer
class	_NofitPolyPlacer
struct	BLConfig
struct	DefaultEpsilon
struct	DefaultEpsilon< T, enable_if_t< std::is_floating_point< T >::value, T > >
struct	DefaultEpsilon< T, enable_if_t< std::is_integral< T >::value, T > >
class	EdgeCache
struct	EmptyConfig
struct	Lvl
struct	NfpPConfig
class	PlacerBoilerplate

Functions
template<class RawShape >
void	correctNfpPosition (nfp::NfpResult< RawShape > &nfp, const _Item< RawShape > &stationary, const _Item< RawShape > &orbiter)
template<class RawShape >
void	correctNfpPosition (nfp::NfpResult< RawShape > &nfp, const RawShape &stationary, const _Item< RawShape > &orbiter)
template<class RawShape , class Circle = _Circle<TPoint<RawShape>>>
Circle	minimizeCircle (const RawShape &sh)
template<class RawShape >
_Circle< TPoint< RawShape > >	boundingCircle (const RawShape &sh)

---

Class Documentation

libnest2d::placers::DefaultEpsilon

struct libnest2d::placers::DefaultEpsilon

template<class T, class = T>
struct libnest2d::placers::DefaultEpsilon< T, class >

libnest2d::placers::EmptyConfig

struct libnest2d::placers::EmptyConfig

Function Documentation

boundingCircle()

template<class RawShape >

_Circle< TPoint< RawShape > > libnest2d::placers::boundingCircle

(

const RawShape &

sh

)

                                                             {
    return minimizeCircle(sh);
}

References minimizeCircle().

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

Here is the call graph for this function:

Here is the caller graph for this function:

correctNfpPosition() [1/2]

template<class RawShape >

void libnest2d::placers::correctNfpPosition ( nfp::NfpResult< RawShape > &  nfp, const _Item< RawShape > &  stationary, const _Item< RawShape > &  orbiter  )

inline

{
    // The provided nfp is somewhere in the dark. We need to get it
    // to the right position around the stationary shape.
    // This is done by choosing the leftmost lowest vertex of the
    // orbiting polygon to be touched with the rightmost upper
    // vertex of the stationary polygon. In this configuration, the
    // reference vertex of the orbiting polygon (which can be dragged around
    // the nfp) will be its rightmost upper vertex that coincides with the
    // rightmost upper vertex of the nfp. No proof provided other than Jonas
    // Lindmark's reasoning about the reference vertex of nfp in his thesis
    // ("No fit polygon problem" - section 2.1.9)
 
    auto touch_sh = stationary.rightmostTopVertex();
    auto touch_other = orbiter.leftmostBottomVertex();
    auto dtouch = touch_sh - touch_other;
    auto top_other = orbiter.rightmostTopVertex() + dtouch;
    auto dnfp = top_other - nfp.second; // nfp.second is the nfp reference point
    shapelike::translate(nfp.first, dnfp);
}

References libnest2d::_Item< RawShape >::leftmostBottomVertex(), libnest2d::_Item< RawShape >::rightmostTopVertex(), and libnest2d::shapelike::translate().

Here is the call graph for this function:

correctNfpPosition() [2/2]

template<class RawShape >

void libnest2d::placers::correctNfpPosition ( nfp::NfpResult< RawShape > &  nfp, const RawShape &  stationary, const _Item< RawShape > &  orbiter  )

inline

{
    auto touch_sh = nfp::rightmostUpVertex(stationary);
    auto touch_other = orbiter.leftmostBottomVertex();
    auto dtouch = touch_sh - touch_other;
    auto top_other = orbiter.rightmostTopVertex() + dtouch;
    auto dnfp = top_other - nfp.second;
    shapelike::translate(nfp.first, dnfp);
}

References libnest2d::_Item< RawShape >::leftmostBottomVertex(), libnest2d::_Item< RawShape >::rightmostTopVertex(), libnest2d::nfp::rightmostUpVertex(), and libnest2d::shapelike::translate().

Here is the call graph for this function:

minimizeCircle()

template<class RawShape , class Circle = _Circle<TPoint<RawShape>>>

Circle libnest2d::placers::minimizeCircle

(

const RawShape &

sh

)

                                          {
    using Point = TPoint<RawShape>;
    using Coord = TCoord<Point>;
 
    auto& ctr = sl::contour(sh);
    if(ctr.empty()) return {{0, 0}, 0};
 
    auto bb = sl::boundingBox(sh);
    auto capprx = bb.center();
    auto rapprx = pl::distance(bb.minCorner(), bb.maxCorner());
 
 
    opt::StopCriteria stopcr;
    stopcr.max_iterations = 30;
    stopcr.relative_score_difference = 1e-3;
    opt::TOptimizer<opt::Method::L_SUBPLEX> solver(stopcr);
 
    std::vector<double> dists(ctr.size(), 0);
 
    auto result = solver.optimize_min(
        [capprx, rapprx, &ctr, &dists](double xf, double yf) {
            auto xt = Coord( std::round(getX(capprx) + rapprx*xf) );
            auto yt = Coord( std::round(getY(capprx) + rapprx*yf) );
 
            Point centr(xt, yt);
 
            unsigned i = 0;
            for(auto v : ctr) {
                dists[i++] = pl::distance(v, centr);
            }
 
            auto mit = std::max_element(dists.begin(), dists.end());
 
            assert(mit != dists.end());
 
            return *mit;
        },
        opt::initvals(0.0, 0.0),
        opt::bound(-1.0, 1.0), opt::bound(-1.0, 1.0)
    );
 
    double oxf = std::get<0>(result.optimum);
    double oyf = std::get<1>(result.optimum);
    auto xt = Coord( std::round(getX(capprx) + rapprx*oxf) );
    auto yt = Coord( std::round(getY(capprx) + rapprx*oyf) );
 
    Point cc(xt, yt);
    auto r = result.score;
 
    return {cc, r};
}

References libnest2d::opt::bound(), libnest2d::shapelike::boundingBox(), libnest2d::shapelike::contour(), libnest2d::pointlike::distance(), libnest2d::getX(), libnest2d::getY(), libnest2d::opt::initvals(), libnest2d::opt::StopCriteria::max_iterations, and libnest2d::opt::StopCriteria::relative_score_difference.

Referenced by boundingCircle().

Here is the call graph for this function:

Here is the caller graph for this function: