Subclass of _Item for regular rectangle items. More...

#include <src/libnest2d/include/libnest2d/nester.hpp>

Inheritance diagram for libnest2d::_Rectangle< Sh >:

Collaboration diagram for libnest2d::_Rectangle< Sh >:

Public Types
using	Unit = TCoord< Sh >

using	ShapeType = Sh
	The type of the shape which was handed over as the template argument.

using	Iterator = VertexConstIterator
	Iterator type for the outer vertices.

Public Member Functions
	_Rectangle (Unit w, Unit h)

Unit	width () const BP2D_NOEXCEPT

Unit	height () const BP2D_NOEXCEPT

bool	isFixed () const noexcept

void	markAsFixedInBin (int binid)

void	binId (int idx)

int	binId () const noexcept

void	priority (int p)

int	priority () const noexcept

std::string	toString () const
	Convert the polygon to string representation. The format depends on the implementation of the polygon.

Iterator	begin () const
	Iterator tho the first contour vertex in the polygon.

Iterator	cbegin () const
	Alias to begin()

Iterator	end () const
	Iterator to the last contour vertex.

Iterator	cend () const
	Alias to end()

Vertex	vertex (unsigned long idx) const
	Get a copy of an outer vertex within the carried shape.

void	setVertex (unsigned long idx, const Vertex &v)
	Modify a vertex.

void	setShape (Sh rsh)

void	setOnPackedFn (std::function< void(_Item &)> onpackedfn)

void	onPacked ()

double	area () const
	Calculate the shape area.

bool	isContourConvex () const

bool	isHoleConvex (unsigned) const

bool	areHolesConvex () const

size_t	vertexCount () const
	The number of the outer ring vertices.

size_t	holeCount () const

bool	isInside (const Vertex &p) const
	isPointInside

bool	isInside (const _Item &sh) const

bool	isInside (const Sh &sh) const

bool	isInside (const _Box< TPoint< Sh > > &box) const

bool	isInside (const _Circle< TPoint< Sh > > &box) const

void	translate (const Vertex &d) BP2D_NOEXCEPT

void	rotate (const Radians &rads) BP2D_NOEXCEPT

void	inflation (Coord distance) BP2D_NOEXCEPT

Coord	inflation () const BP2D_NOEXCEPT

void	inflate (Coord distance) BP2D_NOEXCEPT

Radians	rotation () const BP2D_NOEXCEPT

void	rotation (Radians rot) BP2D_NOEXCEPT

TPoint< Sh >	translation () const BP2D_NOEXCEPT

void	translation (const TPoint< Sh > &tr) BP2D_NOEXCEPT

const Sh &	transformedShape () const

	operator Sh () const

const Sh &	rawShape () const BP2D_NOEXCEPT

void	resetTransformation () BP2D_NOEXCEPT

Box	boundingBox () const

Vertex	referenceVertex () const

Vertex	rightmostTopVertex () const

Vertex	leftmostBottomVertex () const

Static Public Member Functions
static BP2D_CONSTEXPR Orientation	orientation ()
	Get the orientation of the polygon.

static bool	intersects (const _Item &sh1, const _Item &sh2)

static bool	touches (const _Item &sh1, const _Item &sh2)

Private Types
using	TO = Orientation

enum	Convexity

using	Coord = TCoord< TPoint< Sh > >

using	Vertex = TPoint< Sh >

using	Box = _Box< Vertex >

using	VertexConstIterator = typename TContour< Sh >::const_iterator

Private Member Functions
const Sh &	infaltedShape () const

void	invalidateCache () const BP2D_NOEXCEPT

Static Private Member Functions
static bool	vsort (const Vertex &v1, const Vertex &v2)

Private Attributes
Sh	sh_

Vertex	translation_

Radians	rotation_

Coord	inflation_

bool	has_rotation_

bool	has_translation_

bool	has_inflation_

Sh	tr_cache_

bool	tr_cache_valid_

double	area_cache_

bool	area_cache_valid_

Sh	inflate_cache_

bool	inflate_cache_valid_

Convexity	convexity_

VertexConstIterator	rmt_

VertexConstIterator	lmb_

bool	rmt_valid_

bool	lmb_valid_

struct libnest2d::_Item::BBCache	bb_cache_

int	binid_

int	priority_

bool	fixed_

std::function< void(_Item &)>	on_packed_

Detailed Description

template<class Sh>
class libnest2d::_Rectangle< Sh >

