libnest2d::placers::_BottomLeftPlacer< RawShape > Class Template Reference

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

Inheritance diagram for libnest2d::placers::_BottomLeftPlacer< RawShape >:

Collaboration diagram for libnest2d::placers::_BottomLeftPlacer< RawShape >:

Public Types
enum class	Dir { LEFT , DOWN }
using	ShapeType = RawShape
using	Item = _Item< RawShape >
using	Vertex = TPoint< RawShape >
using	Segment = _Segment< Vertex >
using	BinType = _Box< TPoint< RawShape > >
using	Coord = TCoord< Vertex >
using	Config = BLConfig< RawShape >
using	ItemGroup = _ItemGroup< RawShape >
using	DefaultIter = typename ItemGroup::const_iterator

Public Member Functions
	_BottomLeftPlacer (const BinType &bin)
template<class Range = ConstItemRange<typename Base::DefaultIter>>
PackResult	trypack (Item &item, const Range &=Range())
RawShape	leftPoly (const Item &item) const
RawShape	downPoly (const Item &item) const
Coord	availableSpaceLeft (const Item &item)
Coord	availableSpaceDown (const Item &item)
const BinType &	bin () const BP2D_NOEXCEPT
void	bin (TB &&b)
void	configure (const Config &config) BP2D_NOEXCEPT
bool	pack (Item &item, const Range &rem=Range())
void	preload (const ItemGroup &packeditems)
void	accept (PackResult &r)
void	unpackLast ()
const ItemGroup &	getItems () const
void	clearItems ()
double	filledArea () const

Protected Member Functions
PackResult	_trypack (Item &item)
void	setInitialPosition (Item &item)
ItemGroup	itemsInTheWayOf (const Item &item, const Dir dir)
Coord	availableSpace (const Item &_item, const Dir dir)
RawShape	toWallPoly (const Item &_item, const Dir dir) const

Static Protected Member Functions
template<class C = Coord>
static enable_if_t< std::is_floating_point< C >::value, bool >	isInTheWayOf (const Item &item, const Item &other, const RawShape &scanpoly)
template<class C = Coord>
static enable_if_t< std::is_integral< C >::value, bool >	isInTheWayOf (const Item &item, const Item &other, const RawShape &scanpoly)

Protected Attributes
BinType	bin_
ItemGroup	items_
BLConfig< RawShape >	config_

Private Types
using	Base = PlacerBoilerplate< _BottomLeftPlacer< RawShape >, RawShape, _Box< TPoint< RawShape > >, BLConfig< RawShape > >

Private Attributes
bool	farea_valid_
double	farea_

Detailed Description

template<class RawShape>
class libnest2d::placers::_BottomLeftPlacer< RawShape >

Member Typedef Documentation

Base

template<class RawShape >

using libnest2d::placers::_BottomLeftPlacer< RawShape >::Base = PlacerBoilerplate<_BottomLeftPlacer<RawShape>, RawShape, _Box<TPoint<RawShape> >, BLConfig<RawShape> >

private

BinType

using libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::BinType = _Box< TPoint< RawShape > >

inherited

Config

using libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::Config = BLConfig< RawShape >

inherited

Coord

using libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::Coord = TCoord<Vertex>

inherited

DefaultIter

using libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::DefaultIter = typename ItemGroup::const_iterator

inherited

Item

using libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::Item = _Item<RawShape>

inherited

ItemGroup

using libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::ItemGroup = _ItemGroup<RawShape>

inherited

Segment

using libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::Segment = _Segment<Vertex>

inherited

ShapeType

using libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::ShapeType = RawShape

inherited

Vertex

using libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::Vertex = TPoint<RawShape>

inherited

Member Enumeration Documentation

Dir

template<class RawShape >

enum class libnest2d::placers::_BottomLeftPlacer::Dir

strong

Enumerator
LEFT
DOWN

                   {
        LEFT,
        DOWN
    };

Constructor & Destructor Documentation

_BottomLeftPlacer()

