Slic3r::ClipperZUtils Namespace Reference

Classes
class	ClipperZIntersectionVisitor

Typedefs
using	ZPoint = ClipperLib_Z::IntPoint
using	ZPoints = ClipperLib_Z::Path
using	ZPath = ClipperLib_Z::Path
using	ZPaths = ClipperLib_Z::Paths

Functions
bool	zpoint_lower (const ZPoint &l, const ZPoint &r)
template<bool Open = false>
ZPath	to_zpath (const Points &path, coord_t z)
template<bool Open = false>
ZPaths	to_zpaths (const VecOfPoints &paths, coord_t z)
template<bool Open = false>
ZPaths	expolygons_to_zpaths (const ExPolygons &src, coord_t &base_idx)
template<bool Open = false>
Points	from_zpath (const ZPoints &path)
template<bool Open = false>
void	from_zpaths (const ZPaths &paths, VecOfPoints &out)
template<bool Open = false>
VecOfPoints	from_zpaths (const ZPaths &paths)

Typedef Documentation

ZPath

using Slic3r::ClipperZUtils::ZPath = typedef ClipperLib_Z::Path

ZPaths

using Slic3r::ClipperZUtils::ZPaths = typedef ClipperLib_Z::Paths

ZPoint

using Slic3r::ClipperZUtils::ZPoint = typedef ClipperLib_Z::IntPoint

ZPoints

using Slic3r::ClipperZUtils::ZPoints = typedef ClipperLib_Z::Path

Function Documentation

expolygons_to_zpaths()

template<bool Open = false>

ZPaths Slic3r::ClipperZUtils::expolygons_to_zpaths ( const ExPolygons &  src, coord_t &  base_idx  )

inline

{
    ZPaths out;
    out.reserve(std::accumulate(src.begin(), src.end(), size_t(0),
        [](const size_t acc, const ExPolygon &expoly) { return acc + expoly.num_contours(); }));
    for (const ExPolygon &expoly : src) {
        out.emplace_back(to_zpath<Open>(expoly.contour.points, base_idx));
        for (const Polygon &hole : expoly.holes)
            out.emplace_back(to_zpath<Open>(hole.points, base_idx));
        ++ base_idx;
    }
    return out;
}

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

Referenced by Slic3r::Algorithm::wave_seeds().

Here is the caller graph for this function:

from_zpath()

template<bool Open = false>

Points Slic3r::ClipperZUtils::from_zpath ( const ZPoints &  path )

inline

{
    Points out;
    if (! path.empty()) {
        out.reserve((path.size() + Open) ? 1 : 0);
        for (const ZPoint &p : path)
            out.emplace_back(p.x(), p.y());
        if (Open)
            out.emplace_back(out.front());
    }
    return out;
}

Referenced by Slic3r::expolygons_to_zpaths_shrunk(), and Slic3r::Algorithm::wave_seeds().

Here is the caller graph for this function:

from_zpaths() [1/2]

template<bool Open = false>

VecOfPoints Slic3r::ClipperZUtils::from_zpaths ( const ZPaths &  paths )

inline

{
    VecOfPoints out;
    from_zpaths(paths, out);
    return out;
}

References from_zpaths().

Here is the call graph for this function:

from_zpaths() [2/2]

template<bool Open = false>

void Slic3r::ClipperZUtils::from_zpaths ( const ZPaths &  paths, VecOfPoints &  out  )

inline

{
    out.reserve(out.size() + paths.size());
    for (const ZPoints &path : paths)
        out.emplace_back(from_zpath<Open>(path));
}

Referenced by from_zpaths().

Here is the caller graph for this function:

to_zpath()

template<bool Open = false>

ZPath Slic3r::ClipperZUtils::to_zpath ( const Points &  path, coord_t  z  )

inline

{
    ZPath out;
    if (! path.empty()) {
        out.reserve((path.size() + Open) ? 1 : 0);
        for (const Point &p : path)
            out.emplace_back(p.x(), p.y(), z);
        if (Open)
            out.emplace_back(out.front());
    }
    return out;
}

to_zpaths()

template<bool Open = false>

ZPaths Slic3r::ClipperZUtils::to_zpaths ( const VecOfPoints &  paths, coord_t  z  )

inline

{
    ZPaths out;
    out.reserve(paths.size());
    for (const Points &path : paths)
        out.emplace_back(to_zpath<Open>(path, z));
    return out;
}

zpoint_lower()

bool Slic3r::ClipperZUtils::zpoint_lower ( const ZPoint &  l, const ZPoint &  r  )

inline

{
    return l.x() < r.x() || (l.x() == r.x() && (l.y() < r.y() || (l.y() == r.y() && l.z() < r.z())));
}