Subclass of _Item for regular rectangle items.

Member Typedef Documentation

◆ Box

using libnest2d::_Item< Sh >::Box = _Box<Vertex>

privateinherited

◆ Coord

using libnest2d::_Item< Sh >::Coord = TCoord<TPoint<Sh > >

privateinherited

◆ Iterator

using libnest2d::_Item< Sh >::Iterator = VertexConstIterator

inherited

Iterator type for the outer vertices.

Only const iterators can be used. The _Item type is not intended to modify the carried shapes from the outside. The main purpose of this type is to cache the calculation results from the various operators it supports. Giving out a non const iterator would make it impossible to perform correct cache invalidation.

◆ ShapeType

using libnest2d::_Item< Sh >::ShapeType = Sh

inherited

The type of the shape which was handed over as the template argument.

◆ TO

template<class Sh >

using libnest2d::_Rectangle< Sh >::TO = Orientation

private

◆ Unit

template<class Sh >

using libnest2d::_Rectangle< Sh >::Unit = TCoord<Sh>

◆ Vertex

using libnest2d::_Item< Sh >::Vertex = TPoint<Sh >

privateinherited

◆ VertexConstIterator

using libnest2d::_Item< Sh >::VertexConstIterator = typename TContour<Sh >::const_iterator

privateinherited

Member Enumeration Documentation

◆ Convexity

enum libnest2d::_Item::Convexity : char

strongprivateinherited

                        : char {
        UNCHECKED,
        C_TRUE,
        C_FALSE
    };

Constructor & Destructor Documentation

◆ _Rectangle()

template<class Sh >

libnest2d::_Rectangle< Sh >::_Rectangle	(	Unit	w,
		Unit	h
	)

inline

492: _Item<Sh>{create_rect<Sh>(w, h)} {}

Member Function Documentation

◆ area()

double libnest2d::_Item< Sh >::area ( ) const

inlineinherited

Calculate the shape area.

The method returns absolute value and does not reflect polygon orientation. The result is cached, subsequent calls will have very little cost.

Returns: The shape area in floating point double precision.

                               {
        double ret ;
        if(area_cache_valid_) ret = area_cache_;
        else {
            ret = sl::area(infaltedShape());
            area_cache_ = ret;
            area_cache_valid_ = true;
        }
        return ret;
    }

◆ areHolesConvex()

bool libnest2d::_Item< Sh >::areHolesConvex ( ) const

inlineinherited

                                       {
        return false;
    }

◆ begin()

Iterator libnest2d::_Item< Sh >::begin ( ) const

inlineinherited

Iterator tho the first contour vertex in the polygon.

    {
        return sl::cbegin(sh_);
    }

◆ binId() [1/2]

int libnest2d::_Item< Sh >::binId ( ) const

inlinenoexceptinherited

140{ return binid_; }

libnest2d::_Item< Sh >::binid_

int binid_

Definition nester.hpp:71

◆ binId() [2/2]

void libnest2d::_Item< Sh >::binId ( int idx )

inlineinherited

139{ binid_ = idx; }

◆ boundingBox()

Box libnest2d::_Item< Sh >::boundingBox ( ) const

inlineinherited

                                   {
        if(!bb_cache_.valid) {
            if(!has_rotation_)
                bb_cache_.bb = sl::boundingBox(infaltedShape());
            else {
                // TODO make sure this works
                auto rotsh = infaltedShape();
                sl::rotate(rotsh, rotation_);
                bb_cache_.bb = sl::boundingBox(rotsh);
            }
            bb_cache_.valid = true;
        }
 
        auto &bb = bb_cache_.bb; auto &tr = translation_;
        return {bb.minCorner() + tr, bb.maxCorner() + tr };
    }

◆ cbegin()

Iterator libnest2d::_Item< Sh >::cbegin ( ) const

inlineinherited

Alias to begin()

    {
        return sl::cbegin(sh_);
    }

◆ cend()

Iterator libnest2d::_Item< Sh >::cend ( ) const

inlineinherited

Alias to end()

    {
        return sl::cend(sh_);
    }

◆ end()

Iterator libnest2d::_Item< Sh >::end ( ) const

inlineinherited

Iterator to the last contour vertex.

    {
        return sl::cend(sh_);
    }

◆ height()

template<class Sh >

Unit libnest2d::_Rectangle< Sh >::height ( ) const

inline

                                             {
        return getY(vertex(2));
    }

References libnest2d::getY(), and libnest2d::_Item< Sh >::vertex().

Here is the call graph for this function:

◆ holeCount()

size_t libnest2d::_Item< Sh >::holeCount ( ) const

inlineinherited

                                    {
        return sl::holeCount(sh_);
    }

◆ infaltedShape()

const Sh & libnest2d::_Item< Sh >::infaltedShape ( ) const

inlineprivateinherited

                                                 {
        if(has_inflation_ ) {
            if(inflate_cache_valid_) return inflate_cache_;
 
            inflate_cache_ = sh_;
            sl::offset(inflate_cache_, inflation_);
            inflate_cache_valid_ = true;
            return inflate_cache_;
        }
        return sh_;
    }

◆ inflate()

void libnest2d::_Item< Sh >::inflate ( Coord distance )

inlineinherited

    {
        inflation(inflation() + distance);
    }

◆ inflation() [1/2]

Coord libnest2d::_Item< Sh >::inflation ( ) const

inlineinherited

                                                 {
        return inflation_;
    }

◆ inflation() [2/2]

void libnest2d::_Item< Sh >::inflation ( Coord distance )

inlineinherited

    {
        inflation_ = distance;
        has_inflation_ = true;
        invalidateCache();
    }

◆ intersects()

static bool libnest2d::_Item< Sh >::intersects	(	const _Item< Sh > &	sh1,
		const _Item< Sh > &	sh2
	)

inlinestaticinherited

    {
        return sl::intersects(sh1.transformedShape(),
                                     sh2.transformedShape());
    }

◆ invalidateCache()

void libnest2d::_Item< Sh >::invalidateCache ( ) const

inlineprivateinherited

    {
        tr_cache_valid_ = false;
        lmb_valid_ = false; rmt_valid_ = false;
        area_cache_valid_ = false;
        inflate_cache_valid_ = false;
        bb_cache_.valid = false;
        convexity_ = Convexity::UNCHECKED;
    }

◆ isContourConvex()

bool libnest2d::_Item< Sh >::isContourConvex ( ) const

inlineinherited

                                        {
        bool ret = false;
 
        switch(convexity_) {
        case Convexity::UNCHECKED:
            ret = sl::isConvex(sl::contour(transformedShape()));
            convexity_ = ret? Convexity::C_TRUE : Convexity::C_FALSE;
            break;
        case Convexity::C_TRUE: ret = true; break;
        case Convexity::C_FALSE:;
        }
 
        return ret;
    }

◆ isFixed()

bool libnest2d::_Item< Sh >::isFixed ( ) const

inlinenoexceptinherited

132{ return fixed_; }

libnest2d::_Item< Sh >::fixed_

bool fixed_

Definition nester.hpp:72

◆ isHoleConvex()

bool libnest2d::_Item< Sh >::isHoleConvex ( unsigned ) const

inlineinherited

                                               {
        return false;
    }

◆ isInside() [1/5]

bool libnest2d::_Item< Sh >::isInside ( const _Box< TPoint< Sh > > & box ) const

inlineinherited

                                                                             {
    return sl::isInside(boundingBox(), box);
}

◆ isInside() [2/5]

bool libnest2d::_Item< Sh >::isInside ( const _Circle< TPoint< Sh > > & box ) const

inlineinherited

                                                                     {
    return sl::isInside(transformedShape(), circ);
}

◆ isInside() [3/5]

bool libnest2d::_Item< Sh >::isInside ( const _Item< Sh > & sh ) const

inlineinherited

    {
        return sl::isInside(transformedShape(), sh.transformedShape());
    }

◆ isInside() [4/5]

bool libnest2d::_Item< Sh >::isInside ( const Sh & sh ) const

inlineinherited

    {
        return sl::isInside(transformedShape(), sh);
    }

◆ isInside() [5/5]

bool libnest2d::_Item< Sh >::isInside ( const Vertex & p ) const

inlineinherited

isPointInside

Parameters

p

Returns

    {
        return sl::isInside(p, transformedShape());
    }

◆ leftmostBottomVertex()

Vertex libnest2d::_Item< Sh >::leftmostBottomVertex ( ) const

inlineinherited

                                               {
        if(!lmb_valid_ || !tr_cache_valid_) {  // find min x and min y vertex
            auto& tsh = transformedShape();
            lmb_ = std::min_element(sl::cbegin(tsh), sl::cend(tsh), vsort);
            lmb_valid_ = true;
        }
        return *lmb_;
    }

◆ markAsFixedInBin()

void libnest2d::_Item< Sh >::markAsFixedInBin ( int binid )

inlineinherited

    {
        fixed_ = binid >= 0;
        binid_ = binid;
    }

◆ onPacked()

void libnest2d::_Item< Sh >::onPacked ( )

inlineinherited

    {
        if (on_packed_)
            on_packed_(*this);
    }

◆ operator Sh()

libnest2d::_Item< Sh >::operator Sh ( ) const

inlineinherited

    {
        return transformedShape();
    }

◆ orientation()

static BP2D_CONSTEXPR Orientation libnest2d::_Item< Sh >::orientation ( )

inlinestaticinherited

Get the orientation of the polygon.

The orientation have to be specified as a specialization of the OrientationType struct which has a Value constant.

Returns: The orientation type identifier for the _Item type.

                                                    {
        return OrientationType<TContour<RawShape>>::Value;
    }

◆ priority() [1/2]

int libnest2d::_Item< Sh >::priority ( ) const

inlinenoexceptinherited

143{ return priority_; }

libnest2d::_Item< Sh >::priority_

int priority_

Definition nester.hpp:71

◆ priority() [2/2]

void libnest2d::_Item< Sh >::priority ( int p )

inlineinherited

142{ priority_ = p; }

◆ rawShape()

const Sh & libnest2d::_Item< Sh >::rawShape ( ) const

inlineinherited

    {
        return sh_;
    }

◆ referenceVertex()

Vertex libnest2d::_Item< Sh >::referenceVertex ( ) const

inlineinherited

                                          {
        return rightmostTopVertex();
    }

◆ resetTransformation()

void libnest2d::_Item< Sh >::resetTransformation ( )

inlineinherited

    {
        has_translation_ = false; has_rotation_ = false; has_inflation_ = false;
        invalidateCache();
    }

◆ rightmostTopVertex()

Vertex libnest2d::_Item< Sh >::rightmostTopVertex ( ) const

inlineinherited

                                             {
        if(!rmt_valid_ || !tr_cache_valid_) {  // find max x and max y vertex
            auto& tsh = transformedShape();
            rmt_ = std::max_element(sl::cbegin(tsh), sl::cend(tsh), vsort);
            rmt_valid_ = true;
        }
        return *rmt_;
    }

◆ rotate()

void libnest2d::_Item< Sh >::rotate ( const Radians & rads )

inlineinherited

    {
        rotation(rotation() + rads);
    }

◆ rotation() [1/2]

Radians libnest2d::_Item< Sh >::rotation ( ) const

inlineinherited

    {
        return rotation_;
    }

◆ rotation() [2/2]

void libnest2d::_Item< Sh >::rotation ( Radians rot )

inlineinherited

    {
        if(rotation_ != rot) {
            rotation_ = rot; has_rotation_ = true; tr_cache_valid_ = false;
            rmt_valid_ = false; lmb_valid_ = false;
            bb_cache_.valid = false;
        }
    }

◆ setOnPackedFn()

void libnest2d::_Item< Sh >::setOnPackedFn ( std::function< void(_Item< Sh > &)> onpackedfn )

inlineinherited

    {
        on_packed_ = onpackedfn;
    }

◆ setShape()

void libnest2d::_Item< Sh >::setShape ( Sh rsh )

inlineinherited

    {
        sh_ = std::move(rsh);
        invalidateCache();
    }

◆ setVertex()

void libnest2d::_Item< Sh >::setVertex	(	unsigned long	idx,
		const Vertex &	v
	)

inlineinherited

Modify a vertex.

Note that this method will invalidate every cached calculation result including polygon offset and transformations.

Parameters

idx	The index of the requested vertex.
v	The new vertex data.

    {
        invalidateCache();
        sl::vertex(sh_, idx) = v;
    }

◆ toString()

std::string libnest2d::_Item< Sh >::toString ( ) const

inlineinherited

Convert the polygon to string representation. The format depends on the implementation of the polygon.

Returns

    {
        return sl::toString(sh_);
    }

◆ touches()

static bool libnest2d::_Item< Sh >::touches	(	const _Item< Sh > &	sh1,
		const _Item< Sh > &	sh2
	)

inlinestaticinherited

    {
        return sl::touches(sh1.transformedShape(),
                                  sh2.transformedShape());
    }

◆ transformedShape()

const Sh & libnest2d::_Item< Sh >::transformedShape ( ) const

inlineinherited

    {
        if(tr_cache_valid_) return tr_cache_;
 
        RawShape cpy = infaltedShape();
        if(has_rotation_) sl::rotate(cpy, rotation_);
        if(has_translation_) sl::translate(cpy, translation_);
        tr_cache_ = cpy; tr_cache_valid_ = true;
        rmt_valid_ = false; lmb_valid_ = false;
 
        return tr_cache_;
    }

◆ translate()

void libnest2d::_Item< Sh >::translate ( const Vertex & d )

inlineinherited

    {
        translation(translation() + d);
    }

◆ translation() [1/2]

TPoint< Sh > libnest2d::_Item< Sh >::translation ( ) const

inlineinherited

    {
        return translation_;
    }

◆ translation() [2/2]

void libnest2d::_Item< Sh >::translation ( const TPoint< Sh > & tr )

inlineinherited

    {
        if(translation_ != tr) {
            translation_ = tr; has_translation_ = true; tr_cache_valid_ = false;
            //bb_cache_.valid = false;
        }
    }

◆ vertex()

Vertex libnest2d::_Item< Sh >::vertex ( unsigned long idx ) const

inlineinherited

Get a copy of an outer vertex within the carried shape.

Note that the vertex considered here is taken from the original shape that this item is constructed from. This means that no transformation is applied to the shape in this call.

Parameters

idx	The index of the requested vertex.

Returns: A copy of the requested vertex.

    {
        return sl::vertex(sh_, idx);
    }

◆ vertexCount()

size_t libnest2d::_Item< Sh >::vertexCount ( ) const

inlineinherited

The number of the outer ring vertices.

                                      {
        return sl::contourVertexCount(sh_);
    }

◆ vsort()

static bool libnest2d::_Item< Sh >::vsort	(	const Vertex &	v1,
		const Vertex &	v2
	)

inlinestaticprivateinherited

    {
        TCompute<Vertex> x1 = getX(v1), x2 = getX(v2);
        TCompute<Vertex> y1 = getY(v1), y2 = getY(v2);
        return y1 == y2 ? x1 < x2 : y1 < y2;
    }

◆ width()

template<class Sh >

Unit libnest2d::_Rectangle< Sh >::width ( ) const

inline

                                            {
        return getX(vertex(2));
    }

References libnest2d::getX(), and libnest2d::_Item< Sh >::vertex().

Sh libnest2d::_Item< Sh >::tr_cache_

mutableprivateinherited

◆ tr_cache_valid_

bool libnest2d::_Item< Sh >::tr_cache_valid_

mutableprivateinherited

◆ translation_

Vertex libnest2d::_Item< Sh >::translation_

privateinherited

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

src/libnest2d/include/libnest2d/nester.hpp

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Box

◆ Coord

◆ Iterator

◆ ShapeType

◆ TO

◆ Unit

◆ Vertex

◆ VertexConstIterator

Member Enumeration Documentation

◆ Convexity

Constructor & Destructor Documentation

◆ _Rectangle()

Member Function Documentation

◆ area()

◆ areHolesConvex()

◆ begin()

◆ binId() [1/2]

◆ binId() [2/2]

◆ boundingBox()

◆ cbegin()

◆ cend()

◆ end()

◆ height()

◆ holeCount()

◆ infaltedShape()

◆ inflate()

◆ inflation() [1/2]

◆ inflation() [2/2]

◆ intersects()

◆ invalidateCache()

◆ isContourConvex()

◆ isFixed()

◆ isHoleConvex()

◆ isInside() [1/5]

◆ isInside() [2/5]

◆ isInside() [3/5]

◆ isInside() [4/5]

◆ isInside() [5/5]

◆ leftmostBottomVertex()

◆ markAsFixedInBin()

◆ onPacked()

◆ operator Sh()

◆ orientation()

◆ priority() [1/2]

◆ priority() [2/2]

◆ rawShape()

◆ referenceVertex()

◆ resetTransformation()

◆ rightmostTopVertex()

◆ rotate()

◆ rotation() [1/2]

◆ rotation() [2/2]

◆ setOnPackedFn()

◆ setShape()

◆ setVertex()

◆ toString()

◆ touches()

◆ transformedShape()

◆ translate()

◆ translation() [1/2]

◆ translation() [2/2]

◆ vertex()

◆ vertexCount()

◆ vsort()

◆ width()

Member Data Documentation

◆ area_cache_

◆ area_cache_valid_

◆ bb_cache_

◆ binid_

◆ convexity_