Slic3r::SeamContour::anonymous_namespace{SeamContour.cpp} Namespace Reference

Classes
struct	Foot
struct	Witness
struct	BoxEntry

Functions
double	box_distance (const Contour &c, const Vec2d &p)
Foot	closest (const Contour &c, const Vec2d &p, double stop=-1.0, const std::vector< Vec2d > *source_normals=nullptr, double normal_cosine=0.0)
std::vector< Vec2d >	normals (const Contour &c, const Vec2d &p)

---

Class Documentation

Slic3r::SeamContour::anonymous_namespace{SeamContour.cpp}::Foot

struct Slic3r::SeamContour::anonymous_namespace{SeamContour.cpp}::Foot

Class Members
double	distance = std::numeric_limits<double>::infinity()
Vec2d	point = Vec2d::Zero()

Slic3r::SeamContour::anonymous_namespace{SeamContour.cpp}::Witness

struct Slic3r::SeamContour::anonymous_namespace{SeamContour.cpp}::Witness

Class Members
double	angle_degrees
size_t	contour
double	distance

Function Documentation

box_distance()

double Slic3r::SeamContour::anonymous_namespace{SeamContour.cpp}::box_distance	(	const Contour &	c,
		const Vec2d &	p )

                                                      {
    return ((c.min - p).cwiseMax(Vec2d::Zero()) + (p - c.max).cwiseMax(Vec2d::Zero())).norm();
}

References box_distance(), Slic3r::SeamContour::Contour::max, and Slic3r::SeamContour::Contour::min.

Referenced by box_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

closest()

Foot Slic3r::SeamContour::anonymous_namespace{SeamContour.cpp}::closest	(	const Contour &	c,
		const Vec2d &	p,
		double	stop = -1.0,
		const std::vector< Vec2d > *	source_normals = nullptr,
		double	normal_cosine = 0.0 )

                                                                                           {
    Foot result;
    if (stop >= 0.0 && !source_normals)
        for (const Vec2d &vertex : c.points)
            if ((vertex - p).norm() <= stop) return {vertex, (vertex - p).norm()};
    for (size_t i = 0; i < c.points.size(); ++i) {
        const Vec2d &a = c.points[i];
        const Vec2d d = c.points[(i + 1) % c.points.size()] - a;
        const double length2 = d.squaredNorm();
        if (source_normals) {
            if (length2 <= 1e-18) continue;
            const Vec2d normal = (c.hole ? -1.0 : 1.0) * Vec2d(d.y(), -d.x()) / std::sqrt(length2);
            // A thin contour's nearest opposite side must not hide its slightly farther facing side.
            if (std::none_of(source_normals->begin(), source_normals->end(), [&](const Vec2d &n) {
                    return n.dot(normal) >= normal_cosine;
                })) continue;
        }
        const double t = length2 > 0.0 ? std::clamp((p - a).dot(d) / length2, 0.0, 1.0) : 0.0;
        const Vec2d q = a + t * d;
        const double distance = (q - p).norm();
        if (distance < result.distance) result = {q, distance};
        if (result.distance <= stop) break; // A proximity certificate needs no exact closest point.
    }
    return result;
}

References closest(), Slic3r::SeamContour::anonymous_namespace{SeamContour.cpp}::Foot::distance, Slic3r::dot(), Slic3r::SeamContour::Contour::hole, Slic3r::normal(), and Slic3r::SeamContour::Contour::points.

Referenced by closest().

Here is the call graph for this function:

Here is the caller graph for this function:

normals()

std::vector< Vec2d > Slic3r::SeamContour::anonymous_namespace{SeamContour.cpp}::normals	(	const Contour &	c,
		const Vec2d &	p )

                                                           {
    std::vector<Vec2d> result;
    for (size_t i = 0; i < c.points.size(); ++i) {
        const Vec2d &a = c.points[i];
        const Vec2d d = c.points[(i + 1) % c.points.size()] - a;
        if (d.squaredNorm() <= 1e-18) continue;
        const double t = std::clamp((p - a).dot(d) / d.squaredNorm(), 0.0, 1.0);
        // Every caller supplies a vertex or closest foot on this boundary; avoid a second full search.
        if ((a + t * d - p).norm() <= 1e-6) {
            // Candidate polygons are CCW; a hole has material on their opposite side.
            const Vec2d n(d.y(), -d.x());
            result.push_back((c.hole ? -1.0 : 1.0) * n.normalized());
        }
    }
    return result;
}

References Slic3r::dot(), Slic3r::SeamContour::Contour::hole, normals(), and Slic3r::SeamContour::Contour::points.

Referenced by normals().

Here is the call graph for this function:

Here is the caller graph for this function: