Slic3r::anonymous_namespace{SketchEngine.cpp} Namespace Reference

Functions
bool	off_same (const Vec2d &a, const Vec2d &b)
bool	off_is_open_curve (const SketchEntity &e)
bool	off_pick (const std::vector< Vec2d > &cands, const Vec2d &seed, Vec2d &out)
bool	off_line_line (const Vec2d &a0, const Vec2d &a1, const Vec2d &b0, const Vec2d &b1, const Vec2d &seed, Vec2d &out)
std::vector< Vec2d >	off_line_circle (const Vec2d &p0, const Vec2d &p1, const Vec2d &c, double r)
std::vector< Vec2d >	off_circle_circle (const Vec2d &c0, double r0, const Vec2d &c1, double r1)
void	off_set_end (SketchEntity &e, bool at_end, const Vec2d &q)
bool	off_one (const SketchEntity &e, double d, SketchEntity &out)
bool	off_join (SketchEntity &a, SketchEntity &b)
void	off_reverse (SketchEntity &e)
bool	angle_on_arc (const SketchEntity &e, double ang, double tol)
void	entity_intersections (const SketchEntity &A, const SketchEntity &B, std::vector< Vec2d > &out)

Function Documentation

angle_on_arc()

bool Slic3r::anonymous_namespace{SketchEngine.cpp}::angle_on_arc	(	const SketchEntity &	e,
		double	ang,
		double	tol )

{
    const double TWO_PI = 2.0 * M_PI;
    const double sweep  = e.end_angle - e.start_angle;
    double d = (sweep >= 0.0) ? ang - e.start_angle : e.start_angle - ang;
    d = std::fmod(d, TWO_PI);
    if (d < 0.0) d += TWO_PI;
    if (d > TWO_PI - tol) d -= TWO_PI;     // just before the start counts as the start
    return d >= -tol && d <= std::abs(sweep) + tol;
}

References angle_on_arc(), Slic3r::SketchEntity::end_angle, M_PI, and Slic3r::SketchEntity::start_angle.

Referenced by angle_on_arc(), and entity_intersections().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_intersections()

void Slic3r::anonymous_namespace{SketchEngine.cpp}::entity_intersections	(	const SketchEntity &	A,
		const SketchEntity &	B,
		std::vector< Vec2d > &	out )

{
    using T = SketchEntity::Type;
    const double eps = 1e-9;
    auto on_seg = [](const SketchEntity& L, const Vec2d& p) {
        const Vec2d d = L.p1 - L.p0;
        const double l2 = d.squaredNorm();
        if (l2 < 1e-24) return false;
        const double t = (p - L.p0).dot(d) / l2;
        return t >= -1e-9 && t <= 1.0 + 1e-9;
    };
    if (A.type == T::Line && B.type == T::Line) {
        const Vec2d r = A.p1 - A.p0, q = B.p1 - B.p0, w = B.p0 - A.p0;
        const double den = r.x() * q.y() - r.y() * q.x();
        if (std::abs(den) < eps * r.norm() * q.norm()) {
            // Parallel. Collinear overlap is a crossing wherever it is: report the overlap's
            // nearest end, which the caller then tests against the shared joints.
            if (std::abs(r.x() * w.y() - r.y() * w.x()) > 1e-9 * std::max(1.0, r.norm())) return;
            for (const Vec2d& p : { B.p0, B.p1 }) if (on_seg(A, p)) out.push_back(p);
            for (const Vec2d& p : { A.p0, A.p1 }) if (on_seg(B, p)) out.push_back(p);
            return;
        }
        const double t = (w.x() * q.y() - w.y() * q.x()) / den;
        const double u = (w.x() * r.y() - w.y() * r.x()) / den;
        if (t >= -1e-9 && t <= 1.0 + 1e-9 && u >= -1e-9 && u <= 1.0 + 1e-9) out.push_back(A.p0 + t * r);
        return;
    }
    if (A.type == T::Arc && B.type == T::Line) { entity_intersections(B, A, out); return; }
    if (A.type == T::Line && B.type == T::Arc) {
        const Vec2d d = A.p1 - A.p0, f = A.p0 - B.center;
        const double a = d.squaredNorm(), b = 2.0 * f.dot(d), c = f.squaredNorm() - B.radius * B.radius;
        if (a < 1e-24) return;
        double disc = b * b - 4.0 * a * c;
        if (disc < -1e-9 * a * B.radius * B.radius) return;
        disc = std::sqrt(std::max(0.0, disc));
        for (double t : { (-b - disc) / (2.0 * a), (-b + disc) / (2.0 * a) }) {
            if (t < -1e-9 || t > 1.0 + 1e-9) continue;
            const Vec2d p = A.p0 + t * d;
            if (angle_on_arc(B, std::atan2(p.y() - B.center.y(), p.x() - B.center.x()), 1e-9))
                out.push_back(p);
        }
        return;
    }
    if (A.type == T::Arc && B.type == T::Arc) {
        const Vec2d dc = B.center - A.center;
        const double dd = dc.norm();
        if (dd < 1e-12) {
            // Concentric: they overlap only on the same circle, and then everywhere they share.
            if (std::abs(A.radius - B.radius) > 1e-9) return;
            for (const Vec2d& p : { B.p0, B.p1 })
                if (angle_on_arc(A, std::atan2(p.y() - A.center.y(), p.x() - A.center.x()), 1e-9)) out.push_back(p);
            for (const Vec2d& p : { A.p0, A.p1 })
                if (angle_on_arc(B, std::atan2(p.y() - B.center.y(), p.x() - B.center.x()), 1e-9)) out.push_back(p);
            return;
        }
        if (dd > A.radius + B.radius + 1e-9 || dd < std::abs(A.radius - B.radius) - 1e-9) return;
        const double x = (dd * dd + A.radius * A.radius - B.radius * B.radius) / (2.0 * dd);
        const double h = std::sqrt(std::max(0.0, A.radius * A.radius - x * x));
        const Vec2d  u = dc / dd, m = A.center + x * u, n(-u.y(), u.x());
        for (const Vec2d& p : { Vec2d(m + h * n), Vec2d(m - h * n) }) {
            if (angle_on_arc(A, std::atan2(p.y() - A.center.y(), p.x() - A.center.x()), 1e-9) &&
                angle_on_arc(B, std::atan2(p.y() - B.center.y(), p.x() - B.center.x()), 1e-9))
                out.push_back(p);
            if (h < 1e-12) break;
        }
    }
}

References angle_on_arc(), Slic3r::SketchEntity::center, Slic3r::dot(), entity_intersections(), Slic3r::f(), L, Slic3r::l2(), Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::radius, and Slic3r::SketchEntity::type.

Referenced by entity_intersections().

Here is the call graph for this function:

Here is the caller graph for this function:

off_circle_circle()

std::vector< Vec2d > Slic3r::anonymous_namespace{SketchEngine.cpp}::off_circle_circle	(	const Vec2d &	c0,
		double	r0,
		const Vec2d &	c1,
		double	r1 )

{
    std::vector<Vec2d> out;
    const Vec2d d = c1 - c0;
    const double L = d.norm();
    if (L < 1e-12 || L > r0 + r1 || L < std::abs(r0 - r1)) return out;
    const double a = (r0 * r0 - r1 * r1 + L * L) / (2.0 * L);
    const double h2 = r0 * r0 - a * a;
    const double h = h2 > 0.0 ? std::sqrt(h2) : 0.0;
    const Vec2d u = d / L, n(-u.y(), u.x());
    out.push_back(c0 + a * u + h * n);
    out.push_back(c0 + a * u - h * n);
    return out;
}

References L, and off_circle_circle().

Referenced by off_circle_circle(), and off_join().

Here is the call graph for this function:

Here is the caller graph for this function:

off_is_open_curve()

bool Slic3r::anonymous_namespace{SketchEngine.cpp}::off_is_open_curve

(

const SketchEntity &

e

)

