Slic3r::ClipperZUtils Namespace Reference

Classes
class	ClipperZIntersectionVisitor

Typedefs
using	ZPoint = Vec3crd
using	ZPoints = std::vector<ZPoint, PointsAllocator<ZPoint>>
using	ZPath = ZPoints
using	ZPaths = std::vector<ZPath, PointsAllocator<ZPath>>
using	ZFillCallback = std::function<void(const ZPoint &e1bot, const ZPoint &e1top, const ZPoint &e2bot, const ZPoint &e2top, ZPoint &pt)>

Functions
static C2::Paths64	to_paths64 (const ZPaths &paths)
static void	append_zpaths (const C2::Paths64 &paths, ZPaths &out)
double	area (const ZPath &path)
ZPaths	clip_zpaths (ClipType clip_type, const ZPaths &subject, bool subject_open, const ZPaths &clip, const ZFillCallback &zfill, bool preserve_collinear)
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

ZFillCallback

using Slic3r::ClipperZUtils::ZFillCallback = std::function<void(const ZPoint &e1bot, const ZPoint &e1top, const ZPoint &e2bot, const ZPoint &e2top, ZPoint &pt)>

ZPath

using Slic3r::ClipperZUtils::ZPath = ZPoints

ZPaths

using Slic3r::ClipperZUtils::ZPaths = std::vector<ZPath, PointsAllocator<ZPath>>

ZPoint

using Slic3r::ClipperZUtils::ZPoint = Vec3crd

ZPoints

using Slic3r::ClipperZUtils::ZPoints = std::vector<ZPoint, PointsAllocator<ZPoint>>

Function Documentation

append_zpaths()

void Slic3r::ClipperZUtils::append_zpaths ( const C2::Paths64 & paths, ZPaths & out )

static

{
    out.reserve(out.size() + paths.size());
    for (const C2::Path64 &path : paths) {
        ZPath &dst = out.emplace_back();
        dst.reserve(path.size());
        for (const C2::Point64 &pt : path)
            dst.emplace_back(pt.x, pt.y, pt.z);
    }
}

Referenced by clip_zpaths().

Here is the caller graph for this function:

area()

double Slic3r::ClipperZUtils::area

(

const ZPath &

path

)

{
    const size_t size = path.size();
    if (size < 3)
        return 0.;
    double a = 0.;
    for (size_t i = 0, j = size - 1; i < size; j = i ++)
        a += (double(path[j].x()) + path[i].x()) * (double(path[j].y()) - path[i].y());
    return -a * 0.5;
}

Referenced by Slic3r::tree_supports_generate_paths().

Here is the caller graph for this function:

clip_zpaths()

ZPaths Slic3r::ClipperZUtils::clip_zpaths	(	ClipType	clip_type,
		const ZPaths &	subject,
		bool	subject_open,
		const ZPaths &	clip,
		const ZFillCallback &	zfill,
		bool	preserve_collinear )

{
    C2::Clipper64 clipper;
    clipper.PreserveCollinear(preserve_collinear);
    if (zfill)
        clipper.SetZCallback([&zfill](const C2::Point64 &e1bot, const C2::Point64 &e1top, const C2::Point64 &e2bot, const C2::Point64 &e2top, C2::Point64 &pt) {
            // Clipper2 already copied Z from a coincident input vertex.
            auto coincident = [&pt](const C2::Point64 &p) { return p.x == pt.x && p.y == pt.y; };
            if (coincident(e1bot) || coincident(e1top) || coincident(e2bot) || coincident(e2top))
                return;
            ZPoint zpt(pt.x, pt.y, pt.z);
            zfill(ZPoint(e1bot.x, e1bot.y, e1bot.z), ZPoint(e1top.x, e1top.y, e1top.z),
                  ZPoint(e2bot.x, e2bot.y, e2bot.z), ZPoint(e2top.x, e2top.y, e2top.z), zpt);
            pt.z = zpt.z();
        });
    if (subject_open)
        clipper.AddOpenSubject(to_paths64(subject));
    else
        clipper.AddSubject(to_paths64(subject));
    clipper.AddClip(to_paths64(clip));
    const C2::ClipType type = clip_type == ctIntersection ? C2::ClipType::Intersection :
                              clip_type == ctUnion        ? C2::ClipType::Union :
                              clip_type == ctDifference   ? C2::ClipType::Difference : C2::ClipType::Xor;
    C2::Paths64 closed, open;
    clipper.Execute(type, C2::FillRule::NonZero, closed, open);
    ZPaths out;
    append_zpaths(closed, out);
    append_zpaths(open, out);
    return out;
}

References append_zpaths(), Slic3r::ctDifference, Slic3r::ctIntersection, Slic3r::ctUnion, and to_paths64().

Referenced by Slic3r::clip_extrusion(), Slic3r::Algorithm::do_split_line(), Slic3r::tree_supports_generate_paths(), and Slic3r::Algorithm::wave_seeds().

Here is the call graph for this function:

Here is the caller graph for this function:

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, Slic3r::MultiPoint::points, and to_zpath().

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

Here is the call graph for this function:

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::Algorithm::do_split_line(), from_zpaths(), 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));
}

References from_zpath().

Referenced by from_zpaths().

Here is the call graph for this function:

Here is the caller graph for this function:

to_paths64()

C2::Paths64 Slic3r::ClipperZUtils::to_paths64 ( const ZPaths & paths )

static

{
    C2::Paths64 out;
    out.reserve(paths.size());
    for (const ZPath &path : paths) {
        C2::Path64 &dst = out.emplace_back();
        dst.reserve(path.size());
        for (const ZPoint &pt : path)
            dst.emplace_back(pt.x(), pt.y(), pt.z());
    }
    return out;
}

Referenced by clip_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;
}

Referenced by Slic3r::Algorithm::do_split_line(), expolygons_to_zpaths(), Slic3r::Algorithm::expolygons_to_zpaths_expanded_opened(), to_zpaths(), and Slic3r::tree_supports_generate_paths().

Here is the caller graph for this function:

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;
}

References to_zpath().

Here is the call graph for this function:

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())));
}