template<class RawShape >

libnest2d::placers::_BottomLeftPlacer< RawShape >::_BottomLeftPlacer ( const BinType &  bin )

inlineexplicit

: Base(bin) {}

Member Function Documentation

_trypack()

template<class RawShape >

PackResult libnest2d::placers::_BottomLeftPlacer< RawShape >::_trypack ( Item &  item )

inlineprotected

                                    {
 
        // Get initial position for item in the top right corner
        setInitialPosition(item);
 
        Coord d = availableSpaceDown(item);
        auto eps = config_.epsilon;
        bool can_move = d > eps;
        bool can_be_packed = can_move;
        bool left = true;
 
        while(can_move) {
            if(left) { // write previous down move and go down
                item.translate({0, -d+eps});
                d = availableSpaceLeft(item);
                can_move = d > eps;
                left = false;
            } else { // write previous left move and go down
                item.translate({-d+eps, 0});
                d = availableSpaceDown(item);
                can_move = d > eps;
                left = true;
            }
        }
 
        if(can_be_packed) {
            Item trsh(item.transformedShape());
            for(auto& v : trsh) can_be_packed = can_be_packed &&
                    getX(v) < bin_.width() &&
                    getY(v) < bin_.height();
        }
 
        return can_be_packed? PackResult(item) : PackResult();
    }

References libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpaceDown(), libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpaceLeft(), libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape >, RawShape, _Box< TPoint< RawShape > >, BLConfig< RawShape > >::bin_, libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape >, RawShape, _Box< TPoint< RawShape > >, BLConfig< RawShape > >::config_, libnest2d::getX(), libnest2d::getY(), libnest2d::_Box< P >::height(), libnest2d::placers::_BottomLeftPlacer< RawShape >::setInitialPosition(), libnest2d::_Item< RawShape >::transformedShape(), libnest2d::_Item< RawShape >::translate(), and libnest2d::_Box< P >::width().

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::trypack().

Here is the call graph for this function:

Here is the caller graph for this function:

accept()

void libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::accept ( PackResult &  r )

inlineinherited

                               {
        if(r) {
            r.item_ptr_->translation(r.move_);
            r.item_ptr_->rotation(r.rot_);
            items_.emplace_back(*(r.item_ptr_));
            farea_valid_ = false;
        }
    }

availableSpace()

template<class RawShape >

Coord libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpace ( const Item &  _item, const Dir  dir  )

inlineprotected

                                                           {
 
        Item item (_item.transformedShape());
 
 
        std::function<Coord(const Vertex&)> getCoord;
        std::function< std::pair<Coord, bool>(const Segment&, const Vertex&) >
            availableDistanceSV;
 
        std::function< std::pair<Coord, bool>(const Vertex&, const Segment&) >
            availableDistance;
 
        if(dir == Dir::LEFT) {
            getCoord = [](const Vertex& v) { return getX(v); };
            availableDistance = pointlike::horizontalDistance<Vertex>;
            availableDistanceSV = [](const Segment& s, const Vertex& v) {
                auto ret = pointlike::horizontalDistance<Vertex>(v, s);
                if(ret.second) ret.first = -ret.first;
                return ret;
            };
        }
        else {
            getCoord = [](const Vertex& v) { return getY(v); };
            availableDistance = pointlike::verticalDistance<Vertex>;
            availableDistanceSV = [](const Segment& s, const Vertex& v) {
                auto ret = pointlike::verticalDistance<Vertex>(v, s);
                if(ret.second) ret.first = -ret.first;
                return ret;
            };
        }
 
        auto&& items_in_the_way = itemsInTheWayOf(item, dir);
 
        // Comparison function for finding min vertex
        auto cmp = [&getCoord](const Vertex& v1, const Vertex& v2) {
            return getCoord(v1) < getCoord(v2);
        };
 
        // find minimum left or down coordinate of item
        auto minvertex_it = std::min_element(item.begin(),
                                                   item.end(),
                                                   cmp);
 
        // Get the initial distance in floating point
        Coord m = getCoord(*minvertex_it);
 
        // Check available distance for every vertex of item to the objects
        // in the way for the nearest intersection
        if(!items_in_the_way.empty()) { // This is crazy, should be optimized...
            for(Item& pleft : items_in_the_way) {
                // For all segments in items_to_left
 
                assert(pleft.vertexCount() > 0);
 
                auto trpleft_poly = pleft.transformedShape();
                auto& trpleft = sl::contour(trpleft_poly);
                auto first = sl::begin(trpleft);
                auto next = first + 1;
                auto endit = sl::end(trpleft);
 
                while(next != endit) {
                    Segment seg(*(first++), *(next++));
                    for(auto& v : item) {   // For all vertices in item
 
                        auto d = availableDistance(v, seg);
 
                        if(d.second && d.first < m)  m = d.first;
                    }
                }
            }
 
            auto first = item.begin();
            auto next = first + 1;
            auto endit = item.end();
 
            // For all edges in item:
            while(next != endit) {
                Segment seg(*(first++), *(next++));
 
                // for all shapes in items_to_left
                for(Item& sh : items_in_the_way) {
                    assert(sh.vertexCount() > 0);
 
                    Item tsh(sh.transformedShape());
                    for(auto& v : tsh) {   // For all vertices in item
 
                        auto d = availableDistanceSV(seg, v);
 
                        if(d.second && d.first < m)  m = d.first;
                    }
                }
            }
        }
 
        return m;
    }

References libnest2d::_Item< RawShape >::begin(), libnest2d::shapelike::begin(), libnest2d::shapelike::contour(), libnest2d::_Item< RawShape >::end(), libnest2d::shapelike::end(), libnest2d::getX(), libnest2d::getY(), libnest2d::placers::_BottomLeftPlacer< RawShape >::itemsInTheWayOf(), libnest2d::placers::_BottomLeftPlacer< RawShape >::LEFT, and libnest2d::_Item< RawShape >::transformedShape().

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpaceDown(), and libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpaceLeft().

Here is the call graph for this function:

Here is the caller graph for this function:

availableSpaceDown()

template<class RawShape >

Coord libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpaceDown ( const Item &  item )

inline

                                                      {
        return availableSpace(item, Dir::DOWN);
    }

References libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpace(), and libnest2d::placers::_BottomLeftPlacer< RawShape >::DOWN.

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::_trypack().

Here is the call graph for this function:

Here is the caller graph for this function:

availableSpaceLeft()

template<class RawShape >

Coord libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpaceLeft ( const Item &  item )

inline

                                                      {
        return availableSpace(item, Dir::LEFT);
    }

References libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpace(), and libnest2d::placers::_BottomLeftPlacer< RawShape >::LEFT.

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::_trypack().

Here is the call graph for this function:

Here is the caller graph for this function:

bin() [1/2]

const BinType & libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::bin ( ) const

inlineinherited

{ return bin_; }

bin() [2/2]

void libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::bin ( TB &&  b )

inlineinherited

                                               {
        bin_ = std::forward<BinType>(b);
    }

clearItems()

void libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::clearItems ( )

inlineinherited

                             {
        items_.clear();
        farea_valid_ = false;
    }

configure()

void libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::configure ( const Config &  config )

inlineinherited

                                                              {
        config_ = config;
    }

downPoly()

template<class RawShape >

RawShape libnest2d::placers::_BottomLeftPlacer< RawShape >::downPoly ( const Item &  item ) const

inline

                                                     {
        return toWallPoly(item, Dir::DOWN);
    }

References libnest2d::placers::_BottomLeftPlacer< RawShape >::DOWN, and libnest2d::placers::_BottomLeftPlacer< RawShape >::toWallPoly().

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::itemsInTheWayOf().

Here is the call graph for this function:

Here is the caller graph for this function:

filledArea()

double libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::filledArea ( ) const

inlineinherited

                                     {
        if(farea_valid_) return farea_;
        else {
            farea_ = .0;
            std::for_each(items_.begin(), items_.end(),
                          [this] (Item& item) {
                farea_ += item.area();
            });
            farea_valid_ = true;
        }
 
        return farea_;
    }

getItems()

const ItemGroup & libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::getItems ( ) const

inlineinherited

{ return items_; }

isInTheWayOf() [1/2]

template<class RawShape >

template<class C = Coord>

static enable_if_t< std::is_floating_point< C >::value, bool > libnest2d::placers::_BottomLeftPlacer< RawShape >::isInTheWayOf ( const Item &  item, const Item &  other, const RawShape &  scanpoly  )

inlinestaticprotected

    {
        auto tsh = other.transformedShape();
        return ( sl::intersects(tsh, scanpoly) ||
                 sl::isInside(tsh, scanpoly) ) &&
               ( !sl::intersects(tsh, item.rawShape()) &&
                 !sl::isInside(tsh, item.rawShape()) );
    }

References libnest2d::shapelike::intersects(), libnest2d::shapelike::isInside(), libnest2d::_Item< RawShape >::rawShape(), and libnest2d::_Item< RawShape >::transformedShape().

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::itemsInTheWayOf().

Here is the call graph for this function:

Here is the caller graph for this function:

isInTheWayOf() [2/2]

template<class RawShape >

template<class C = Coord>

static enable_if_t< std::is_integral< C >::value, bool > libnest2d::placers::_BottomLeftPlacer< RawShape >::isInTheWayOf ( const Item &  item, const Item &  other, const RawShape &  scanpoly  )

inlinestaticprotected

    {
        auto tsh = other.transformedShape();
 
        bool inters_scanpoly = sl::intersects(tsh, scanpoly) &&
                !sl::touches(tsh, scanpoly);
        bool inters_item = sl::intersects(tsh, item.rawShape()) &&
                !sl::touches(tsh, item.rawShape());
 
        return ( inters_scanpoly ||
                 sl::isInside(tsh, scanpoly)) &&
               ( !inters_item &&
                 !sl::isInside(tsh, item.rawShape())
                 );
    }

References libnest2d::shapelike::intersects(), libnest2d::shapelike::isInside(), libnest2d::_Item< RawShape >::rawShape(), libnest2d::shapelike::touches(), and libnest2d::_Item< RawShape >::transformedShape().

Here is the call graph for this function:

itemsInTheWayOf()

template<class RawShape >

ItemGroup libnest2d::placers::_BottomLeftPlacer< RawShape >::itemsInTheWayOf ( const Item &  item, const Dir  dir  )

inlineprotected

                                                               {
        // Get the left or down polygon, that has the same area as the shadow
        // of input item reflected to the left or downwards
        auto&& scanpoly = dir == Dir::LEFT? leftPoly(item) :
                                            downPoly(item);
 
        ItemGroup ret;    // packed items 'in the way' of item
        ret.reserve(items_.size());
 
        // Predicate to find items that are 'in the way' for left (down) move
        auto predicate = [&scanpoly, &item](const Item& it) {
            return isInTheWayOf(item, it, scanpoly);
        };
 
        // Get the items that are in the way for the left (or down) movement
        std::copy_if(items_.begin(), items_.end(),
                     std::back_inserter(ret), predicate);
 
        return ret;
    }

References libnest2d::placers::_BottomLeftPlacer< RawShape >::downPoly(), libnest2d::placers::_BottomLeftPlacer< RawShape >::isInTheWayOf(), libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape >, RawShape, _Box< TPoint< RawShape > >, BLConfig< RawShape > >::items_, libnest2d::placers::_BottomLeftPlacer< RawShape >::LEFT, and libnest2d::placers::_BottomLeftPlacer< RawShape >::leftPoly().

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

leftPoly()

template<class RawShape >

RawShape libnest2d::placers::_BottomLeftPlacer< RawShape >::leftPoly ( const Item &  item ) const

inline

                                                     {
        return toWallPoly(item, Dir::LEFT);
    }

References libnest2d::placers::_BottomLeftPlacer< RawShape >::LEFT, and libnest2d::placers::_BottomLeftPlacer< RawShape >::toWallPoly().

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::itemsInTheWayOf().

Here is the call graph for this function:

Here is the caller graph for this function:

pack()

bool libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::pack ( Item &  item, const Range &  rem = Range()  )

inlineinherited

                                                      {
        auto&& r = static_cast<Subclass*>(this)->trypack(item, rem);
        if(r) {
            items_.emplace_back(*(r.item_ptr_));
            farea_valid_ = false;
        }
        return r;
    }

preload()

void libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::preload ( const ItemGroup &  packeditems )

inlineinherited

                                               {
        items_.insert(items_.end(), packeditems.begin(), packeditems.end());
        farea_valid_ = false;
    }

setInitialPosition()

template<class RawShape >

void libnest2d::placers::_BottomLeftPlacer< RawShape >::setInitialPosition ( Item &  item )

inlineprotected

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

References libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape >, RawShape, _Box< TPoint< RawShape > >, BLConfig< RawShape > >::bin_, libnest2d::_Item< RawShape >::boundingBox(), libnest2d::getX(), libnest2d::getY(), libnest2d::_Box< P >::maxCorner(), and libnest2d::_Item< RawShape >::translate().

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::_trypack().

Here is the call graph for this function:

Here is the caller graph for this function:

toWallPoly()

template<class RawShape >

RawShape libnest2d::placers::_BottomLeftPlacer< RawShape >::toWallPoly ( const Item &  _item, const Dir  dir  ) const

inlineprotected

Implementation of the left (and down) polygon as described by [López-Camacho et al. 2013]\ (http://www.cs.stir.ac.uk/~goc/papers/EffectiveHueristic2DAOR2013.pdf) see algorithm 8 for details...

                                                                {
        // The variable names reflect the case of left polygon calculation.
        //
        // We will iterate through the item's vertices and search for the top
        // and bottom vertices (or right and left if dir==Dir::DOWN).
        // Save the relevant vertices and their indices into `bottom` and
        // `top` vectors. In case of left polygon construction these will
        // contain the top and bottom polygons which have the same vertical
        // coordinates (in case there is more of them).
        //
        // We get the leftmost (or downmost) vertex from the `bottom` and `top`
        // vectors and construct the final polygon.
 
        Item item (_item.transformedShape());
 
        auto getCoord = [dir](const Vertex& v) {
            return dir == Dir::LEFT? getY(v) : getX(v);
        };
 
        Coord max_y = std::numeric_limits<Coord>::min();
        Coord min_y = std::numeric_limits<Coord>::max();
 
        using El = std::pair<size_t, std::reference_wrapper<const Vertex>>;
 
        std::function<bool(const El&, const El&)> cmp;
 
        if(dir == Dir::LEFT)
            cmp = [](const El& e1, const El& e2) {
                return getX(e1.second.get()) < getX(e2.second.get());
            };
        else
            cmp = [](const El& e1, const El& e2) {
                return getY(e1.second.get()) < getY(e2.second.get());
            };
 
        std::vector< El > top;
        std::vector< El > bottom;
 
        size_t idx = 0;
        for(auto& v : item) { // Find the bottom and top vertices and save them
            auto vref = std::cref(v);
            auto vy = getCoord(v);
 
            if( vy > max_y ) {
                max_y = vy;
                top.clear();
                top.emplace_back(idx, vref);
            }
            else if(vy == max_y) { top.emplace_back(idx, vref); }
 
            if(vy < min_y) {
                min_y = vy;
                bottom.clear();
                bottom.emplace_back(idx, vref);
            }
            else if(vy == min_y) { bottom.emplace_back(idx, vref); }
 
            idx++;
        }
 
        // Get the top and bottom leftmost vertices, or the right and left
        // downmost vertices (if dir == Dir::DOWN)
        auto topleft_it = std::min_element(top.begin(), top.end(), cmp);
        auto bottomleft_it =
                std::min_element(bottom.begin(), bottom.end(), cmp);
 
        auto& topleft_vertex = topleft_it->second.get();
        auto& bottomleft_vertex = bottomleft_it->second.get();
 
        // Start and finish positions for the vertices that will be part of the
        // new polygon
        auto start = std::min(topleft_it->first, bottomleft_it->first);
        auto finish = std::max(topleft_it->first, bottomleft_it->first);
 
        RawShape ret;
 
        // the return shape
        auto& rsh = sl::contour(ret);
 
        // reserve for all vertices plus 2 for the left horizontal wall, 2 for
        // the additional vertices for maintaning min object distance
        sl::reserve(rsh, finish-start+4);
 
        auto addOthers_ = [&rsh, finish, start, &item](){
            for(size_t i = start+1; i < finish; i++)
                sl::addVertex(rsh, item.vertex(i));
        };
 
        auto reverseAddOthers_ = [&rsh, finish, start, &item](){
            for(auto i = finish-1; i > start; i--)
                sl::addVertex(rsh, item.vertex(static_cast<unsigned long>(i)));
        };
 
        auto addOthers = [&]() {
            if constexpr (!is_clockwise<RawShape>())
                addOthers_();
            else
                reverseAddOthers_();
        };
 
        // Final polygon construction...
 
        // Clockwise polygon construction
 
        sl::addVertex(rsh, topleft_vertex);
 
        if(dir == Dir::LEFT) addOthers();
        else {
            sl::addVertex(rsh, {getX(topleft_vertex), 0});
            sl::addVertex(rsh, {getX(bottomleft_vertex), 0});
        }
 
        sl::addVertex(rsh, bottomleft_vertex);
 
        if(dir == Dir::LEFT) {
            sl::addVertex(rsh, {0, getY(bottomleft_vertex)});
            sl::addVertex(rsh, {0, getY(topleft_vertex)});
        }
        else addOthers();
 
 
        // Close the polygon
        if constexpr (ClosureTypeV<RawShape> == Closure::CLOSED)
            sl::addVertex(rsh, topleft_vertex);
 
        if constexpr (!is_clockwise<RawShape>())
            std::reverse(rsh.begin(), rsh.end());
 
        return ret;
    }

References libnest2d::shapelike::addVertex(), libnest2d::CLOSED, libnest2d::shapelike::contour(), libnest2d::getX(), libnest2d::getY(), libnest2d::placers::_BottomLeftPlacer< RawShape >::LEFT, libnest2d::shapelike::reserve(), libnest2d::_Item< RawShape >::transformedShape(), and libnest2d::_Item< RawShape >::vertex().

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::downPoly(), and libnest2d::placers::_BottomLeftPlacer< RawShape >::leftPoly().

Here is the call graph for this function:

Here is the caller graph for this function:

trypack()

template<class RawShape >

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

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

inline

    {
        auto r = _trypack(item);
        if(!r && Base::config_.allow_rotations) {
 
            item.rotate(Degrees(90));
            r =_trypack(item);
        }
        return r;
    }

References libnest2d::placers::_BottomLeftPlacer< RawShape >::_trypack(), libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape >, RawShape, _Box< TPoint< RawShape > >, BLConfig< RawShape > >::config_, and libnest2d::_Item< RawShape >::rotate().

Here is the call graph for this function:

unpackLast()

void libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::unpackLast ( )

inlineinherited

                      {
        items_.pop_back();
        farea_valid_ = false;
    }

Member Data Documentation

bin_

BinType libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::bin_

protectedinherited

config_

BLConfig< RawShape > libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::config_

protectedinherited

farea_

double libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::farea_

mutableprivateinherited

farea_valid_

bool libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::farea_valid_

mutableprivateinherited

items_

ItemGroup libnest2d::placers::PlacerBoilerplate< _BottomLeftPlacer< RawShape > , RawShape, _Box< TPoint< RawShape > > , BLConfig< RawShape > >::items_

protectedinherited

---

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

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