{
    return e.type == SketchEntity::Type::Line || e.type == SketchEntity::Type::Arc;
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::Line, off_is_open_curve(), and Slic3r::SketchEntity::type.

Referenced by off_is_open_curve().

Here is the call graph for this function:

Here is the caller graph for this function:

off_join()

bool Slic3r::anonymous_namespace{SketchEngine.cpp}::off_join	(	SketchEntity &	a,
		SketchEntity &	b )

{
    const Vec2d seed = 0.5 * (a.p1 + b.p0);
    Vec2d q;
    const bool aL = a.type == SketchEntity::Type::Line;
    const bool bL = b.type == SketchEntity::Type::Line;
    if (aL && bL) {
        if (!off_line_line(a.p0, a.p1, b.p0, b.p1, seed, q)) return false;
    } else if (aL) {
        if (!off_pick(off_line_circle(a.p0, a.p1, b.center, b.radius), seed, q)) return false;
    } else if (bL) {
        if (!off_pick(off_line_circle(b.p0, b.p1, a.center, a.radius), seed, q)) return false;
    } else {
        if (!off_pick(off_circle_circle(a.center, a.radius, b.center, b.radius), seed, q)) return false;
    }
    off_set_end(a, true,  q);
    off_set_end(b, false, q);
    return true;
}

References Slic3r::SketchEntity::center, Slic3r::SketchEntity::Line, off_circle_circle(), off_join(), off_line_circle(), off_line_line(), off_pick(), off_set_end(), Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::radius, and Slic3r::SketchEntity::type.

Referenced by off_join().

Here is the call graph for this function:

Here is the caller graph for this function:

off_line_circle()

std::vector< Vec2d > Slic3r::anonymous_namespace{SketchEngine.cpp}::off_line_circle	(	const Vec2d &	p0,
		const Vec2d &	p1,
		const Vec2d &	c,
		double	r )

{
    std::vector<Vec2d> out;
    Vec2d d = p1 - p0;
    const double dd = d.squaredNorm();
    if (dd < 1e-18 || r <= 0.0) return out;
    const Vec2d f = p0 - c;
    const double b = 2.0 * f.dot(d), cc = f.squaredNorm() - r * r;
    const double disc = b * b - 4.0 * dd * cc;
    if (disc < 0.0) return out;
    const double sq = std::sqrt(disc);
    out.push_back(p0 + ((-b - sq) / (2.0 * dd)) * d);
    out.push_back(p0 + ((-b + sq) / (2.0 * dd)) * d);
    return out;
}

References Slic3r::f(), and off_line_circle().

Referenced by off_join(), and off_line_circle().

Here is the call graph for this function:

Here is the caller graph for this function:

off_line_line()

bool Slic3r::anonymous_namespace{SketchEngine.cpp}::off_line_line	(	const Vec2d &	a0,
		const Vec2d &	a1,
		const Vec2d &	b0,
		const Vec2d &	b1,
		const Vec2d &	seed,
		Vec2d &	out )

{
    const Vec2d da = a1 - a0, db = b1 - b0;
    const double den = da.x() * db.y() - da.y() * db.x();
    if (std::abs(den) < 1e-12) return false;                 // parallel: no miter exists
    const Vec2d w = b0 - a0;
    const double t = (w.x() * db.y() - w.y() * db.x()) / den;
    out = a0 + t * da;
    (void)seed;
    return true;
}

References off_line_line().

Referenced by off_join(), and off_line_line().

Here is the call graph for this function:

Here is the caller graph for this function:

off_one()

bool Slic3r::anonymous_namespace{SketchEngine.cpp}::off_one	(	const SketchEntity &	e,
		double	d,
		SketchEntity &	out )

{
    switch (e.type) {
    case SketchEntity::Type::Line: {
        Vec2d t = e.p1 - e.p0;
        if (t.norm() < 1e-12) return false;
        t.normalize();
        const Vec2d n(-t.y(), t.x());
        out = e;
        out.p0 = e.p0 + d * n;
        out.p1 = e.p1 + d * n;
        return true;
    }
    case SketchEntity::Type::Circle: {
        // A circle runs CCW (it is what a 360° CCW arc chain closes into), so the rule below
        // applies to it too: +d is the left side, the inside, and the radius SHRINKS. It used to
        // grow, so a full circle and the same outline drawn as arcs offset opposite ways.
        const double r = e.radius - d;
        if (r <= 1e-9) return false;
        out = e; out.radius = r; out.p0 = out.center;
        return true;
    }
    case SketchEntity::Type::Arc: {
        // Same convention as the Line above: +d moves the curve to the LEFT of its direction
        // of travel. For a CCW arc the left side is the inside, so the radius SHRINKS; for a
        // CW arc it grows. Reading the sign off the sweep is what keeps a stadium outline
        // (lines + caps) offsetting as one body instead of the lines going one way and the
        // caps the other — which is what a plain `radius + d` did.
        const double sgn = (e.end_angle >= e.start_angle) ? -1.0 : 1.0;
        const double r = e.radius + sgn * d;
        if (r <= 1e-9) return false;
        out = e;
        out.radius = r;
        out.p0 = e.center + r * Vec2d(std::cos(e.start_angle), std::sin(e.start_angle));
        out.p1 = e.center + r * Vec2d(std::cos(e.end_angle),   std::sin(e.end_angle));
        return true;
    }
    default:
        // Point has nothing to offset; a true parallel of an ellipse is not an ellipse and of a
        // spline is not a same-degree spline, so both stay out of v1 rather than lie about it.
        return false;
    }
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::center, Slic3r::SketchEntity::Circle, Slic3r::SketchEntity::end_angle, Slic3r::SketchEntity::Line, off_one(), Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::radius, Slic3r::sgn(), Slic3r::SketchEntity::start_angle, and Slic3r::SketchEntity::type.

Referenced by off_one().

Here is the call graph for this function:

Here is the caller graph for this function:

off_pick()

bool Slic3r::anonymous_namespace{SketchEngine.cpp}::off_pick	(	const std::vector< Vec2d > &	cands,
		const Vec2d &	seed,
		Vec2d &	out )

{
    if (cands.empty()) return false;
    double best = std::numeric_limits<double>::max();
    for (const Vec2d& c : cands) {
        const double d = (c - seed).squaredNorm();
        if (d < best) { best = d; out = c; }
    }
    return true;
}

References off_pick().

Referenced by off_join(), and off_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

off_reverse()

void Slic3r::anonymous_namespace{SketchEngine.cpp}::off_reverse

(

SketchEntity &

e

)

{
    std::swap(e.p0, e.p1);
    if (e.type == SketchEntity::Type::Arc)
        std::swap(e.start_angle, e.end_angle);
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::end_angle, off_reverse(), Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::start_angle, and Slic3r::SketchEntity::type.

Referenced by off_reverse().

Here is the call graph for this function:

Here is the caller graph for this function:

off_same()

bool Slic3r::anonymous_namespace{SketchEngine.cpp}::off_same	(	const Vec2d &	a,
		const Vec2d &	b )

{
    const double tol = std::max(sketch_join_tol(), 1e-6);
    return (a - b).squaredNorm() <= tol * tol;
}

References off_same(), and Slic3r::sketch_join_tol().

Referenced by off_same().

Here is the call graph for this function:

Here is the caller graph for this function:

off_set_end()

void Slic3r::anonymous_namespace{SketchEngine.cpp}::off_set_end	(	SketchEntity &	e,
		bool	at_end,
		const Vec2d &	q )

{
    if (e.type == SketchEntity::Type::Line) {
        (at_end ? e.p1 : e.p0) = q;
        return;
    }
    if (e.type != SketchEntity::Type::Arc) return;
    const bool ccw = e.end_angle >= e.start_angle;
    const double ang = std::atan2(q.y() - e.center.y(), q.x() - e.center.x());
    if (at_end) {
        e.p1 = q;
        double a = ang;
        if (ccw) { while (a < e.start_angle) a += 2.0 * M_PI; while (a - e.start_angle > 2.0 * M_PI) a -= 2.0 * M_PI; }
        else     { while (a > e.start_angle) a -= 2.0 * M_PI; while (e.start_angle - a > 2.0 * M_PI) a += 2.0 * M_PI; }
        e.end_angle = a;
    } else {
        e.p0 = q;
        double a = ang;
        if (ccw) { while (a > e.end_angle) a -= 2.0 * M_PI; while (e.end_angle - a > 2.0 * M_PI) a += 2.0 * M_PI; }
        else     { while (a < e.end_angle) a += 2.0 * M_PI; while (a - e.end_angle > 2.0 * M_PI) a -= 2.0 * M_PI; }
        e.start_angle = a;
    }
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::center, Slic3r::SketchEntity::end_angle, Slic3r::SketchEntity::Line, M_PI, off_set_end(), Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::start_angle, and Slic3r::SketchEntity::type.

Referenced by off_join(), and off_set_end().

Here is the call graph for this function:

Here is the caller graph for this function: