Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp} Namespace Reference

Functions
std::vector< std::pair< Vec2d, Vec2d > >	text_strokes (const std::string &text, double height, Vec2d &size)
void	paint_back_to_front (std::vector< PlanePiece > &&in, size_t k, const std::vector< SketchPlane > &planes, double eps, const Vec3d &eye, const Vec3d &forward, bool perspective, std::vector< PlanePiece > &out)
double	label_height (double half)
Vec2d	label_centre (double half, const Vec2d &size)
Vec2d	datum_label_anchor (double half)
bool	is_base_plane (int base)
Vec3d	reference_octant ()
double	poly_signed_area (const std::vector< Vec2d > &p)
bool	pt_in_tri (const Vec2d &p, const Vec2d &a, const Vec2d &b, const Vec2d &c)
std::vector< std::array< unsigned, 3 > >	ear_clip (const std::vector< Vec2d > &poly)
double	rad (double deg)
void	poly (std::vector< std::pair< Vec2d, Vec2d > > &out, std::initializer_list< Vec2d > p)
void	arc (std::vector< std::pair< Vec2d, Vec2d > > &out, double cx, double cy, double rx, double ry, double a0, double a1, int n=14)
void	glyph_strokes (char c, std::vector< std::pair< Vec2d, Vec2d > > &out, double &advance)

Variables
constexpr double	kPi = 3.14159265358979323846

Function Documentation

arc()

void Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::arc	(	std::vector< std::pair< Vec2d, Vec2d > > &	out,
		double	cx,
		double	cy,
		double	rx,
		double	ry,
		double	a0,
		double	a1,
		int	n = 14 )

{
    Vec2d prev(cx + rx * std::cos(a0), cy + ry * std::sin(a0));
    for (int i = 1; i <= n; ++i) {
        const double t = a0 + (a1 - a0) * (double)i / n;
        const Vec2d cur(cx + rx * std::cos(t), cy + ry * std::sin(t));
        out.emplace_back(prev, cur);
        prev = cur;
    }
}

References arc().

Referenced by arc(), and glyph_strokes().

Here is the call graph for this function:

Here is the caller graph for this function:

datum_label_anchor()

Vec2d Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::datum_label_anchor

(

double

half

)

{ return Vec2d(-0.8 * half, 0.84 * half); }

References datum_label_anchor().

Referenced by datum_label_anchor().

Here is the call graph for this function:

Here is the caller graph for this function:

ear_clip()

std::vector< std::array< unsigned, 3 > > Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::ear_clip

(

const std::vector< Vec2d > &

poly

)

{
    std::vector<std::array<unsigned, 3>> tris;
    const size_t n = poly.size();
    if (n < 3) return tris;
    std::vector<unsigned> idx(n);
    for (unsigned i = 0; i < n; ++i) idx[i] = i;
    if (poly_signed_area(poly) < 0.0) std::reverse(idx.begin(), idx.end());   // work CCW
    int guard = 0;
    while (idx.size() > 3 && guard++ < int(10 * n)) {
        bool clipped = false;
        const int m = int(idx.size());
        for (int i = 0; i < m; ++i) {
            const unsigned i0 = idx[(i + m - 1) % m];
            const unsigned i1 = idx[i];
            const unsigned i2 = idx[(i + 1) % m];
            const Vec2d& a = poly[i0]; const Vec2d& b = poly[i1]; const Vec2d& c = poly[i2];
            const double cr = (b.x() - a.x()) * (c.y() - a.y()) - (b.y() - a.y()) * (c.x() - a.x());
            if (cr <= 0.0) continue;   // reflex vertex, not an ear tip
            bool ear = true;
            for (int j = 0; j < m; ++j) {
                const unsigned ij = idx[j];
                if (ij == i0 || ij == i1 || ij == i2) continue;
                if (pt_in_tri(poly[ij], a, b, c)) { ear = false; break; }
            }
            if (!ear) continue;
            tris.push_back({ i0, i1, i2 });
            idx.erase(idx.begin() + i);
            clipped = true;
            break;
        }
        if (!clipped) break;   // degenerate input: bail rather than spin
    }
    if (idx.size() == 3) tris.push_back({ idx[0], idx[1], idx[2] });
    return tris;
}

References ear_clip(), poly(), poly_signed_area(), and pt_in_tri().

Referenced by ear_clip().

Here is the call graph for this function:

Here is the caller graph for this function:

glyph_strokes()

void Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::glyph_strokes	(	char	c,
		std::vector< std::pair< Vec2d, Vec2d > > &	out,
		double &	advance )

{
    advance = 0.72;
    switch (c) {
    case '0':
        arc(out, 0.30, 0.50, 0.25, 0.48, 0.0, 2.0 * kPi);
        break;
    case '1':
        poly(out, {Vec2d(0.13, 0.76), Vec2d(0.33, 1.0), Vec2d(0.33, 0.0)});
        poly(out, {Vec2d(0.13, 0.0), Vec2d(0.53, 0.0)});
        advance = 0.52;
        break;
    case '2':
        arc(out, 0.30, 0.72, 0.25, 0.25, rad(170), rad(-45));
        poly(out, {Vec2d(0.477, 0.543), Vec2d(0.06, 0.0), Vec2d(0.56, 0.0)});
        break;
    case '3':
        arc(out, 0.30, 0.74, 0.24, 0.24, rad(160), rad(-90));
        arc(out, 0.30, 0.26, 0.26, 0.26, rad(90), rad(-160));
        break;
    case '4':
        poly(out, {Vec2d(0.42, 1.0), Vec2d(0.04, 0.32), Vec2d(0.58, 0.32)});
        poly(out, {Vec2d(0.42, 1.0), Vec2d(0.42, 0.0)});
        break;
    case '5':
        poly(out, {Vec2d(0.54, 1.0), Vec2d(0.12, 1.0), Vec2d(0.11, 0.52)});
        arc(out, 0.27, 0.30, 0.27, 0.27, rad(130), rad(-120));
        break;
    case '6':
        arc(out, 0.30, 0.28, 0.26, 0.26, 0.0, 2.0 * kPi);
        arc(out, 0.30, 0.55, 0.30, 0.45, rad(90), rad(190));
        break;
    case '7':
        poly(out, {Vec2d(0.05, 1.0), Vec2d(0.57, 1.0), Vec2d(0.22, 0.0)});
        break;
    case '8':
        arc(out, 0.30, 0.73, 0.22, 0.25, 0.0, 2.0 * kPi);
        arc(out, 0.30, 0.26, 0.26, 0.26, 0.0, 2.0 * kPi);
        break;
    case '9':
        arc(out, 0.30, 0.70, 0.26, 0.26, 0.0, 2.0 * kPi);
        arc(out, 0.28, 0.55, 0.28, 0.55, rad(15), rad(-90));
        break;
    case '.':
    case ',':  // locale (LC_NUMERIC) may format the decimal separator as a comma
        // small solid dot: crossed short strokes so the quads fill a visible disk
        poly(out, {Vec2d(0.10, 0.08), Vec2d(0.24, 0.08)});
        poly(out, {Vec2d(0.17, 0.02), Vec2d(0.17, 0.15)});
        advance = 0.30;
        break;
    case '-':
        poly(out, {Vec2d(0.10, 0.5), Vec2d(0.50, 0.5)});
        advance = 0.62;
        break;
    case 'R':
        poly(out, {Vec2d(0.08, 0.0), Vec2d(0.08, 1.0), Vec2d(0.38, 1.0)});
        arc(out, 0.38, 0.75, 0.17, 0.25, rad(90), rad(-90));
        poly(out, {Vec2d(0.38, 0.50), Vec2d(0.08, 0.50)});
        poly(out, {Vec2d(0.30, 0.50), Vec2d(0.58, 0.0)});
        advance = 0.80;
        break;
    case 'X':
        poly(out, {Vec2d(0.06, 1.0), Vec2d(0.58, 0.0)});
        poly(out, {Vec2d(0.58, 1.0), Vec2d(0.06, 0.0)});
        advance = 0.72;
        break;
    case 'Y':
        poly(out, {Vec2d(0.06, 1.0), Vec2d(0.32, 0.52)});
        poly(out, {Vec2d(0.58, 1.0), Vec2d(0.32, 0.52)});
        poly(out, {Vec2d(0.32, 0.52), Vec2d(0.32, 0.0)});
        advance = 0.72;
        break;
    case 'Z':
        poly(out, {Vec2d(0.06, 1.0), Vec2d(0.58, 1.0), Vec2d(0.06, 0.0), Vec2d(0.58, 0.0)});
        advance = 0.72;
        break;
    case ' ':
        advance = 0.5;
        break;
    default:
        advance = 0.5;
        break;
    }
}

References arc(), glyph_strokes(), kPi, poly(), and rad().

Referenced by glyph_strokes(), and text_strokes().

Here is the call graph for this function:

Here is the caller graph for this function:

is_base_plane()

bool Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::is_base_plane

(

int

base

)

{ return base >= 0 && base < 3; }

References is_base_plane().

Referenced by is_base_plane().

Here is the call graph for this function:

Here is the caller graph for this function:

label_centre()

Vec2d Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::label_centre	(	double	half,
		const Vec2d &	size )

{ return Vec2d::Constant(0.88 * half) - 0.5 * size; }

References label_centre().

Referenced by label_centre().

Here is the call graph for this function:

Here is the caller graph for this function:

label_height()

double Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::label_height

(

double

half

)

{ return 0.30 * half; }

References label_height().

Referenced by label_height().

Here is the call graph for this function:

Here is the caller graph for this function:

paint_back_to_front()

void Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::paint_back_to_front	(	std::vector< PlanePiece > &&	in,
		size_t	k,
		const std::vector< SketchPlane > &	planes,
		double	eps,
		const Vec3d &	eye,
		const Vec3d &	forward,
		bool	perspective,
		std::vector< PlanePiece > &	out )

{
    if (in.empty())
        return;
    if (k == planes.size()) {   // not reached: every piece is in the splitter at its own plane's level
        std::move(in.begin(), in.end(), std::back_inserter(out));
        return;
    }
    // The square's own normal: SketchPlane::normal is reversed on XZ, and the side tests only need
    // one consistent choice.
    const Vec3d  n = planes[k].x_axis.cross(planes[k].y_axis).normalized();
    const double d = n.dot(planes[k].origin);
    std::vector<PlanePiece> front, back, on;
    for (PlanePiece& piece : in) {
        if (piece.plane == int(k)) {
            on.push_back(std::move(piece));
            continue;
        }
        std::vector<double> s;
        int                 sides = 0;
        for (const Vec3d& c : piece.corners) {
            s.push_back(n.dot(c) - d);
            sides |= s.back() > eps ? 1 : s.back() < -eps ? 2 : 0;
        }
        if (sides == 0)
            on.push_back(std::move(piece));
        else if (sides == 1)
            front.push_back(std::move(piece));
        else if (sides == 2)
            back.push_back(std::move(piece));
        else {
            PlanePiece   f{ piece.plane, {} }, b{ piece.plane, {} };
            const size_t m = piece.corners.size();
            for (size_t i = 0; i < m; ++i) {
                const size_t j = (i + 1) % m;
                const Vec3d& a = piece.corners[i];
                if (s[i] >= -eps) f.corners.push_back(a);
                if (s[i] <= eps)  b.corners.push_back(a);
                if ((s[i] > eps && s[j] < -eps) || (s[i] < -eps && s[j] > eps)) {
                    const Vec3d x = a + (piece.corners[j] - a) * (s[i] / (s[i] - s[j]));
                    f.corners.push_back(x);
                    b.corners.push_back(x);
                }
            }
            front.push_back(std::move(f));
            back.push_back(std::move(b));
        }
    }
    // An orthographic eye is at infinity behind the view direction. Camera::get_position() is a
    // finite point there and can sit on the wrong side of a plane, so only the direction counts.
    const bool eye_in_front = perspective ? n.dot(eye) - d > 0. : n.dot(forward) < 0.;
    paint_back_to_front(std::move(eye_in_front ? back : front), k + 1, planes, eps, eye, forward, perspective, out);
    std::move(on.begin(), on.end(), std::back_inserter(out));
    paint_back_to_front(std::move(eye_in_front ? front : back), k + 1, planes, eps, eye, forward, perspective, out);
}

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

