libnest2d::shapelike Namespace Reference

Functions
template<>
void	offset (Slic3r::ExPolygon &sh, coord_t distance, const PolygonTag &)
template<>
void	offset (Slic3r::Polygon &sh, coord_t distance, const PathTag &)
template<>
std::string	toString (const Slic3r::ExPolygon &sh)
template<>
Slic3r::ExPolygon	create (const Slic3r::Polygon &path, const Slic3r::Polygons &holes)
template<>
Slic3r::ExPolygon	create (Slic3r::Polygon &&path, Slic3r::Polygons &&holes)
template<>
const THolesContainer< PolygonImpl > &	holes (const Slic3r::ExPolygon &sh)
template<>
THolesContainer< PolygonImpl > &	holes (Slic3r::ExPolygon &sh)
template<>
Slic3r::Polygon &	hole (Slic3r::ExPolygon &sh, unsigned long idx)
template<>
const Slic3r::Polygon &	hole (const Slic3r::ExPolygon &sh, unsigned long idx)
template<>
size_t	holeCount (const Slic3r::ExPolygon &sh)
template<>
Slic3r::Polygon &	contour (Slic3r::ExPolygon &sh)
template<>
const Slic3r::Polygon &	contour (const Slic3r::ExPolygon &sh)
template<>
void	reserve (Slic3r::Polygon &p, size_t vertex_capacity, const PathTag &)
template<>
void	addVertex (Slic3r::Polygon &sh, const PathTag &, const Slic3r::Point &p)
template<>
void	translate (Slic3r::ExPolygon &sh, const Slic3r::Point &offs)
template<>
void	rotate (Slic3r::ExPolygon &sh, const Radians &rads)
template<class S >
S	create (const TContour< S > &contour, const THolesContainer< S > &holes)
template<class S >
S	create (TContour< S > &&contour, THolesContainer< S > &&holes)
template<class S >
S	create (const TContour< S > &contour)
template<class S >
S	create (TContour< S > &&contour)
template<class S >
THolesContainer< S > &	holes (S &)
template<class S >
const THolesContainer< S > &	holes (const S &)
template<class S >
TContour< S > &	hole (S &sh, unsigned long idx)
template<class S >
const TContour< S > &	hole (const S &sh, unsigned long idx)
template<class S >
size_t	holeCount (const S &sh)
template<class S >
TContour< S > &	contour (S &sh)
template<class S >
const TContour< S > &	contour (const S &sh)
template<class RawPath >
void	reserve (RawPath &p, size_t vertex_capacity, const PathTag &)
template<class S , class... Args>
void	addVertex (S &sh, const PathTag &, const TPoint< S > &p)
template<class S , class Fn >
void	foreachVertex (S &sh, Fn fn, const PathTag &)
template<class S >
S::iterator	begin (S &sh, const PathTag &)
template<class S >
S::iterator	end (S &sh, const PathTag &)
template<class S >
S::const_iterator	cbegin (const S &sh, const PathTag &)
template<class S >
S::const_iterator	cend (const S &sh, const PathTag &)
template<class S >
std::string	toString (const S &)
template<Formats , class S >
std::string	serialize (const S &, double=1)
template<Formats , class S >
void	unserialize (S &, const std::string &)
template<class Cntr , class Unit = double>
Unit	area (const Cntr &poly, const PathTag &)
template<class S >
bool	intersects (const S &, const S &)
template<class TGuest , class THost >
bool	isInside (const TGuest &, const THost &, const PointTag &, const PolygonTag &)
template<class TGuest , class THost >
bool	isInside (const TGuest &, const THost &, const PolygonTag &, const PolygonTag &)
template<class S >
bool	touches (const S &, const S &)
template<class S >
bool	touches (const TPoint< S > &, const S &)
template<class S >
_Box< TPoint< S > >	boundingBox (const S &, const PathTag &)
template<class RawShapes >
_Box< TPoint< RawShapes > >	boundingBox (const RawShapes &, const MultiPolygonTag &)
template<class S >
S	convexHull (const S &sh, const PathTag &)
template<class RawShapes , class S = typename RawShapes::value_type>
S	convexHull (const RawShapes &sh, const MultiPolygonTag &)
template<class S >
void	rotate (S &, const Radians &)
template<class S , class P >
void	translate (S &, const P &)
template<class S >
void	offset (S &, TCoord< S >, const PathTag &)
template<class S >
void	offset (S &sh, TCoord< S > distance, const PolygonTag &)
template<class S >
std::pair< bool, std::string >	isValid (const S &)
template<class RawPath >
bool	isConvex (const RawPath &sh, const PathTag &)
template<class S >
TContour< S >::iterator	begin (S &sh, const PolygonTag &)
template<class S >
auto	begin (S &sh) -> decltype(begin(sh, Tag< S >()))
template<class S >
TContour< S >::const_iterator	cbegin (const S &sh, const PolygonTag &)
template<class S >
auto	cbegin (const S &sh) -> decltype(cbegin(sh, Tag< S >()))
template<class S >
TContour< S >::iterator	end (S &sh, const PolygonTag &)
template<class S >
auto	end (S &sh) -> decltype(begin(sh, Tag< S >()))
template<class S >
TContour< S >::const_iterator	cend (const S &sh, const PolygonTag &)
template<class S >
auto	cend (const S &sh) -> decltype(cend(sh, Tag< S >()))
template<class It >
std::reverse_iterator< It >	_backward (It iter)
template<class P >
auto	rbegin (P &p) -> decltype(_backward(end(p)))
template<class P >
auto	rcbegin (const P &p) -> decltype(_backward(cend(p)))
template<class P >
auto	rend (P &p) -> decltype(_backward(begin(p)))
template<class P >
auto	rcend (const P &p) -> decltype(_backward(cbegin(p)))
template<class P >
TPoint< P >	front (const P &p)
template<class P >
TPoint< P >	back (const P &p)
template<class S >
void	reserve (S &sh, size_t vertex_capacity, const PolygonTag &)
template<class T >
void	reserve (T &sh, size_t vertex_capacity)
template<class S >
void	addVertex (S &sh, const PolygonTag &, const TPoint< S > &p)
template<class S >
void	addVertex (S &sh, const TPoint< S > &p)
template<class S >
_Box< TPoint< S > >	boundingBox (const S &poly, const PolygonTag &)
template<class Box >
Box	boundingBox (const Box &box, const BoxTag &)
template<class Circle >
_Box< typename Circle::PointType >	boundingBox (const Circle &circ, const CircleTag &)
template<class S >
_Box< TPoint< S > >	boundingBox (const S &sh)
template<class P >
_Box< P >	boundingBox (const _Box< P > &bb1, const _Box< P > &bb2)
template<class S1 , class S2 >
_Box< TPoint< S1 > >	boundingBox (const S1 &s1, const S2 &s2)
template<class Box >
double	area (const Box &box, const BoxTag &)
template<class Circle >
double	area (const Circle &circ, const CircleTag &)
template<class S >
double	area (const S &poly, const PolygonTag &)
template<class RawShapes >
double	area (const RawShapes &shapes, const MultiPolygonTag &)
template<class S >
double	area (const S &sh)
template<class S >
S	convexHull (const S &sh, const PolygonTag &)
template<class S >
auto	convexHull (const S &sh) -> decltype(convexHull(sh, Tag< S >()))
template<class TP , class TC >
bool	isInside (const TP &point, const TC &circ, const PointTag &, const CircleTag &)
template<class TP , class TB >
bool	isInside (const TP &point, const TB &box, const PointTag &, const BoxTag &)
template<class S , class TC >
bool	isInside (const S &sh, const TC &circ, const PolygonTag &, const CircleTag &)
template<class TB , class TC >
bool	isInside (const TB &box, const TC &circ, const BoxTag &, const CircleTag &)
template<class TBGuest , class TBHost >
bool	isInside (const TBGuest &ibb, const TBHost &box, const BoxTag &, const BoxTag &)
template<class S , class TB >
bool	isInside (const S &poly, const TB &box, const PolygonTag &, const BoxTag &)
template<class TGuest , class THost >
bool	isInside (const TGuest &guest, const THost &host)
template<class S >
TPoint< S > &	vertex (S &sh, unsigned long idx, const PolygonTag &)
template<class S >
TPoint< S > &	vertex (S &sh, unsigned long idx, const PathTag &)
template<class S >
TPoint< S > &	vertex (S &sh, unsigned long idx)
template<class S >
const TPoint< S > &	vertex (const S &sh, unsigned long idx, const PolygonTag &)
template<class S >
const TPoint< S > &	vertex (const S &sh, unsigned long idx, const PathTag &)
template<class S >
const TPoint< S > &	vertex (const S &sh, unsigned long idx)
template<class S >
size_t	contourVertexCount (const S &sh)
template<class S , class Fn >
void	foreachVertex (S &sh, Fn fn, const PolygonTag &)
template<class S , class Fn >
void	foreachVertex (S &sh, Fn fn)
template<class Poly >
bool	isConvex (const Poly &sh, const PolygonTag &)
template<class S >
bool	isConvex (const S &sh)
template<class Box >
void	offset (Box &bb, TCoord< Box > d, const BoxTag &)
template<class C >
void	offset (C &circ, TCoord< C > d, const CircleTag &)
template<class S >
void	offset (S &sh, TCoord< S > d)
template<>
bool	intersects (const PathImpl &sh1, const PathImpl &sh2)
template<>
bool	intersects (const PolygonImpl &sh1, const PolygonImpl &sh2)
template<>
bool	intersects (const bp2d::Segment &s1, const bp2d::Segment &s2)
template<>
double	area (const PolygonImpl &shape, const PolygonTag &)
template<>
bool	isInside (const PointImpl &point, const PolygonImpl &shape, const PointTag &, const PolygonTag &)
template<>
bool	isInside (const PolygonImpl &sh1, const PolygonImpl &sh2, const PolygonTag &, const PolygonTag &)
template<>
bool	touches (const PolygonImpl &sh1, const PolygonImpl &sh2)
template<>
bool	touches (const PointImpl &point, const PolygonImpl &shape)
template<>
bp2d::Box	boundingBox (const PathImpl &sh, const PathTag &)
template<>
bp2d::Box	boundingBox< bp2d::Shapes > (const bp2d::Shapes &shapes, const MultiPolygonTag &)
template<>
PathImpl	convexHull (const PathImpl &sh, const PathTag &)
template<>
PolygonImpl	convexHull (const TMultiShape< PolygonImpl > &shapes, const MultiPolygonTag &)
template<>
void	offset (PolygonImpl &sh, bp2d::Coord distance)
template<>
std::string	serialize< libnest2d::Formats::SVG > (const PolygonImpl &sh, double scale)
template<>
void	unserialize< libnest2d::Formats::SVG > (PolygonImpl &sh, const std::string &str)
template<>
std::pair< bool, std::string >	isValid (const PolygonImpl &sh)

Function Documentation

_backward()

template<class It >

std::reverse_iterator< It > libnest2d::shapelike::_backward

(

It

iter

)

                                                              {
    return std::reverse_iterator<It>(iter);
}

Referenced by rbegin(), rcbegin(), rcend(), and rend().

Here is the caller graph for this function:

addVertex() [1/4]

template<class S , class... Args>

void libnest2d::shapelike::addVertex ( S &  sh, const PathTag &  , const TPoint< S > &  p  )

inline

{
    sh.emplace_back(p);
}

addVertex() [2/4]

template<class S >

void libnest2d::shapelike::addVertex ( S &  sh, const PolygonTag &  , const TPoint< S > &  p  )

inline

{
    addVertex(contour(sh), PathTag(), p);
}

References addVertex(), and contour().

Here is the call graph for this function:

addVertex() [3/4]

template<class S >

void libnest2d::shapelike::addVertex ( S &  sh, const TPoint< S > &  p  )

inline

{
    addVertex(sh, Tag<S>(), p);
}

References addVertex().

Here is the call graph for this function:

addVertex() [4/4]

template<>

void libnest2d::shapelike::addVertex ( Slic3r::Polygon &  sh, const PathTag &  , const Slic3r::Point &  p  )

inline

{
    sh.points.emplace_back(p);
}

References Slic3r::MultiPoint::points.

Referenced by addVertex(), addVertex(), libnest2d::__nfp::buildPolygon(), convexHull(), convexHull(), libnest2d::create_rect(), libnest2d::removeCollinearPoints(), libnest2d::rotcalipers(), and libnest2d::placers::_BottomLeftPlacer< RawShape >::toWallPoly().

Here is the caller graph for this function:

area() [1/7]

template<class Box >

double libnest2d::shapelike::area ( const Box &  box, const BoxTag &    )

inline

{
    return box.template area<double>();
}

area() [2/7]

template<class Circle >

double libnest2d::shapelike::area ( const Circle &  circ, const CircleTag &    )

inline

{
    return circ.area();
}

References libnest2d::_Circle< P >::area().

Here is the call graph for this function:

area() [3/7]

template<class Cntr , class Unit = double>

Unit libnest2d::shapelike::area ( const Cntr &  poly, const PathTag &    )

inline

{
    namespace sl = shapelike;
    if (sl::cend(poly) - sl::cbegin(poly) < 3) return 0.0;
  
    Unit a = 0;
    for (auto i = sl::cbegin(poly), j = std::prev(sl::cend(poly)); 
         i < sl::cend(poly); ++i)
    {
        auto xj = Unit(getX(*j)), yj = Unit(getY(*j));
        auto xi = Unit(getX(*i)), yi = Unit(getY(*i));
        a += (xj + xi) *  (yj - yi);
        j = i;
    }
    a /= 2;
    return is_clockwise<Cntr>() ? a : -a;
}

References cbegin(), cend(), libnest2d::getX(), and libnest2d::getY().

Referenced by libnest2d::_Item< RawShape >::area(), area(), area(), and libnest2d::selections::_DJDHeuristic< RawShape >::packItems().

Here is the call graph for this function:

Here is the caller graph for this function:

area() [4/7]

template<>

double libnest2d::shapelike::area ( const PolygonImpl &  shape, const PolygonTag &    )

inline

{
    return boost::geometry::area(shape);
}

area() [5/7]

template<class RawShapes >

double libnest2d::shapelike::area ( const RawShapes &  shapes, const MultiPolygonTag &    )

inline

{
    using S = typename RawShapes::value_type;
    return std::accumulate(shapes.begin(), shapes.end(), 0.0,
                    [](double a, const S& b) {
        return a += area(b);
    });
}

area() [6/7]

template<class S >

double libnest2d::shapelike::area ( const S &  poly, const PolygonTag &    )

inline

{
    auto hls = holes(poly);
    return std::accumulate(hls.begin(), hls.end(), 
                           area(contour(poly), PathTag()),
                           [](double a, const TContour<S> &h){
        return a + area(h, PathTag());    
    });
}

References area(), contour(), and holes().

Here is the call graph for this function:

area() [7/7]

template<class S >

double libnest2d::shapelike::area ( const S &  sh )

inline

{
    return area(sh, Tag<S>());
}

References area().

Here is the call graph for this function:

back()

template<class P >

TPoint< P > libnest2d::shapelike::back

(

const P &

p

)

                                              {
    return *std::prev(shapelike::cend(p));
}

References cend().

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

Here is the call graph for this function:

Here is the caller graph for this function:

begin() [1/3]

template<class S >

auto libnest2d::shapelike::begin ( S &  sh ) -> decltype(begin(sh, Tag<S>()))

inline

{
    return begin(sh, Tag<S>());
}

References begin().

Here is the call graph for this function:

begin() [2/3]

template<class S >

S::iterator libnest2d::shapelike::begin ( S &  sh, const PathTag &    )

inline

{
    return sh.begin();
}

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpace(), begin(), begin(), libnest2d::__nfp::buildPolygon(), libnest2d::create_rect(), isConvex(), rend(), vertex(), and vertex().

Here is the caller graph for this function:

begin() [3/3]

template<class S >

TContour< S >::iterator libnest2d::shapelike::begin ( S &  sh, const PolygonTag &    )

inline

{
    return begin(contour(sh), PathTag());
}

References begin(), and contour().

Here is the call graph for this function:

boundingBox() [1/9]

template<class P >

_Box< P > libnest2d::shapelike::boundingBox	(	const _Box< P > &	bb1,
		const _Box< P > &	bb2
	)

{
    auto& pminc = bb1.minCorner();
    auto& pmaxc = bb1.maxCorner();
    auto& iminc = bb2.minCorner();
    auto& imaxc = bb2.maxCorner();
    P minc, maxc;
    
    setX(minc, std::min(getX(pminc), getX(iminc)));
    setY(minc, std::min(getY(pminc), getY(iminc)));
    
    setX(maxc, std::max(getX(pmaxc), getX(imaxc)));
    setY(maxc, std::max(getY(pmaxc), getY(imaxc)));
    return _Box<P>(minc, maxc);
}

References libnest2d::getX(), libnest2d::getY(), libnest2d::_Box< P >::maxCorner(), libnest2d::_Box< P >::minCorner(), libnest2d::setX(), and libnest2d::setY().

Here is the call graph for this function:

boundingBox() [2/9]

template<class Box >

Box libnest2d::shapelike::boundingBox ( const Box &  box, const BoxTag &    )

inline

{
    return box;
}

boundingBox() [3/9]

template<class Circle >

_Box< typename Circle::PointType > libnest2d::shapelike::boundingBox ( const Circle &  circ, const CircleTag &    )

inline

{
    using Point = typename Circle::PointType;
    using Coord = TCoord<Point>;
    Point pmin = {
        static_cast<Coord>(getX(circ.center()) - circ.radius()),
        static_cast<Coord>(getY(circ.center()) - circ.radius()) };
 
    Point pmax = {
        static_cast<Coord>(getX(circ.center()) + circ.radius()),
        static_cast<Coord>(getY(circ.center()) + circ.radius()) };
 
    return {pmin, pmax};
}

References libnest2d::_Circle< P >::center(), libnest2d::getX(), libnest2d::getY(), and libnest2d::_Circle< P >::radius().

Here is the call graph for this function:

boundingBox() [4/9]

template<>

bp2d::Box libnest2d::shapelike::boundingBox ( const PathImpl &  sh, const PathTag &    )

inline

{
    bp2d::Box b;
    boost::geometry::envelope(sh, b);
    return b;
}

boundingBox() [5/9]

template<class RawShapes >

_Box< TPoint< RawShapes > > libnest2d::shapelike::boundingBox ( const RawShapes &  , const MultiPolygonTag &    )

inline

{
    static_assert(always_false<RawShapes>::value,
                  "shapelike::boundingBox(shapes) unimplemented!");
}

boundingBox() [6/9]

template<class S >

_Box< TPoint< S > > libnest2d::shapelike::boundingBox ( const S &  , const PathTag &    )

inline

{
    static_assert(always_false<S>::value,
                  "shapelike::boundingBox(shape) unimplemented!");
}

Referenced by Slic3r::arrangement::AutoArranger< TBin >::AutoArranger(), libnest2d::_Item< RawShape >::boundingBox(), boundingBox(), boundingBox(), boundingBox(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::finalAlign(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::finalAlign(), libnest2d::fitIntoBoxRotation(), Slic3r::arrangement::fixed_overfit(), isInside(), libnest2d::placers::minimizeCircle(), Slic3r::arrangement::AutoArranger< TBin >::objfunc(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::overfit(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::placeOutsideOfBin(), libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::setInitialPosition(), and libnest2d::placers::_NofitPolyPlacer< RawShape, TBin >::trypack().

Here is the caller graph for this function:

boundingBox() [7/9]

template<class S >

_Box< TPoint< S > > libnest2d::shapelike::boundingBox ( const S &  poly, const PolygonTag &    )

inline

{
    return boundingBox(contour(poly), PathTag());
}

References boundingBox(), and contour().

Here is the call graph for this function:

boundingBox() [8/9]

template<class S >

_Box< TPoint< S > > libnest2d::shapelike::boundingBox ( const S &  sh )

inline

{
    return boundingBox(sh, Tag<S>() );
}

References boundingBox().

Here is the call graph for this function:

boundingBox() [9/9]

template<class S1 , class S2 >

_Box< TPoint< S1 > > libnest2d::shapelike::boundingBox	(	const S1 &	s1,
		const S2 &	s2
	)

{
    return boundingBox(boundingBox(s1), boundingBox(s2));
}

References boundingBox().

Here is the call graph for this function:

boundingBox< bp2d::Shapes >()

template<>

bp2d::Box libnest2d::shapelike::boundingBox< bp2d::Shapes > ( const bp2d::Shapes &  shapes, const MultiPolygonTag &    )

inline

{
    bp2d::Box b;
    boost::geometry::envelope(shapes, b);
    return b;
}

cbegin() [1/3]

template<class S >

auto libnest2d::shapelike::cbegin ( const S &  sh ) -> decltype(cbegin(sh, Tag<S>()))

inline

{
    return cbegin(sh, Tag<S>());
}

References cbegin().

Here is the call graph for this function:

cbegin() [2/3]

template<class S >

S::const_iterator libnest2d::shapelike::cbegin ( const S &  sh, const PathTag &    )

inline

{
    return sh.cbegin();
}

Referenced by area(), libnest2d::_Item< RawShape >::begin(), libnest2d::__nfp::buildPolygon(), libnest2d::_Item< RawShape >::cbegin(), cbegin(), cbegin(), contourVertexCount(), convexHull(), convexHull(), libnest2d::placers::EdgeCache< RawShape >::createCache(), front(), isInside(), libnest2d::_Item< RawShape >::leftmostBottomVertex(), libnest2d::nfp::leftmostDownVertex(), libnest2d::nfp::nfpConvexOnly(), rcend(), libnest2d::removeCollinearPoints(), libnest2d::_Item< RawShape >::rightmostTopVertex(), libnest2d::nfp::rightmostUpVertex(), libnest2d::rotcalipers(), serialize< libnest2d::Formats::SVG >(), vertex(), and vertex().

Here is the caller graph for this function:

cbegin() [3/3]

template<class S >

TContour< S >::const_iterator libnest2d::shapelike::cbegin ( const S &  sh, const PolygonTag &    )

inline

{
    return cbegin(contour(sh), PathTag());
}

References cbegin(), and contour().

Here is the call graph for this function:

cend() [1/3]

template<class S >

auto libnest2d::shapelike::cend ( const S &  sh ) -> decltype(cend(sh, Tag<S>()))

inline

{
    return cend(sh, Tag<S>());
}

References cend().

Here is the call graph for this function:

cend() [2/3]

template<class S >

S::const_iterator libnest2d::shapelike::cend ( const S &  sh, const PathTag &    )

inline

{
    return sh.cend();
}

Referenced by area(), back(), libnest2d::__nfp::buildPolygon(), libnest2d::_Item< RawShape >::cend(), cend(), cend(), contourVertexCount(), convexHull(), convexHull(), libnest2d::placers::EdgeCache< RawShape >::createCache(), libnest2d::_Item< RawShape >::end(), isInside(), libnest2d::_Item< RawShape >::leftmostBottomVertex(), libnest2d::nfp::leftmostDownVertex(), libnest2d::nfp::nfpConvexOnly(), rcbegin(), libnest2d::removeCollinearPoints(), libnest2d::_Item< RawShape >::rightmostTopVertex(), libnest2d::nfp::rightmostUpVertex(), libnest2d::rotcalipers(), and serialize< libnest2d::Formats::SVG >().

Here is the caller graph for this function:

cend() [3/3]

template<class S >

TContour< S >::const_iterator libnest2d::shapelike::cend ( const S &  sh, const PolygonTag &    )

inline

{
    return cend(contour(sh), PathTag());
}

References cend(), and contour().

Here is the call graph for this function:

contour() [1/4]

template<class S >

const TContour< S > & libnest2d::shapelike::contour ( const S &  sh )

inline

{
    static_assert(always_false<S>::value,
                  "shapelike::contour() unimplemented!");
    return sh;
}

contour() [2/4]

template<>

const Slic3r::Polygon & libnest2d::shapelike::contour ( const Slic3r::ExPolygon &  sh )

inline

{
    return sh.contour;
}

References Slic3r::ExPolygon::contour.

contour() [3/4]

template<class S >

TContour< S > & libnest2d::shapelike::contour ( S &  sh )

inline

{
    static_assert(always_false<S>::value,
                  "shapelike::contour() unimplemented!");
    return sh;
}

contour() [4/4]

template<>

Slic3r::Polygon & libnest2d::shapelike::contour ( Slic3r::ExPolygon &  sh )

inline

{
    return sh.contour;
}

References Slic3r::ExPolygon::contour.

Referenced by addVertex(), area(), libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpace(), begin(), boundingBox(), libnest2d::__nfp::buildPolygon(), cbegin(), cend(), convexHull(), create(), create(), create(), create(), end(), foreachVertex(), boost::geometry::traits::exterior_ring< bp2d::PolygonImpl >::get(), boost::geometry::traits::exterior_ring< bp2d::PolygonImpl >::get(), libnest2d::_Item< RawShape >::isContourConvex(), isConvex(), libnest2d::placers::minimizeCircle(), offset(), reserve(), libnest2d::placers::_BottomLeftPlacer< RawShape >::toWallPoly(), vertex(), vertex(), and libnest2d::svg::SVGWriter< RawShape >::writeShape().

Here is the caller graph for this function:

contourVertexCount()

template<class S >

size_t libnest2d::shapelike::contourVertexCount ( const S &  sh )

inline

{
    return shapelike::cend(sh) - shapelike::cbegin(sh);
}

References cbegin(), and cend().

Referenced by libnest2d::placers::EdgeCache< RawShape >::createCache(), libnest2d::nfp::nfpConvexOnly(), libnest2d::removeCollinearPoints(), serialize< libnest2d::Formats::SVG >(), and libnest2d::_Item< RawShape >::vertexCount().

Here is the call graph for this function:

Here is the caller graph for this function:

convexHull() [1/6]

template<>

PathImpl libnest2d::shapelike::convexHull ( const PathImpl &  sh, const PathTag &    )

inline

{
    PathImpl ret;
    boost::geometry::convex_hull(sh, ret);
    return ret;
}

convexHull() [2/6]

template<class RawShapes , class S = typename RawShapes::value_type>

S libnest2d::shapelike::convexHull ( const RawShapes &  sh, const MultiPolygonTag &    )

inline

{
    namespace sl = shapelike;
    S cntr;
    for(auto& poly : sh) 
        for(auto it = sl::cbegin(poly); it != sl::cend(poly); ++it) 
            addVertex(cntr, *it);
    
    return convexHull(cntr, Tag<S>());
}

References addVertex(), cbegin(), cend(), and convexHull().

Here is the call graph for this function:

convexHull() [3/6]

template<class S >

auto libnest2d::shapelike::convexHull ( const S &  sh ) -> decltype(convexHull(sh, Tag<S>()))

inline

{
    return convexHull(sh, Tag<S>());
}

References convexHull().

Here is the call graph for this function:

convexHull() [4/6]

template<class S >

S libnest2d::shapelike::convexHull ( const S &  sh, const PathTag &    )

inline

{
    using Unit = TCompute<S>;
    using Point = TPoint<S>;
    namespace sl = shapelike;
    
    size_t edges = sl::cend(sh) - sl::cbegin(sh);
    if(edges <= 3) return {};
    
    bool closed = false;
    std::vector<Point> U, L;
    U.reserve(1 + edges / 2); L.reserve(1 + edges / 2);
    
    std::vector<Point> pts; pts.reserve(edges);
    std::copy(sl::cbegin(sh), sl::cend(sh), std::back_inserter(pts));
    
    auto fpt = pts.front(), lpt = pts.back();
    if(getX(fpt) == getX(lpt) && getY(fpt) == getY(lpt)) { 
        closed = true; pts.pop_back();
    }
    
    std::sort(pts.begin(), pts.end(), 
              [](const Point& v1, const Point& v2)
    {
        Unit x1 = getX(v1), x2 = getX(v2), y1 = getY(v1), y2 = getY(v2);
        return x1 == x2 ? y1 < y2 : x1 < x2;
    });
    
    auto dir = [](const Point& p, const Point& q, const Point& r) {
        return (Unit(getY(q)) - getY(p)) * (Unit(getX(r)) - getX(p)) -
               (Unit(getX(q)) - getX(p)) * (Unit(getY(r)) - getY(p));
    };
    
    auto ik = pts.begin();
    
    while(ik != pts.end()) {
        
        while(U.size() > 1 && dir(U[U.size() - 2], U.back(), *ik) <= 0) 
            U.pop_back();
        while(L.size() > 1 && dir(L[L.size() - 2], L.back(), *ik) >= 0) 
            L.pop_back();
        
        U.emplace_back(*ik);
        L.emplace_back(*ik);
        
        ++ik;
    }
    
    S ret; reserve(ret, U.size() + L.size());
    if(is_clockwise<S>()) {
        for(auto it = U.begin(); it != std::prev(U.end()); ++it) 
            addVertex(ret, *it);  
        for(auto it = L.rbegin(); it != std::prev(L.rend()); ++it) 
            addVertex(ret, *it);
        if(closed) addVertex(ret, *std::prev(L.rend()));
    } else {
        for(auto it = L.begin(); it != std::prev(L.end()); ++it) 
            addVertex(ret, *it);  
        for(auto it = U.rbegin(); it != std::prev(U.rend()); ++it) 
            addVertex(ret, *it);  
        if(closed) addVertex(ret, *std::prev(U.rend()));
    }
    
    return ret;
}

References addVertex(), cbegin(), cend(), libnest2d::getX(), libnest2d::getY(), L, and reserve().

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

Here is the call graph for this function:

Here is the caller graph for this function:

convexHull() [5/6]

template<class S >

S libnest2d::shapelike::convexHull ( const S &  sh, const PolygonTag &    )

inline

{
    return create<S>(convexHull(contour(sh), PathTag()));
}

References contour(), and convexHull().

Here is the call graph for this function:

convexHull() [6/6]

template<>

PolygonImpl libnest2d::shapelike::convexHull ( const TMultiShape< PolygonImpl > &  shapes, const MultiPolygonTag &    )

inline

{
    PolygonImpl ret;
    boost::geometry::convex_hull(shapes, ret);
    return ret;
}

create() [1/6]

template<>

Slic3r::ExPolygon libnest2d::shapelike::create ( const Slic3r::Polygon &  path, const Slic3r::Polygons &  holes  )

inline

{
    Slic3r::ExPolygon p;
    p.contour = path;
    p.holes = holes;
 
    return p;
}

References Slic3r::ExPolygon::contour, holes(), and Slic3r::ExPolygon::holes.

Here is the call graph for this function:

create() [2/6]

template<class S >

S libnest2d::shapelike::create ( const TContour< S > &  contour )

inline

{
    return create<S>(contour, {});
}

References contour().

Here is the call graph for this function:

create() [3/6]

template<class S >

S libnest2d::shapelike::create ( const TContour< S > &  contour, const THolesContainer< S > &  holes  )

inline

{
    return S(contour, holes);
}

References contour(), and holes().

Here is the call graph for this function:

create() [4/6]

template<>

Slic3r::ExPolygon libnest2d::shapelike::create ( Slic3r::Polygon &&  path, Slic3r::Polygons &&  holes  )

inline

                                                                                       {
    Slic3r::ExPolygon p;
    p.contour.points.swap(path.points);
    p.holes.swap(holes);
 
    return p;
}

References Slic3r::ExPolygon::contour, holes(), Slic3r::ExPolygon::holes, and Slic3r::MultiPoint::points.

Here is the call graph for this function:

create() [5/6]

template<class S >

S libnest2d::shapelike::create ( TContour< S > &&  contour )

inline

{
    return create<S>(contour, {});
}

References contour().

Here is the call graph for this function:

create() [6/6]

template<class S >

S libnest2d::shapelike::create ( TContour< S > &&  contour, THolesContainer< S > &&  holes  )

inline

{
    return S(contour, holes);
}

References contour(), and holes().

Here is the call graph for this function:

end() [1/3]

template<class S >

auto libnest2d::shapelike::end ( S &  sh ) -> decltype(begin(sh, Tag<S>()))

inline

{
    return end(sh, Tag<S>());
}

References end().

Here is the call graph for this function:

end() [2/3]

template<class S >

S::iterator libnest2d::shapelike::end ( S &  sh, const PathTag &    )

inline

{
    return sh.end();
}

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::availableSpace(), libnest2d::create_rect(), end(), end(), isConvex(), and rbegin().

Here is the caller graph for this function:

end() [3/3]

template<class S >

TContour< S >::iterator libnest2d::shapelike::end ( S &  sh, const PolygonTag &    )

inline

{
    return end(contour(sh), PathTag());
}

References contour(), and end().

Here is the call graph for this function:

foreachVertex() [1/3]

template<class S , class Fn >

void libnest2d::shapelike::foreachVertex ( S &  sh, Fn  fn  )

inline

                                        {
    foreachVertex(sh, fn, Tag<S>());
}

References foreachVertex().

Here is the call graph for this function:

foreachVertex() [2/3]

template<class S , class Fn >

void libnest2d::shapelike::foreachVertex ( S &  sh, Fn  fn, const PathTag &    )

inline

                                                        {
    std::for_each(sh.begin(), sh.end(), fn);
}

Referenced by foreachVertex(), and foreachVertex().

Here is the caller graph for this function:

foreachVertex() [3/3]

template<class S , class Fn >

void libnest2d::shapelike::foreachVertex ( S &  sh, Fn  fn, const PolygonTag &    )

inline

                                                           {
    foreachVertex(contour(sh), fn, PathTag());
    for(auto& h : holes(sh)) foreachVertex(h, fn, PathTag());
}

References contour(), foreachVertex(), and holes().

Here is the call graph for this function:

front()

template<class P >

TPoint< P > libnest2d::shapelike::front

(

const P &

p

)

{ return *shapelike::cbegin(p); }

References cbegin().

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

Here is the call graph for this function:

Here is the caller graph for this function:

hole() [1/4]

template<class S >

const TContour< S > & libnest2d::shapelike::hole ( const S &  sh, unsigned long  idx  )

inline

{
    return holes(sh)[idx];
}

References holes().

Here is the call graph for this function:

hole() [2/4]

template<>

const Slic3r::Polygon & libnest2d::shapelike::hole ( const Slic3r::ExPolygon &  sh, unsigned long  idx  )

inline

{
    return sh.holes[idx];
}

References Slic3r::ExPolygon::holes.

hole() [3/4]

template<class S >

TContour< S > & libnest2d::shapelike::hole ( S &  sh, unsigned long  idx  )

inline

{
    return holes(sh)[idx];
}

References holes().

Here is the call graph for this function:

hole() [4/4]

template<>

Slic3r::Polygon & libnest2d::shapelike::hole ( Slic3r::ExPolygon &  sh, unsigned long  idx  )

inline

{
    return sh.holes[idx];
}

References Slic3r::ExPolygon::holes.

holeCount() [1/2]

template<class S >

size_t libnest2d::shapelike::holeCount ( const S &  sh )

inline

{
    return holes(sh).size();
}

References holes().

Here is the call graph for this function:

holeCount() [2/2]

template<>

size_t libnest2d::shapelike::holeCount ( const Slic3r::ExPolygon &  sh )

inline

{
    return sh.holes.size();
}

References Slic3r::ExPolygon::holes.

Referenced by libnest2d::_Item< RawShape >::holeCount(), and isConvex().

Here is the caller graph for this function:

holes() [1/4]

template<class S >

const THolesContainer< S > & libnest2d::shapelike::holes ( const S &  )

inline

{
    static THolesContainer<S> empty;
    return empty;
}

holes() [2/4]

template<>

const THolesContainer< PolygonImpl > & libnest2d::shapelike::holes ( const Slic3r::ExPolygon &  sh )

inline

{
    return sh.holes;
}

References Slic3r::ExPolygon::holes.

Referenced by area(), create(), create(), create(), create(), libnest2d::placers::EdgeCache< RawShape >::createCache(), foreachVertex(), boost::geometry::traits::interior_rings< bp2d::PolygonImpl >::get(), boost::geometry::traits::interior_rings< bp2d::PolygonImpl >::get(), hole(), hole(), holeCount(), offset(), serialize< libnest2d::Formats::SVG >(), and libnest2d::svg::SVGWriter< RawShape >::writeShape().

Here is the caller graph for this function:

holes() [3/4]

template<class S >

THolesContainer< S > & libnest2d::shapelike::holes ( S &  )

inline

{
    static THolesContainer<S> empty;
    return empty;
}

holes() [4/4]

template<>

THolesContainer< PolygonImpl > & libnest2d::shapelike::holes ( Slic3r::ExPolygon &  sh )

inline

{
    return sh.holes;
}

References Slic3r::ExPolygon::holes.

intersects() [1/4]

template<>

bool libnest2d::shapelike::intersects ( const bp2d::Segment &  s1, const bp2d::Segment &  s2  )

inline

{
    return boost::geometry::intersects(s1, s2);
}

intersects() [2/4]

template<>

bool libnest2d::shapelike::intersects ( const PathImpl &  sh1, const PathImpl &  sh2  )

inline

{
    return boost::geometry::intersects(sh1, sh2);
}

intersects() [3/4]

template<>

bool libnest2d::shapelike::intersects ( const PolygonImpl &  sh1, const PolygonImpl &  sh2  )

inline

{
    return boost::geometry::intersects(sh1, sh2);
}

intersects() [4/4]

template<class S >

bool libnest2d::shapelike::intersects ( const S &  , const S &    )

inline

{
    static_assert(always_false<S>::value,
                  "shapelike::intersects() unimplemented!");
    return false;
}

Referenced by libnest2d::_Item< RawShape >::intersects(), and libnest2d::placers::_BottomLeftPlacer< RawShape >::isInTheWayOf().

Here is the caller graph for this function:

isConvex() [1/3]

template<class Poly >

bool libnest2d::shapelike::isConvex ( const Poly &  sh, const PolygonTag &    )

inline

{
    bool convex = true;
    convex &= isConvex(contour(sh), PathTag());
    convex &= holeCount(sh) == 0;
    return convex;
}

References contour(), holeCount(), and isConvex().

Here is the call graph for this function:

isConvex() [2/3]

template<class RawPath >

bool libnest2d::shapelike::isConvex ( const RawPath &  sh, const PathTag &    )

inline

{
    using Vertex = TPoint<RawPath>;
    auto first = begin(sh);
    auto middle = std::next(first);
    auto last = std::next(middle);
    using CVrRef = const Vertex&;
 
    auto zcrossproduct = [](CVrRef k, CVrRef k1, CVrRef k2) {
        auto dx1 = getX(k1) - getX(k);
        auto dy1 = getY(k1) - getY(k);
        auto dx2 = getX(k2) - getX(k1);
        auto dy2 = getY(k2) - getY(k1);
        return dx1*dy2 - dy1*dx2;
    };
 
    auto firstprod = zcrossproduct( *(std::prev(std::prev(end(sh)))),
                                    *first,
                                    *middle );
 
    bool ret = true;
    bool frsign = firstprod > 0;
    while(last != end(sh)) {
        auto &k = *first, &k1 = *middle, &k2 = *last;
        auto zc = zcrossproduct(k, k1, k2);
        ret &= frsign == (zc > 0);
        ++first; ++middle; ++last;
    }
 
    return ret;
}

References begin(), end(), libnest2d::getX(), and libnest2d::getY().

Referenced by libnest2d::_Item< RawShape >::isContourConvex(), isConvex(), and isConvex().

Here is the call graph for this function:

Here is the caller graph for this function:

isConvex() [3/3]

template<class S >

bool libnest2d::shapelike::isConvex ( const S &  sh )

inline

{
    return isConvex(sh, Tag<S>());
}

References isConvex().

Here is the call graph for this function:

isInside() [1/11]

template<>

bool libnest2d::shapelike::isInside ( const PointImpl &  point, const PolygonImpl &  shape, const PointTag &  , const PolygonTag &    )

inline

{
    return boost::geometry::within(point, shape);
}

isInside() [2/11]

template<>

bool libnest2d::shapelike::isInside ( const PolygonImpl &  sh1, const PolygonImpl &  sh2, const PolygonTag &  , const PolygonTag &    )

inline

{
    return boost::geometry::within(sh1, sh2);
}

isInside() [3/11]

template<class S , class TB >

bool libnest2d::shapelike::isInside ( const S &  poly, const TB &  box, const PolygonTag &  , const BoxTag &    )

inline

{
    return isInside(boundingBox(poly), box, BoxTag(), BoxTag());
}

References boundingBox(), and isInside().

Here is the call graph for this function:

isInside() [4/11]

template<class S , class TC >

bool libnest2d::shapelike::isInside ( const S &  sh, const TC &  circ, const PolygonTag &  , const CircleTag &    )

inline

{
    return std::all_of(cbegin(sh), cend(sh), [&circ](const TPoint<S>& p)
    {
        return isInside(p, circ, PointTag(), CircleTag());
    });
}

References cbegin(), cend(), and isInside().

Here is the call graph for this function:

isInside() [5/11]

template<class TB , class TC >

bool libnest2d::shapelike::isInside ( const TB &  box, const TC &  circ, const BoxTag &  , const CircleTag &    )

inline

{
    return isInside(box.minCorner(), circ, PointTag(), CircleTag()) &&
           isInside(box.maxCorner(), circ, PointTag(), CircleTag());
}

References isInside().

Here is the call graph for this function:

isInside() [6/11]

template<class TBGuest , class TBHost >

bool libnest2d::shapelike::isInside ( const TBGuest &  ibb, const TBHost &  box, const BoxTag &  , const BoxTag &    )

inline

{
    auto iminX = getX(ibb.minCorner());
    auto imaxX = getX(ibb.maxCorner());
    auto iminY = getY(ibb.minCorner());
    auto imaxY = getY(ibb.maxCorner());
 
    auto minX = getX(box.minCorner());
    auto maxX = getX(box.maxCorner());
    auto minY = getY(box.minCorner());
    auto maxY = getY(box.maxCorner());
 
    return iminX >= minX && imaxX <= maxX && iminY >= minY && imaxY <= maxY;
}

References libnest2d::getX(), and libnest2d::getY().

Here is the call graph for this function:

isInside() [7/11]

template<class TGuest , class THost >

bool libnest2d::shapelike::isInside ( const TGuest &  , const THost &  , const PointTag &  , const PolygonTag &    )

inline

                                                         {
    static_assert(always_false<THost>::value,
                      "shapelike::isInside(point, path) unimplemented!");
    return false;
}

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

Here is the caller graph for this function:

isInside() [8/11]

template<class TGuest , class THost >

bool libnest2d::shapelike::isInside ( const TGuest &  , const THost &  , const PolygonTag &  , const PolygonTag &    )

inline

                                                           {
    static_assert(always_false<THost>::value,
                      "shapelike::isInside(shape, shape) unimplemented!");
    return false;
}

isInside() [9/11]

template<class TGuest , class THost >

bool libnest2d::shapelike::isInside ( const TGuest &  guest, const THost &  host  )

inline

                                                             {
    return isInside(guest, host, Tag<TGuest>(), Tag<THost>());
}

References isInside().

Here is the call graph for this function:

isInside() [10/11]

template<class TP , class TB >

bool libnest2d::shapelike::isInside ( const TP &  point, const TB &  box, const PointTag &  , const BoxTag &    )

inline

{
    auto px = getX(point);
    auto py = getY(point);
    auto minx = getX(box.minCorner());
    auto miny = getY(box.minCorner());
    auto maxx = getX(box.maxCorner());
    auto maxy = getY(box.maxCorner());
 
    return px > minx && px < maxx && py > miny && py < maxy;
}

References libnest2d::getX(), and libnest2d::getY().

Here is the call graph for this function:

isInside() [11/11]

template<class TP , class TC >

bool libnest2d::shapelike::isInside ( const TP &  point, const TC &  circ, const PointTag &  , const CircleTag &    )

inline

{
    auto r = circ.radius();
    return pointlike::squaredDistance(point, circ.center()) < r * r;
}

References libnest2d::pointlike::squaredDistance().

Here is the call graph for this function:

isValid() [1/2]

template<>

std::pair< bool, std::string > libnest2d::shapelike::isValid ( const PolygonImpl &  sh )

inline

{
    std::string message;
    bool ret = boost::geometry::is_valid(sh, message);
 
    return {ret, message};
}

isValid() [2/2]

template<class S >

std::pair< bool, std::string > libnest2d::shapelike::isValid ( const S &  )

inline

{
    return {false, "shapelike::isValid() unimplemented!"};
}

offset() [1/8]

template<class Box >

void libnest2d::shapelike::offset ( Box &  bb, TCoord< Box >  d, const BoxTag &    )

inline

{
    TPoint<Box> md{d, d};
    bb.minCorner() -= md;
    bb.maxCorner() += md;
}

References libnest2d::_Box< P >::maxCorner(), and libnest2d::_Box< P >::minCorner().

Here is the call graph for this function:

offset() [2/8]

template<class C >

void libnest2d::shapelike::offset ( C &  circ, TCoord< C >  d, const CircleTag &    )

inline

{
    circ.radius(circ.radius() + double(d));
}

offset() [3/8]

template<>

void libnest2d::shapelike::offset ( PolygonImpl &  sh, bp2d::Coord  distance  )

inline

{
    PolygonImpl cpy = sh;
    boost::geometry::buffer(cpy, sh, distance);
}

offset() [4/8]

template<class S >

void libnest2d::shapelike::offset ( S &  , TCoord< S >  , const PathTag &    )

inline

{
    dout() << "The current geometry backend does not support offsetting!\n";
}

References libnest2d::dout().

Here is the call graph for this function:

offset() [5/8]

template<class S >

void libnest2d::shapelike::offset ( S &  sh, TCoord< S >  d  )

inline

                                                         {
    offset(sh, d, Tag<S>());
}

References offset().

Here is the call graph for this function:

offset() [6/8]

template<class S >

void libnest2d::shapelike::offset ( S &  sh, TCoord< S >  distance, const PolygonTag &    )

inline

{
    offset(contour(sh), distance);
    for(auto &h : holes(sh)) offset(h, -distance);
}

References contour(), holes(), and offset().

Here is the call graph for this function:

offset() [7/8]

template<>

void libnest2d::shapelike::offset ( Slic3r::ExPolygon &  sh, coord_t  distance, const PolygonTag &    )

inline

{
#define DISABLE_BOOST_OFFSET
    auto res = Slic3r::offset_ex(sh, distance, Slic3r::ClipperLib::jtSquare);
    if (!res.empty()) sh = res.front();
}

References Slic3r::offset_ex().

Referenced by libnest2d::_Item< RawShape >::infaltedShape(), offset(), and offset().

Here is the call graph for this function:

Here is the caller graph for this function:

offset() [8/8]

template<>

void libnest2d::shapelike::offset ( Slic3r::Polygon &  sh, coord_t  distance, const PathTag &    )

inline

{
    auto res = Slic3r::offset(sh, distance, Slic3r::ClipperLib::jtSquare);
    if (!res.empty()) sh = res.front();
}

References Slic3r::MultiPoint::front(), and Slic3r::offset().

Here is the call graph for this function:

rbegin()

template<class P >

auto libnest2d::shapelike::rbegin

(

P &

p

)

-> decltype(_backward(end(p)))

{
    return _backward(end(p));
}

References _backward(), and end().

Here is the call graph for this function:

rcbegin()

template<class P >

auto libnest2d::shapelike::rcbegin

(

const P &

p

)

-> decltype(_backward(cend(p)))

{
    return _backward(cend(p));
}

References _backward(), and cend().

Referenced by libnest2d::nfp::nfpConvexOnly().

Here is the call graph for this function:

Here is the caller graph for this function:

rcend()

template<class P >

auto libnest2d::shapelike::rcend

(

const P &

p

)

-> decltype(_backward(cbegin(p)))

{
    return _backward(cbegin(p));
}

References _backward(), and cbegin().

Here is the call graph for this function:

rend()

template<class P >

auto libnest2d::shapelike::rend

(

P &

p

)

-> decltype(_backward(begin(p)))

{
    return _backward(begin(p));
}

References _backward(), and begin().

Here is the call graph for this function:

reserve() [1/4]

template<class RawPath >

void libnest2d::shapelike::reserve ( RawPath &  p, size_t  vertex_capacity, const PathTag &    )

inline

{
    p.reserve(vertex_capacity);
}

reserve() [2/4]

template<class S >

void libnest2d::shapelike::reserve ( S &  sh, size_t  vertex_capacity, const PolygonTag &    )

inline

{
    reserve(contour(sh), vertex_capacity, PathTag());
}

References contour(), and reserve().

Here is the call graph for this function:

reserve() [3/4]

template<>

void libnest2d::shapelike::reserve ( Slic3r::Polygon &  p, size_t  vertex_capacity, const PathTag &    )

inline

{
    p.points.reserve(vertex_capacity);
}

References Slic3r::MultiPoint::points.

Referenced by libnest2d::__nfp::buildPolygon(), convexHull(), libnest2d::nfp::nfpConvexOnly(), libnest2d::removeCollinearPoints(), reserve(), reserve(), libnest2d::rotcalipers(), and libnest2d::placers::_BottomLeftPlacer< RawShape >::toWallPoly().

Here is the caller graph for this function:

reserve() [4/4]

template<class T >

void libnest2d::shapelike::reserve ( T &  sh, size_t  vertex_capacity  )

inline

                                                   {
    reserve(sh, vertex_capacity, Tag<T>());
}

References reserve().

Here is the call graph for this function:

rotate() [1/2]

template<class S >

void libnest2d::shapelike::rotate ( S &  , const Radians &    )

inline

{
    static_assert(always_false<S>::value,
                  "shapelike::rotate() unimplemented!");
}

rotate() [2/2]

template<>

void libnest2d::shapelike::rotate ( Slic3r::ExPolygon &  sh, const Radians &  rads  )

inline

{
    sh.rotate(rads);
}

References Slic3r::ExPolygon::rotate().

Referenced by libnest2d::_Item< RawShape >::boundingBox(), libnest2d::fitIntoBoxRotation(), and libnest2d::_Item< RawShape >::transformedShape().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize()

template<Formats , class S >

std::string libnest2d::shapelike::serialize ( const S &  , double  = 1  )

inline

{
    static_assert(always_false<S>::value,
                  "shapelike::serialize() unimplemented!");
    return "";
}

serialize< libnest2d::Formats::SVG >()

template<>

std::string libnest2d::shapelike::serialize< libnest2d::Formats::SVG > ( const PolygonImpl &  sh, double  scale  )

inline

{
    std::stringstream ss;
    std::string style = "fill: none; stroke: black; stroke-width: 1px;";
 
    using namespace boost::geometry;
    using Pointf = model::point<double, 2, cs::cartesian>;
    using Polygonf = model::polygon<Pointf>;
 
    Polygonf::ring_type ring;
    Polygonf::inner_container_type holes;
    ring.reserve(shapelike::contourVertexCount(sh));
 
    for(auto it = shapelike::cbegin(sh); it != shapelike::cend(sh); it++) {
        auto& v = *it;
        ring.emplace_back(getX(v)*scale, getY(v)*scale);
    };
 
    auto H = shapelike::holes(sh);
    for(PathImpl& h : H ) {
        Polygonf::ring_type hf;
        for(auto it = h.begin(); it != h.end(); it++) {
            auto& v = *it;
            hf.emplace_back(getX(v)*scale, getY(v)*scale);
        };
        holes.emplace_back(std::move(hf));
    }
 
    Polygonf poly;
    poly.outer() = ring;
    poly.inners() = holes;
    auto svg_data = boost::geometry::svg(poly, style);
 
    ss << svg_data << std::endl;
 
    return ss.str();
}

References cbegin(), cend(), contourVertexCount(), libnest2d::getX(), libnest2d::getY(), holes(), scale(), and style.

Here is the call graph for this function:

toString() [1/2]

template<class S >

std::string libnest2d::shapelike::toString ( const S &  )

inline

{
    return "";
}

toString() [2/2]

template<>

std::string libnest2d::shapelike::toString ( const Slic3r::ExPolygon &  sh )

inline

{
    std::stringstream ss;
 
    ss << "Contour {\n";
    for(auto &p : sh.contour.points) {
        ss << "\t" << p.x() << " " << p.y() << "\n";
    }
    ss << "}\n";
 
    for(auto& h : sh.holes) {
        ss << "Holes {\n";
        for(auto p : h.points)  {
            ss << "\t{\n";
            ss << "\t\t" << p.x() << " " << p.y() << "\n";
            ss << "\t}\n";
        }
        ss << "}\n";
    }
 
    return ss.str();
}

References Slic3r::ExPolygon::contour, Slic3r::ExPolygon::holes, and Slic3r::MultiPoint::points.

Referenced by libnest2d::_Item< RawShape >::toString().

Here is the caller graph for this function:

touches() [1/4]

template<>

bool libnest2d::shapelike::touches ( const PointImpl &  point, const PolygonImpl &  shape  )

inline

{
    return boost::geometry::touches(point, shape);
}

touches() [2/4]

template<>

bool libnest2d::shapelike::touches ( const PolygonImpl &  sh1, const PolygonImpl &  sh2  )

inline

{
    return boost::geometry::touches(sh1, sh2);
}

touches() [3/4]

template<class S >

bool libnest2d::shapelike::touches ( const S &  , const S &    )

inline

{
    static_assert(always_false<S>::value,
                  "shapelike::touches(shape, shape) unimplemented!");
    return false;
}

Referenced by libnest2d::placers::_BottomLeftPlacer< RawShape >::isInTheWayOf(), and libnest2d::_Item< RawShape >::touches().

Here is the caller graph for this function:

touches() [4/4]

template<class S >

bool libnest2d::shapelike::touches ( const TPoint< S > &  , const S &    )

inline

{
    static_assert(always_false<S>::value,
                  "shapelike::touches(point, shape) unimplemented!");
    return false;
}

translate() [1/2]

template<class S , class P >

void libnest2d::shapelike::translate ( S &  , const P &    )

inline

{
    static_assert(always_false<S>::value,
                  "shapelike::translate() unimplemented!");
}

translate() [2/2]

template<>

void libnest2d::shapelike::translate ( Slic3r::ExPolygon &  sh, const Slic3r::Point &  offs  )

inline

{
    sh.translate(offs);
}

References Slic3r::ExPolygon::translate().

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

Here is the call graph for this function:

Here is the caller graph for this function:

unserialize()

template<Formats , class S >

void libnest2d::shapelike::unserialize ( S &  , const std::string &    )

inline

{
    static_assert(always_false<S>::value,
                  "shapelike::unserialize() unimplemented!");
}

unserialize< libnest2d::Formats::SVG >()

template<>

void libnest2d::shapelike::unserialize< libnest2d::Formats::SVG > ( PolygonImpl &  sh, const std::string &  str  )

inline

{
}

vertex() [1/6]

template<class S >

const TPoint< S > & libnest2d::shapelike::vertex ( const S &  sh, unsigned long  idx  )

inline

{
    return vertex(sh, idx, Tag<S>());
}

References vertex().

Here is the call graph for this function:

vertex() [2/6]

template<class S >

const TPoint< S > & libnest2d::shapelike::vertex ( const S &  sh, unsigned long  idx, const PathTag &    )

inline

{
    return *(shapelike::cbegin(sh) + idx);
}

References cbegin().

Here is the call graph for this function:

vertex() [3/6]

template<class S >

const TPoint< S > & libnest2d::shapelike::vertex ( const S &  sh, unsigned long  idx, const PolygonTag &    )

inline

{
    return *(shapelike::cbegin(contour(sh)) + idx);
}

References cbegin(), and contour().

Here is the call graph for this function:

vertex() [4/6]

template<class S >

TPoint< S > & libnest2d::shapelike::vertex ( S &  sh, unsigned long  idx  )

inline

{
    return vertex(sh, idx, Tag<S>());
}

References vertex().

Here is the call graph for this function:

vertex() [5/6]

template<class S >

TPoint< S > & libnest2d::shapelike::vertex ( S &  sh, unsigned long  idx, const PathTag &    )

inline

{
    return *(shapelike::begin(sh) + idx);
}

References begin().

Here is the call graph for this function:

vertex() [6/6]

template<class S >

TPoint< S > & libnest2d::shapelike::vertex ( S &  sh, unsigned long  idx, const PolygonTag &    )

inline

{
    return *(shapelike::begin(contour(sh)) + idx);
}

References begin(), and contour().

Referenced by libnest2d::_Item< RawShape >::setVertex(), vertex(), vertex(), and libnest2d::_Item< RawShape >::vertex().

Here is the call graph for this function:

Here is the caller graph for this function: