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

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

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

Classes
struct	ContourCache

Public Types
using	iterator = std::vector< double >::iterator
using	const_iterator = std::vector< double >::const_iterator

Public Member Functions
	EdgeCache ()=default
	EdgeCache (const _Item< RawShape > &item)
	EdgeCache (const RawShape &sh)
void	accuracy (double a)
	Resolution of returned corners. The stride is derived from this value.
Vertex	coords (double distance) const
	Get a point on the circumference of a polygon.
Vertex	coords (unsigned hidx, double distance) const
double	circumference () const BP2D_NOEXCEPT
double	circumference (unsigned hidx) const BP2D_NOEXCEPT
const std::vector< double > &	corners () const BP2D_NOEXCEPT
	Get the normalized distance values for each vertex.
const std::vector< double > &	corners (unsigned holeidx) const BP2D_NOEXCEPT
	corners for a specific hole
size_t	holeCount () const BP2D_NOEXCEPT
	The number of holes in the abstracted polygon.

Private Types
using	Vertex = TPoint< RawShape >
using	Coord = TCoord< Vertex >
using	Edge = _Segment< Vertex >

Private Member Functions
void	createCache (const RawShape &sh)
size_t	stride (const size_t N) const
void	fetchCorners () const
void	fetchHoleCorners (unsigned hidx) const
Vertex	coords (const ContourCache &cache, double distance) const

Static Private Member Functions
static double	length (const Edge &e)

Private Attributes
struct libnest2d::placers::EdgeCache::ContourCache	contour_
std::vector< ContourCache >	holes_
double	accuracy_ = 1.0

Detailed Description

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

A class for getting a point on the circumference of the polygon (in log time)

This is a transformation of the provided polygon to be able to pinpoint locations on the circumference. The optimizer will pass a floating point value e.g. within <0,1> and we have to transform this value quickly into a coordinate on the circumference. By definition 0 should yield the first vertex and 1.0 would be the last (which should coincide with first).

We also have to make this work for the holes of the captured polygon.

---

Class Documentation

libnest2d::placers::EdgeCache::ContourCache

struct libnest2d::placers::EdgeCache::ContourCache

template<class RawShape>
struct libnest2d::placers::EdgeCache< RawShape >::ContourCache

Collaboration diagram for libnest2d::placers::EdgeCache< RawShape >::ContourCache:

Class Members
vector< double >	corners
vector< double >	distances
vector< Edge >	emap
double	full_distance = 0

Member Typedef Documentation

const_iterator

template<class RawShape >

using libnest2d::placers::EdgeCache< RawShape >::const_iterator = std::vector<double>::const_iterator

Coord

template<class RawShape >

using libnest2d::placers::EdgeCache< RawShape >::Coord = TCoord<Vertex>

private

Edge

template<class RawShape >

using libnest2d::placers::EdgeCache< RawShape >::Edge = _Segment<Vertex>

private

iterator

template<class RawShape >

using libnest2d::placers::EdgeCache< RawShape >::iterator = std::vector<double>::iterator

Vertex

template<class RawShape >

using libnest2d::placers::EdgeCache< RawShape >::Vertex = TPoint<RawShape>

private

Constructor & Destructor Documentation

EdgeCache() [1/3]

template<class RawShape >

libnest2d::placers::EdgeCache< RawShape >::EdgeCache ( )

inlinedefault

EdgeCache() [2/3]

template<class RawShape >

libnest2d::placers::EdgeCache< RawShape >::EdgeCache ( const _Item< RawShape > &  item )

inline

    {
        createCache(item.transformedShape());
    }

References libnest2d::placers::EdgeCache< RawShape >::createCache(), and libnest2d::_Item< RawShape >::transformedShape().

Here is the call graph for this function:

EdgeCache() [3/3]

template<class RawShape >

libnest2d::placers::EdgeCache< RawShape >::EdgeCache ( const RawShape &  sh )

inline

    {
        createCache(sh);
    }

References libnest2d::placers::EdgeCache< RawShape >::createCache().

Here is the call graph for this function:

Member Function Documentation

accuracy()

template<class RawShape >

void libnest2d::placers::EdgeCache< RawShape >::accuracy ( double  a )

inline

Resolution of returned corners. The stride is derived from this value.

{ accuracy_ = a; }

References libnest2d::placers::EdgeCache< RawShape >::accuracy_.

circumference() [1/2]

template<class RawShape >

double libnest2d::placers::EdgeCache< RawShape >::circumference ( ) const

inline

                                                      {
        return contour_.full_distance;
    }

References libnest2d::placers::EdgeCache< RawShape >::contour_, and libnest2d::placers::EdgeCache< RawShape >::ContourCache::full_distance.

circumference() [2/2]

template<class RawShape >

double libnest2d::placers::EdgeCache< RawShape >::circumference ( unsigned  hidx ) const

inline

                                                                   {
        return holes_[hidx].full_distance;
    }

References libnest2d::placers::EdgeCache< RawShape >::holes_.

coords() [1/3]

template<class RawShape >

Vertex libnest2d::placers::EdgeCache< RawShape >::coords ( const ContourCache &  cache, double  distance  ) const

inlineprivate

                                                                           {
        assert(distance >= .0 && distance <= 1.0);
        if (cache.distances.empty() || cache.emap.empty()) return Vertex{};
        if (distance > 1.0) distance = std::fmod(distance, 1.0);
 
        // distance is from 0.0 to 1.0, we scale it up to the full length of
        // the circumference
        double d = distance*cache.full_distance;
 
        auto& distances = cache.distances;
 
        // Magic: we find the right edge in log time
        auto it = std::lower_bound(distances.begin(), distances.end(), d);
        auto idx = it - distances.begin();      // get the index of the edge
        auto edge = cache.emap[idx];         // extrac the edge
 
        // Get the remaining distance on the target edge
        auto ed = d - (idx > 0 ? *std::prev(it) : 0 );
        auto angle = edge.angleToXaxis();
        Vertex ret = edge.first();
 
        // Get the point on the edge which lies in ed distance from the start
        ret += Vertex(static_cast<Coord>(std::round(ed*std::cos(angle))),
                      static_cast<Coord>(std::round(ed*std::sin(angle))));
 
        return ret;
    }

References libnest2d::placers::EdgeCache< RawShape >::ContourCache::distances, libnest2d::placers::EdgeCache< RawShape >::ContourCache::emap, and libnest2d::placers::EdgeCache< RawShape >::ContourCache::full_distance.

Referenced by libnest2d::placers::EdgeCache< RawShape >::coords(), and libnest2d::placers::EdgeCache< RawShape >::coords().

Here is the caller graph for this function:

coords() [2/3]

template<class RawShape >

Vertex libnest2d::placers::EdgeCache< RawShape >::coords ( double  distance ) const

inline

Get a point on the circumference of a polygon.

Parameters

distance

A relative distance from the starting point to the end. Can be from 0.0 to 1.0 where 0.0 is the starting point and 1.0 is the closing point (which should be eqvivalent with the starting point with closed polygons).

Returns

Returns the coordinates of the point lying on the polygon circumference.

                                                {
        return coords(contour_, distance);
    }

References libnest2d::placers::EdgeCache< RawShape >::contour_, and libnest2d::placers::EdgeCache< RawShape >::coords().

Here is the call graph for this function:

coords() [3/3]

template<class RawShape >

Vertex libnest2d::placers::EdgeCache< RawShape >::coords ( unsigned  hidx, double  distance  ) const

inline

                                                               {
        assert(hidx < holes_.size());
        return coords(holes_[hidx], distance);
    }

References libnest2d::placers::EdgeCache< RawShape >::coords(), and libnest2d::placers::EdgeCache< RawShape >::holes_.

Here is the call graph for this function:

corners() [1/2]

template<class RawShape >

const std::vector< double > & libnest2d::placers::EdgeCache< RawShape >::corners ( ) const

inline

Get the normalized distance values for each vertex.

                                                                  {
        fetchCorners();
        return contour_.corners;
    }

References libnest2d::placers::EdgeCache< RawShape >::contour_, libnest2d::placers::EdgeCache< RawShape >::ContourCache::corners, and libnest2d::placers::EdgeCache< RawShape >::fetchCorners().

Here is the call graph for this function:

corners() [2/2]

template<class RawShape >

const std::vector< double > & libnest2d::placers::EdgeCache< RawShape >::corners ( unsigned  holeidx ) const

inline

corners for a specific hole

                                                  {
        fetchHoleCorners(holeidx);
        return holes_[holeidx].corners;
    }

References libnest2d::placers::EdgeCache< RawShape >::fetchHoleCorners(), and libnest2d::placers::EdgeCache< RawShape >::holes_.

Here is the call graph for this function:

createCache()

template<class RawShape >

void libnest2d::placers::EdgeCache< RawShape >::createCache ( const RawShape &  sh )

inlineprivate

                                         {
        {   // For the contour
            auto first = sl::cbegin(sh);
            auto endit = sl::cend(sh);
            auto next = first == endit ? endit : std::next(first);
 
            contour_.distances.reserve(sl::contourVertexCount(sh));
 
            while(next != endit) {
                contour_.emap.emplace_back(*(first++), *(next++));
                contour_.full_distance += length(contour_.emap.back());
                contour_.distances.emplace_back(contour_.full_distance);
            }
 
            if constexpr (ClosureTypeV<RawShape> == Closure::OPEN) {
                if (sl::contourVertexCount(sh) > 0) {
                    contour_.emap.emplace_back(sl::back(sh), sl::front(sh));
                    contour_.full_distance += length(contour_.emap.back());
                    contour_.distances.emplace_back(contour_.full_distance);
                }
            }
        }
 
        for(auto& h : shapelike::holes(sh)) { // For the holes
            auto first = sl::cbegin(h);
            auto endit = sl::cend(h);
            auto next = first == endit ? endit :std::next(first);
 
            ContourCache hc;
            hc.distances.reserve(sl::contourVertexCount(h));
 
            while(next != endit) {
                hc.emap.emplace_back(*(first++), *(next++));
                hc.full_distance += length(hc.emap.back());
                hc.distances.emplace_back(hc.full_distance);
            }
 
            if constexpr (ClosureTypeV<RawShape> == Closure::OPEN) {
                if (sl::contourVertexCount(h) > 0) {
                    hc.emap.emplace_back(sl::back(sh), sl::front(sh));
                    hc.full_distance += length(hc.emap.back());
                    hc.distances.emplace_back(hc.full_distance);
                }
            }
 
            holes_.emplace_back(std::move(hc));
        }
    }

References libnest2d::shapelike::back(), libnest2d::shapelike::cbegin(), libnest2d::shapelike::cend(), libnest2d::placers::EdgeCache< RawShape >::contour_, libnest2d::shapelike::contourVertexCount(), libnest2d::placers::EdgeCache< RawShape >::ContourCache::distances, libnest2d::placers::EdgeCache< RawShape >::ContourCache::emap, libnest2d::shapelike::front(), libnest2d::placers::EdgeCache< RawShape >::ContourCache::full_distance, libnest2d::shapelike::holes(), libnest2d::placers::EdgeCache< RawShape >::holes_, libnest2d::placers::EdgeCache< RawShape >::length(), and libnest2d::OPEN.

Referenced by libnest2d::placers::EdgeCache< RawShape >::EdgeCache(), and libnest2d::placers::EdgeCache< RawShape >::EdgeCache().

Here is the call graph for this function:

Here is the caller graph for this function:

fetchCorners()

template<class RawShape >

void libnest2d::placers::EdgeCache< RawShape >::fetchCorners ( ) const

inlineprivate

                              {
        if(!contour_.corners.empty()) return;
 
        const auto N = contour_.distances.size();
        const auto S = stride(N);
 
        contour_.corners.reserve(N / S + 1);
        contour_.corners.emplace_back(0.0);
        auto N_1 = N-1;
        for(size_t i = 0; i < N_1; i += S) {
            contour_.corners.emplace_back(
                    contour_.distances.at(i) / contour_.full_distance);
        }
    }

References libnest2d::placers::EdgeCache< RawShape >::contour_, libnest2d::placers::EdgeCache< RawShape >::ContourCache::corners, libnest2d::placers::EdgeCache< RawShape >::ContourCache::distances, libnest2d::placers::EdgeCache< RawShape >::ContourCache::full_distance, and libnest2d::placers::EdgeCache< RawShape >::stride().

Referenced by libnest2d::placers::EdgeCache< RawShape >::corners().

Here is the call graph for this function:

Here is the caller graph for this function:

fetchHoleCorners()

template<class RawShape >

void libnest2d::placers::EdgeCache< RawShape >::fetchHoleCorners ( unsigned  hidx ) const

inlineprivate

                                               {
        auto& hc = holes_[hidx];
        if(!hc.corners.empty()) return;
 
        const auto N = hc.distances.size();
        auto N_1 = N-1;
        const auto S = stride(N);
        hc.corners.reserve(N / S + 1);
        hc.corners.emplace_back(0.0);
        for(size_t i = 0; i < N_1; i += S) {
            hc.corners.emplace_back(
                    hc.distances.at(i) / hc.full_distance);
        }
    }

References libnest2d::placers::EdgeCache< RawShape >::holes_, and libnest2d::placers::EdgeCache< RawShape >::stride().

Referenced by libnest2d::placers::EdgeCache< RawShape >::corners().

Here is the call graph for this function:

Here is the caller graph for this function:

holeCount()

template<class RawShape >

size_t libnest2d::placers::EdgeCache< RawShape >::holeCount ( ) const

inline

The number of holes in the abstracted polygon.

{ return holes_.size(); }

References libnest2d::placers::EdgeCache< RawShape >::holes_.

length()

template<class RawShape >

static double libnest2d::placers::EdgeCache< RawShape >::length ( const Edge &  e )

inlinestaticprivate

    { 
        return std::sqrt(e.template sqlength<double>());
    }

Referenced by libnest2d::placers::EdgeCache< RawShape >::createCache().

Here is the caller graph for this function:

stride()

template<class RawShape >

size_t libnest2d::placers::EdgeCache< RawShape >::stride ( const size_t  N ) const

inlineprivate

                                        {
        using std::round;
        using std::pow;
 
        return static_cast<Coord>(
                    round(N/pow(N, pow(accuracy_, 1.0/3.0)))
                );
    }

References libnest2d::placers::EdgeCache< RawShape >::accuracy_, and round().

Referenced by libnest2d::placers::EdgeCache< RawShape >::fetchCorners(), and libnest2d::placers::EdgeCache< RawShape >::fetchHoleCorners().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

accuracy_

template<class RawShape >

double libnest2d::placers::EdgeCache< RawShape >::accuracy_ = 1.0

private

Referenced by libnest2d::placers::EdgeCache< RawShape >::accuracy(), and libnest2d::placers::EdgeCache< RawShape >::stride().

contour_

template<class RawShape >

struct libnest2d::placers::EdgeCache::ContourCache libnest2d::placers::EdgeCache< RawShape >::contour_

private

Referenced by libnest2d::placers::EdgeCache< RawShape >::circumference(), libnest2d::placers::EdgeCache< RawShape >::coords(), libnest2d::placers::EdgeCache< RawShape >::corners(), libnest2d::placers::EdgeCache< RawShape >::createCache(), and libnest2d::placers::EdgeCache< RawShape >::fetchCorners().

holes_

template<class RawShape >

std::vector<ContourCache> libnest2d::placers::EdgeCache< RawShape >::holes_

private

Referenced by libnest2d::placers::EdgeCache< RawShape >::circumference(), libnest2d::placers::EdgeCache< RawShape >::coords(), libnest2d::placers::EdgeCache< RawShape >::corners(), libnest2d::placers::EdgeCache< RawShape >::createCache(), libnest2d::placers::EdgeCache< RawShape >::fetchHoleCorners(), and libnest2d::placers::EdgeCache< RawShape >::holeCount().

---

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

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