Referenced by paint_back_to_front().

Here is the call graph for this function:

Here is the caller graph for this function:

poly()

void Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::poly	(	std::vector< std::pair< Vec2d, Vec2d > > &	out,
		std::initializer_list< Vec2d >	p )

{
    auto it = p.begin();
    if (it == p.end()) return;
    Vec2d prev = *it++;
    for (; it != p.end(); ++it) { out.emplace_back(prev, *it); prev = *it; }
}

References poly().

Referenced by ear_clip(), glyph_strokes(), and poly().

Here is the call graph for this function:

Here is the caller graph for this function:

poly_signed_area()

double Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::poly_signed_area

(

const std::vector< Vec2d > &

p

)

{
    double a = 0.0;
    for (size_t i = 0, n = p.size(); i < n; ++i) {
        const Vec2d& u = p[i];
        const Vec2d& v = p[(i + 1) % n];
        a += u.x() * v.y() - v.x() * u.y();
    }
    return 0.5 * a;
}

References poly_signed_area().

Referenced by ear_clip(), and poly_signed_area().

Here is the call graph for this function:

Here is the caller graph for this function:

pt_in_tri()

bool Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::pt_in_tri	(	const Vec2d &	p,
		const Vec2d &	a,
		const Vec2d &	b,
		const Vec2d &	c )

{
    auto cross = [](const Vec2d& u, const Vec2d& v, const Vec2d& w) {
        return (v.x() - u.x()) * (w.y() - u.y()) - (v.y() - u.y()) * (w.x() - u.x());
    };
    const double d1 = cross(a, b, p), d2 = cross(b, c, p), d3 = cross(c, a, p);
    const bool neg = (d1 < 0) || (d2 < 0) || (d3 < 0);
    const bool pos = (d1 > 0) || (d2 > 0) || (d3 > 0);
    return !(neg && pos);   // inside iff all cross products share a sign
}

References Slic3r::cross(), and pt_in_tri().

Referenced by ear_clip(), and pt_in_tri().

Here is the call graph for this function:

Here is the caller graph for this function:

rad()

double Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::rad ( double deg )

inline

{ return deg * kPi / 180.0; }

References kPi, and rad().

Referenced by glyph_strokes(), and rad().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_octant()

Vec3d Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::reference_octant

(

)

{ return Vec3d(1., -1., 1.); }

References reference_octant().

Referenced by reference_octant().

Here is the call graph for this function:

Here is the caller graph for this function:

text_strokes()

std::vector< std::pair< Vec2d, Vec2d > > Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::text_strokes	(	const std::string &	text,
		double	height,
		Vec2d &	size )

{
    std::vector<std::pair<Vec2d, Vec2d>> out;
    double                               pen = 0.;
    for (char c : text) {
        std::vector<std::pair<Vec2d, Vec2d>> glyph;
        double                               advance = 0.;
        glyph_strokes(c, glyph, advance);
        for (const auto& [a, b] : glyph)
            out.emplace_back((a + Vec2d(pen, 0.)) * height, (b + Vec2d(pen, 0.)) * height);
        pen += advance;
    }
    BoundingBoxf box;
    for (const auto& [a, b] : out) {
        box.merge(a);
        box.merge(b);
    }
    if (!box.defined) {
        size = Vec2d::Zero();
        return out;
    }
    const Vec2d mid = box.center();
    for (auto& [a, b] : out) {
        a -= mid;
        b -= mid;
    }
    size = box.size();
    return out;
}

References Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::BoundingBoxBase< PointType, APointsType >::defined, glyph_strokes(), Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), and text_strokes().

Referenced by text_strokes().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

kPi

double Slic3r::GUI::anonymous_namespace{DesignSketchTool.cpp}::kPi = 3.14159265358979323846

constexpr

Referenced by glyph_strokes(), and rad().