Slic3r::anonymous_namespace{ClipperUtils.cpp} Namespace Reference

Functions
C2::ClipType	to_c2 (ClipType type)
C2::FillRule	to_c2 (PolyFillType type)
C2::JoinType	to_c2 (JoinType type)
C2::EndType	to_c2 (EndType type)
int64_t	px (const Point &pt)
int64_t	py (const Point &pt)
int64_t	px (const C2::Point64 &pt)
int64_t	py (const C2::Point64 &pt)
template<typename PathsProvider>
C2::Paths64	to_paths64 (PathsProvider &&paths)
template<class PathT>
bool	append_offset_path (C2::Paths64 &out, const PathT &path, double shortest, C2::EndType end)
Points	c2_to_points (const C2::Path64 &path)
Polygons	c2_to_polygons (const C2::Paths64 &paths)
Polylines	c2_to_polylines (const C2::Paths64 &paths)
size_t	c2_count_expolygons (const C2::PolyPath64 &outer)
void	c2_append_expolygons (const C2::PolyPath64 &outer, ExPolygons &out, std::vector< const C2::Path64 * > &stray_holes)
bool	path_encloses (const Polygon &outer, const Polygon &inner)
void	c2_attach_stray_holes (ExPolygons &out, size_t first, const std::vector< const C2::Path64 * > &stray_holes)
ExPolygons	c2_to_expolygons (const C2::PolyTree64 &tree)
template<class TOut>
void	c2_clip (C2::ClipType type, const C2::Paths64 &subject, const C2::Paths64 &clip, C2::FillRule fill, TOut &out)
Polylines	c2_clip_open (C2::ClipType type, const C2::Paths64 &subject, const C2::Paths64 &clip)
void	c2_offset_setup (C2::ClipperOffset &co, float delta, JoinType joinType, double miterLimit, double capTolerance=0.)
bool	c2_offset_as_group (const C2::Paths64 &paths, const std::vector< double > &areas)
template<class TOut>
void	c2_offset_closed_paths (C2::Paths64 &&paths, float delta, JoinType joinType, double miterLimit, TOut &out)
template<class PathsT, class TOut>
void	c2_offset_closed (PathsT &&src, float delta, JoinType joinType, double miterLimit, TOut &out)
template<class PathsProvider, class TOut>
void	c2_offset2_closed (PathsProvider &&src, float delta1, float delta2, JoinType joinType, double miterLimit, TOut &out)
const ExPolygon &	expolygon_of (const ExPolygon &expoly)
const ExPolygon &	expolygon_of (const ExPolygon *expoly)
const ExPolygon &	expolygon_of (const Surface &surface)
const ExPolygon &	expolygon_of (const Surface *surface)
template<class ExPolygonRange, class TOut>
void	c2_offset_expolygons (const ExPolygonRange &src, float delta, JoinType joinType, double miterLimit, TOut &out)
template<class ExPolygonRange>
Polygons	c2_expolygons_offset (const ExPolygonRange &src, float delta, JoinType joinType, double miterLimit)
template<class ExPolygonRange>
ExPolygons	c2_expolygons_offset_ex (const ExPolygonRange &src, float delta, JoinType joinType, double miterLimit)
template<class PathsProvider>
Polygons	c2_offset_lines (PathsProvider &&src, float delta, JoinType joinType, double miterLimit, EndType endType, double capTolerance=0.)
template<class PathsProvider>
C2::Paths64	c2_clip_paths (PathsProvider &&clip, ApplySafetyOffset do_safety_offset)

Function Documentation

append_offset_path()

template<class PathT>

bool Slic3r::anonymous_namespace{ClipperUtils.cpp}::append_offset_path	(	C2::Paths64 &	out,
		const PathT &	path,
		double	shortest,
		C2::EndType	end )

{
    int high = int(path.size()) - 1;
    if (high < 0)
        return false;
    const double shortest2 = shortest * shortest;
    auto same = [shortest2](const auto &a, const auto &b) {
        const double dx = double(px(a) - px(b));
        const double dy = double(py(a) - py(b));
        return shortest2 > 0. ? dx * dx + dy * dy < shortest2 : dx == 0. && dy == 0.;
    };
    if (end == C2::EndType::Polygon || end == C2::EndType::Joined)
        while (high > 0 && same(path[high], path[0]))
            -- high;
    C2::Path64 dst;
    dst.reserve(high + 1);
    dst.emplace_back(px(path[0]), py(path[0]));
    for (int i = 1, last = 0; i <= high; ++ i)
        if (! same(path[i], path[last])) {
            dst.emplace_back(px(path[i]), py(path[i]));
            last = i;
        }
    if (end == C2::EndType::Polygon && dst.size() < 3)
        return false;
    out.emplace_back(std::move(dst));
    return true;
}

References append_offset_path(), and px().

Referenced by append_offset_path(), c2_offset_closed(), c2_offset_expolygons(), and c2_offset_lines().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_append_expolygons()

void Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_append_expolygons	(	const C2::PolyPath64 &	outer,
		ExPolygons &	out,
		std::vector< const C2::Path64 * > &	stray_holes )

{
    if (C2::Area(outer.Polygon()) < 0.) {
        stray_holes.emplace_back(&outer.Polygon());
        for (const auto &island : outer)
            c2_append_expolygons(*island, out, stray_holes);
        return;
    }
    // Indexed, as the recursion below may reallocate out.
    const size_t idx = out.size();
    out.emplace_back().contour.points = c2_to_points(outer.Polygon());
    out[idx].holes.reserve(outer.Count());
    for (const auto &child : outer)
        if (C2::Area(child->Polygon()) > 0.)
            c2_append_expolygons(*child, out, stray_holes);
        else {
            out[idx].holes.emplace_back().points = c2_to_points(child->Polygon());
            // Islands inside the hole.
            for (const auto &island : *child)
                c2_append_expolygons(*island, out, stray_holes);
        }
}

References c2_append_expolygons(), and c2_to_points().

Referenced by c2_append_expolygons(), and c2_to_expolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_attach_stray_holes()

void Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_attach_stray_holes	(	ExPolygons &	out,
		size_t	first,
		const std::vector< const C2::Path64 * > &	stray_holes )

{
    if (stray_holes.empty())
        return;
    using Tree = AABBTreeIndirect::Tree<2, coord_t>;
    std::vector<AABBTreeIndirect::BoundingBoxWrapper> bboxes;
    bboxes.reserve(out.size() - first);
    for (size_t i = first; i < out.size(); ++ i)
        bboxes.emplace_back(i, get_extents(out[i].contour));
    Tree tree;
    tree.build_modify_input(bboxes);
    // Contour areas, computed when a contour first becomes a candidate.
    std::vector<double> areas(out.size(), 0.);
    std::vector<size_t> candidates;
    for (const C2::Path64 *path : stray_holes) {
        Polygon hole;
        hole.points = c2_to_points(*path);
        const double            hole_area = - C2::Area(*path);
        const BoundingBox       bbox      = get_extents(hole);
        const Tree::BoundingBox hole_bbox(bbox.min, bbox.max);
        candidates.clear();
        AABBTreeIndirect::traverse(tree,
            [&hole_bbox](const Tree::Node &node) { return node.bbox.contains(hole_bbox); },
            [&candidates](const Tree::Node &node) { candidates.emplace_back(node.idx); return true; });
        for (size_t idx : candidates)
            if (areas[idx] == 0.)
                areas[idx] = out[idx].contour.area();
        std::sort(candidates.begin(), candidates.end(), [&areas](size_t a, size_t b) { return areas[a] < areas[b]; });
        auto larger = std::upper_bound(candidates.begin(), candidates.end(), hole_area, [&areas](double area, size_t idx) { return area < areas[idx]; });
        if (auto it = std::find_if(larger, candidates.end(), [&out, &hole](size_t idx) { return path_encloses(out[idx].contour, hole); });
            it == candidates.end())
            // Nothing around it: keep the path as Clipper2 returned it.
            out.emplace_back().contour = std::move(hole);
        else
            out[*it].holes.emplace_back(std::move(hole));
    }
}

References Slic3r::area(), c2_attach_stray_holes(), c2_to_points(), Slic3r::contour(), Slic3r::get_extents(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::MultiPoint::points, and Slic3r::AABBTreeIndirect::traverse().

Referenced by c2_attach_stray_holes(), and c2_to_expolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_clip()

template<class TOut>

void Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_clip	(	C2::ClipType	type,
		const C2::Paths64 &	subject,
		const C2::Paths64 &	clip,
		C2::FillRule	fill,
		TOut &	out )

{
    C2::Clipper64 clipper;
    // Clipper2 keeps collinear vertices by default, Clipper1 removed them.
    clipper.PreserveCollinear(false);
    clipper.AddSubject(subject);
    if (! clip.empty())
        clipper.AddClip(clip);
    clipper.Execute(type, fill, out);
}

References c2_clip().

Referenced by c2_clip(), and c2_offset_closed_paths().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_clip_open()

Polylines Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_clip_open	(	C2::ClipType	type,
		const C2::Paths64 &	subject,
		const C2::Paths64 &	clip )

{
    C2::Clipper64 clipper;
    clipper.PreserveCollinear(false);
    clipper.AddOpenSubject(subject);
    if (! clip.empty())
        clipper.AddClip(clip);
    C2::Paths64 closed, open;
    clipper.Execute(type, C2::FillRule::NonZero, closed, open);
    return c2_to_polylines(open);
}

References c2_clip_open(), and c2_to_polylines().

Referenced by c2_clip_open().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_clip_paths()

template<class PathsProvider>

C2::Paths64 Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_clip_paths	(	PathsProvider &&	clip,
		ApplySafetyOffset	do_safety_offset )

{
    if (do_safety_offset == ApplySafetyOffset::No)
        return to_paths64(std::forward<PathsProvider>(clip));
    C2::Paths64 out;
    c2_offset_closed(std::forward<PathsProvider>(clip), ClipperSafetyOffset, DefaultJoinType, DefaultMiterLimit, out);
    return out;
}

References c2_clip_paths(), c2_offset_closed(), Slic3r::ClipperSafetyOffset, Slic3r::DefaultJoinType, Slic3r::DefaultMiterLimit, Slic3r::No, and to_paths64().

Referenced by c2_clip_paths().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_count_expolygons()

size_t Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_count_expolygons

(

const C2::PolyPath64 &

outer

)

{
    size_t cnt = 1;
    for (const auto &hole : outer)
        for (const auto &island : *hole)
            cnt += c2_count_expolygons(*island);
    return cnt;
}

References c2_count_expolygons().

Referenced by c2_count_expolygons(), and c2_to_expolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_expolygons_offset()

template<class ExPolygonRange>

Polygons Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_expolygons_offset	(	const ExPolygonRange &	src,
		float	delta,
		JoinType	joinType,
		double	miterLimit )

{
    C2::Paths64 out;
    c2_offset_expolygons(src, delta, joinType, miterLimit, out);
    return c2_to_polygons(out);
}

References c2_expolygons_offset(), c2_offset_expolygons(), and c2_to_polygons().

Referenced by c2_expolygons_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_expolygons_offset_ex()

template<class ExPolygonRange>

ExPolygons Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_expolygons_offset_ex	(	const ExPolygonRange &	src,
		float	delta,
		JoinType	joinType,
		double	miterLimit )

{
    C2::PolyTree64 out;
    c2_offset_expolygons(src, delta, joinType, miterLimit, out);
    return c2_to_expolygons(out);
}

References c2_expolygons_offset_ex(), c2_offset_expolygons(), and c2_to_expolygons().

Referenced by c2_expolygons_offset_ex().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_offset2_closed()

template<class PathsProvider, class TOut>

void Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_offset2_closed	(	PathsProvider &&	src,
		float	delta1,
		float	delta2,
		JoinType	joinType,
		double	miterLimit,
		TOut &	out )

{
    C2::Paths64 first;
    c2_offset_closed(std::forward<PathsProvider>(src), delta1, joinType, miterLimit, first);
    c2_offset_closed(first, delta2, joinType, miterLimit, out);
}

References c2_offset2_closed(), and c2_offset_closed().

Referenced by c2_offset2_closed().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_offset_as_group()

bool Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_offset_as_group	(	const C2::Paths64 &	paths,
		const std::vector< double > &	areas )

{
    std::vector<C2::Rect64> contours;
    for (size_t i = 0; i < paths.size(); ++ i)
        if (areas[i] > 0.)
            contours.emplace_back(C2::GetBounds(paths[i]));
    for (size_t i = 0; i < paths.size(); ++ i)
        if (areas[i] < 0.) {
            const C2::Rect64 hole = C2::GetBounds(paths[i]);
            if (std::none_of(contours.begin(), contours.end(), [&hole](const C2::Rect64 &r) {
                    return r.left < hole.left && r.right > hole.right && r.top < hole.top && r.bottom > hole.bottom;
                }))
                return false;
        }
    return true;
}

References c2_offset_as_group().

Referenced by c2_offset_as_group(), and c2_offset_closed_paths().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_offset_closed()

template<class PathsT, class TOut>

void Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_offset_closed	(	PathsT &&	src,
		float	delta,
		JoinType	joinType,
		double	miterLimit,
		TOut &	out )

{
    const double shortest = std::abs(delta * ClipperOffsetShortestEdgeFactor);
    C2::Paths64  paths;
    paths.reserve(src.size());
    for (const auto &path : src)
        append_offset_path(paths, path, shortest, C2::EndType::Polygon);
    c2_offset_closed_paths(std::move(paths), delta, joinType, miterLimit, out);
}

References append_offset_path(), c2_offset_closed(), c2_offset_closed_paths(), and Slic3r::ClipperOffsetShortestEdgeFactor.

Referenced by c2_clip_paths(), c2_offset2_closed(), c2_offset_closed(), and c2_offset_lines().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_offset_closed_paths()

template<class TOut>

void Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_offset_closed_paths	(	C2::Paths64 &&	paths,
		float	delta,
		JoinType	joinType,
		double	miterLimit,
		TOut &	out )

{
    std::vector<double> areas;
    areas.reserve(paths.size());
    for (const C2::Path64 &path : paths)
        areas.emplace_back(C2::Area(path));
    C2::ClipperOffset co;
    c2_offset_setup(co, delta, joinType, miterLimit);
    if (c2_offset_as_group(paths, areas)) {
        // Clipper2 would grow degenerate paths even for a negative offset.
        if (delta < 0. && std::all_of(areas.begin(), areas.end(), [](double a) { return a == 0.; }))
            return;
        co.AddPaths(paths, to_c2(joinType), C2::EndType::Polygon);
        co.Execute(delta, out);
        return;
    }
    C2::Paths64 offsetted, single;
    for (size_t i = 0; i < paths.size(); ++ i) {
        if (areas[i] == 0. && delta < 0.)
            continue;
        co.Clear();
        co.AddPath(paths[i], to_c2(joinType), C2::EndType::Polygon);
        // Clipper2 reverses a lone CW path, so the flipped sign shrinks it as a hole.
        co.Execute(areas[i] < 0. ? - delta : delta, single);
        append(offsetted, std::move(single));
    }
    c2_clip(C2::ClipType::Union, offsetted, {}, delta > 0. ? C2::FillRule::NonZero : C2::FillRule::Positive, out);
}

References Slic3r::append(), c2_clip(), c2_offset_as_group(), c2_offset_closed_paths(), c2_offset_setup(), and to_c2().

Referenced by c2_offset_closed(), and c2_offset_closed_paths().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_offset_expolygons()

template<class ExPolygonRange, class TOut>

void Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_offset_expolygons	(	const ExPolygonRange &	src,
		float	delta,
		JoinType	joinType,
		double	miterLimit,
		TOut &	out )

{
    const double shortest = std::abs(delta * ClipperOffsetShortestEdgeFactor);
    C2::Paths64  paths;
    for (const auto &item : src) {
        const ExPolygon &expoly = expolygon_of(item);
        if (! append_offset_path(paths, expoly.contour.points, shortest, C2::EndType::Polygon))
            continue;
        if (const double area = C2::Area(paths.back()); area == 0.) {
            // A degenerate contour vanishes when shrunk and encloses no hole when grown.
            if (delta < 0.)
                paths.pop_back();
            continue;
        } else if (area < 0.)
            std::reverse(paths.back().begin(), paths.back().end());
        for (const Polygon &hole : expoly.holes)
            if (append_offset_path(paths, hole.points, shortest, C2::EndType::Polygon)) {
                if (const double area = C2::Area(paths.back()); area == 0.)
                    paths.pop_back();
                else if (area > 0.)
                    std::reverse(paths.back().begin(), paths.back().end());
            }
    }
    C2::ClipperOffset co;
    c2_offset_setup(co, delta, joinType, miterLimit);
    co.AddPaths(paths, to_c2(joinType), C2::EndType::Polygon);
    co.Execute(delta, out);
}

References append_offset_path(), Slic3r::area(), c2_offset_expolygons(), c2_offset_setup(), Slic3r::ClipperOffsetShortestEdgeFactor, Slic3r::ExPolygon::contour, expolygon_of(), Slic3r::ExPolygon::holes, Slic3r::MultiPoint::points, and to_c2().

Referenced by c2_expolygons_offset(), c2_expolygons_offset_ex(), and c2_offset_expolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_offset_lines()

template<class PathsProvider>

Polygons Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_offset_lines	(	PathsProvider &&	src,
		float	delta,
		JoinType	joinType,
		double	miterLimit,
		EndType	endType,
		double	capTolerance = 0. )

{
    C2::Paths64 out;
    if (endType == etClosedPolygon) {
        c2_offset_closed(std::forward<PathsProvider>(src), delta, joinType, miterLimit, out);
        return c2_to_polygons(out);
    }
    const C2::EndType end      = to_c2(endType);
    const double      shortest = std::abs(delta * ClipperOffsetShortestEdgeFactor);
    C2::Paths64       paths;
    paths.reserve(src.size());
    for (const Points &path : src)
        append_offset_path(paths, path, shortest, end);
    C2::ClipperOffset co;
    c2_offset_setup(co, delta, joinType, miterLimit, capTolerance);
    co.AddPaths(paths, to_c2(joinType), end);
    co.Execute(delta, out);
    return c2_to_polygons(out);
}

References append_offset_path(), c2_offset_closed(), c2_offset_lines(), c2_offset_setup(), c2_to_polygons(), Slic3r::ClipperOffsetShortestEdgeFactor, Slic3r::etClosedPolygon, and to_c2().

Referenced by c2_offset_lines().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_offset_setup()

void Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_offset_setup	(	C2::ClipperOffset &	co,
		float	delta,
		JoinType	joinType,
		double	miterLimit,
		double	capTolerance = 0. )

{
    const double max_arc_tolerance = std::abs(delta) * 0.25;
    if (joinType == jtRound)
        co.ArcTolerance(miterLimit > 0. ? std::min(miterLimit, max_arc_tolerance) : 0.25);
    else {
        co.MiterLimit(std::max(miterLimit, 2.));
        co.ArcTolerance(std::min(capTolerance > 0. ? capTolerance : 0.25, max_arc_tolerance));
    }
}

References c2_offset_setup(), and Slic3r::jtRound.

Referenced by c2_offset_closed_paths(), c2_offset_expolygons(), c2_offset_lines(), and c2_offset_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_to_expolygons()

ExPolygons Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_to_expolygons

(

const C2::PolyTree64 &

tree

)

{
    size_t cnt = 0;
    for (const auto &outer : tree)
        cnt += c2_count_expolygons(*outer);
    ExPolygons out;
    out.reserve(cnt);
    std::vector<const C2::Path64*> stray_holes;
    for (const auto &outer : tree)
        c2_append_expolygons(*outer, out, stray_holes);
    c2_attach_stray_holes(out, 0, stray_holes);
    return out;
}

References c2_append_expolygons(), c2_attach_stray_holes(), c2_count_expolygons(), and c2_to_expolygons().

Referenced by c2_expolygons_offset_ex(), and c2_to_expolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_to_points()

Points Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_to_points ( const C2::Path64 & path )

inline

{
    Points out;
    out.reserve(path.size());
    for (const C2::Point64 &pt : path)
        out.emplace_back(pt.x, pt.y);
    return out;
}

References c2_to_points().

Referenced by c2_append_expolygons(), c2_attach_stray_holes(), c2_to_points(), c2_to_polygons(), and c2_to_polylines().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_to_polygons()

Polygons Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_to_polygons

(

const C2::Paths64 &

paths

)

{
    Polygons out;
    out.reserve(paths.size());
    for (const C2::Path64 &path : paths)
        out.emplace_back().points = c2_to_points(path);
    return out;
}

References c2_to_points(), and c2_to_polygons().

Referenced by c2_expolygons_offset(), c2_offset_lines(), and c2_to_polygons().

Here is the call graph for this function:

Here is the caller graph for this function:

c2_to_polylines()

Polylines Slic3r::anonymous_namespace{ClipperUtils.cpp}::c2_to_polylines

(

const C2::Paths64 &

paths

)

{
    Polylines out;
    out.reserve(paths.size());
    for (const C2::Path64 &path : paths)
        out.emplace_back(c2_to_points(path));
    return out;
}

References c2_to_points(), and c2_to_polylines().

Referenced by c2_clip_open(), and c2_to_polylines().

Here is the call graph for this function:

Here is the caller graph for this function:

expolygon_of() [1/4]

const ExPolygon & Slic3r::anonymous_namespace{ClipperUtils.cpp}::expolygon_of ( const ExPolygon & expoly )

inline

{ return expoly; }

References expolygon_of().

Referenced by c2_offset_expolygons(), expolygon_of(), expolygon_of(), expolygon_of(), and expolygon_of().

Here is the call graph for this function:

Here is the caller graph for this function:

expolygon_of() [2/4]

const ExPolygon & Slic3r::anonymous_namespace{ClipperUtils.cpp}::expolygon_of ( const ExPolygon * expoly )

inline

{ return *expoly; }

References expolygon_of().

Here is the call graph for this function:

expolygon_of() [3/4]

const ExPolygon & Slic3r::anonymous_namespace{ClipperUtils.cpp}::expolygon_of ( const Surface & surface )

inline

{ return surface.expolygon; }

References Slic3r::Surface::expolygon, and expolygon_of().

Here is the call graph for this function:

expolygon_of() [4/4]

const ExPolygon & Slic3r::anonymous_namespace{ClipperUtils.cpp}::expolygon_of ( const Surface * surface )

inline

{ return surface->expolygon; }

References Slic3r::Surface::expolygon, and expolygon_of().

Here is the call graph for this function:

path_encloses()

bool Slic3r::anonymous_namespace{ClipperUtils.cpp}::path_encloses	(	const Polygon &	outer,
		const Polygon &	inner )

{
    // The rounding of the two paths, and of the projection Polygon::on_boundary() measures to.
    static constexpr double touching = 3.;
    for (const Point &pt : inner.points)
        if (! outer.on_boundary(pt, touching))
            return contains(outer, pt, true);
    const std::optional<Point> pt = ClipperUtils::interior_point(inner);
    return pt && contains(outer, *pt, true);
}

References Slic3r::Geometry::contains(), Slic3r::ClipperUtils::interior_point(), Slic3r::Polygon::on_boundary(), path_encloses(), and Slic3r::MultiPoint::points.

Referenced by path_encloses().

Here is the call graph for this function:

Here is the caller graph for this function:

px() [1/2]

int64_t Slic3r::anonymous_namespace{ClipperUtils.cpp}::px ( const C2::Point64 & pt )

inline

{ return pt.x; }

References px().

Here is the call graph for this function:

px() [2/2]

int64_t Slic3r::anonymous_namespace{ClipperUtils.cpp}::px ( const Point & pt )

inline

{ return pt.x(); }

References px().

Referenced by append_offset_path(), px(), and px().

Here is the call graph for this function:

Here is the caller graph for this function:

py() [1/2]

int64_t Slic3r::anonymous_namespace{ClipperUtils.cpp}::py ( const C2::Point64 & pt )

inline

{ return pt.y; }

py() [2/2]

int64_t Slic3r::anonymous_namespace{ClipperUtils.cpp}::py ( const Point & pt )

inline

{ return pt.y(); }

to_c2() [1/4]

C2::ClipType Slic3r::anonymous_namespace{ClipperUtils.cpp}::to_c2

(

ClipType

type

)

{
    switch (type) {
    case ctIntersection: return C2::ClipType::Intersection;
    case ctUnion:        return C2::ClipType::Union;
    case ctDifference:   return C2::ClipType::Difference;
    default:                         return C2::ClipType::Xor;
    }
}

References Slic3r::ctDifference, Slic3r::ctIntersection, Slic3r::ctUnion, and to_c2().

Referenced by c2_offset_closed_paths(), c2_offset_expolygons(), c2_offset_lines(), to_c2(), to_c2(), to_c2(), and to_c2().

Here is the call graph for this function:

Here is the caller graph for this function:

to_c2() [2/4]

C2::EndType Slic3r::anonymous_namespace{ClipperUtils.cpp}::to_c2

(

EndType

type

)

{
    switch (type) {
    case etClosedPolygon: return C2::EndType::Polygon;
    case etClosedLine:    return C2::EndType::Joined;
    case etOpenSquare:    return C2::EndType::Square;
    case etOpenRound:     return C2::EndType::Round;
    default:                          return C2::EndType::Butt;
    }
}

References Slic3r::etClosedLine, Slic3r::etClosedPolygon, Slic3r::etOpenRound, Slic3r::etOpenSquare, and to_c2().

Here is the call graph for this function:

to_c2() [3/4]

C2::JoinType Slic3r::anonymous_namespace{ClipperUtils.cpp}::to_c2

(

JoinType

type

)

{
    switch (type) {
    case jtSquare: return C2::JoinType::Square;
    case jtRound:  return C2::JoinType::Round;
    default:                   return C2::JoinType::Miter;
    }
}

References Slic3r::jtRound, Slic3r::jtSquare, and to_c2().

Here is the call graph for this function:

to_c2() [4/4]

C2::FillRule Slic3r::anonymous_namespace{ClipperUtils.cpp}::to_c2

(

PolyFillType

type

)

{
    switch (type) {
    case pftEvenOdd:  return C2::FillRule::EvenOdd;
    case pftNonZero:  return C2::FillRule::NonZero;
    case pftPositive: return C2::FillRule::Positive;
    default:                      return C2::FillRule::Negative;
    }
}

References Slic3r::pftEvenOdd, Slic3r::pftNonZero, Slic3r::pftPositive, and to_c2().

Here is the call graph for this function:

to_paths64()

template<typename PathsProvider>

C2::Paths64 Slic3r::anonymous_namespace{ClipperUtils.cpp}::to_paths64

(

PathsProvider &&

paths

)

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

References to_paths64().

Referenced by c2_clip_paths(), and to_paths64().

Here is the call graph for this function:

Here is the caller graph for this function: