anonymous_namespace{NSVGUtils.cpp} Namespace Reference

Classes
struct	LinesPath
struct	DashesParam

Functions
bool	is_line (const float *p, float precision=1e-4f)
LinesPath	linearize_path (NSVGpath *first_path, const NSVGLineParams &param)
HealedExPolygons	fill_to_expolygons (const LinesPath &lines_path, const NSVGshape &shape, const NSVGLineParams &param)
HealedExPolygons	stroke_to_expolygons (const LinesPath &lines_path, const NSVGshape &shape, const NSVGLineParams &param)
Point::coord_type	to_coor (float val, double scale)
bool	need_flattening (float tessTol, const Vec2f &p1, const Vec2f &p2, const Vec2f &p3, const Vec2f &p4)
void	flatten_cubic_bez (Points &points, float tessTol, const Vec2f &p1, const Vec2f &p2, const Vec2f &p3, const Vec2f &p4, int level)
	Convert cubic curve to lines Inspired by nanosvgrast.h function nsvgRasterize -> nsvg__flattenShape -> nsvg__flattenCubicBez https://github.com/memononen/nanosvg/blob/f0a3e1034dd22e2e87e5db22401e44998383124e/src/nanosvgrast.h#L335.
Polylines	to_dashes (const Polyline &polyline, const DashesParam &param)

---

Class Documentation

anonymous_namespace{NSVGUtils.cpp}::LinesPath

struct anonymous_namespace{NSVGUtils.cpp}::LinesPath

Collaboration diagram for anonymous_namespace{NSVGUtils.cpp}::LinesPath:

Class Members
Polygons	polygons
Polylines	polylines

Function Documentation

fill_to_expolygons()

HealedExPolygons anonymous_namespace{NSVGUtils.cpp}::fill_to_expolygons	(	const LinesPath &	lines_path,
		const NSVGshape &	shape,
		const NSVGLineParams &	param )

{
    Polygons fill = lines_path.polygons; // copy
 
    // close polyline to create polygon
    polygons_append(fill, to_polygons(lines_path.polylines));
    if (fill.empty())
        return {};
 
    // if (shape->fillRule == NSVGfillRule::NSVG_FILLRULE_NONZERO)
    bool is_non_zero = true;
    if (shape.fillRule == NSVGfillRule::NSVG_FILLRULE_EVENODD)
        is_non_zero = false;
 
    return Emboss::heal_polygons(fill, is_non_zero, param.max_heal_iteration);
}

References Slic3r::Emboss::heal_polygons(), Slic3r::NSVGLineParams::max_heal_iteration, anonymous_namespace{NSVGUtils.cpp}::LinesPath::polygons, Slic3r::polygons_append(), anonymous_namespace{NSVGUtils.cpp}::LinesPath::polylines, and Slic3r::to_polygons().

Here is the call graph for this function:

flatten_cubic_bez()

void anonymous_namespace{NSVGUtils.cpp}::flatten_cubic_bez	(	Points &	points,
		float	tessTol,
		const Vec2f &	p1,
		const Vec2f &	p2,
		const Vec2f &	p3,
		const Vec2f &	p4,
		int	level )

Convert cubic curve to lines Inspired by nanosvgrast.h function nsvgRasterize -> nsvg__flattenShape -> nsvg__flattenCubicBez https://github.com/memononen/nanosvg/blob/f0a3e1034dd22e2e87e5db22401e44998383124e/src/nanosvgrast.h#L335.

Parameters

polygon	Result points
tessTol	Tesselation tolerance
p1	Curve point
p2	Curve point
p3	Curve point
p4	Curve point
level	Actual depth of recursion

{
    if (!need_flattening(tessTol, p1, p2, p3, p4)) {
        Point::coord_type x = static_cast<Point::coord_type>(std::round(p4.x()));
        Point::coord_type y = static_cast<Point::coord_type>(std::round(p4.y()));
        points.emplace_back(x, y);
        return;
    }
 
    --level;
    if (level == 0)
        return;
    
    Vec2f p12  = (p1 + p2) * 0.5f;
    Vec2f p23  = (p2 + p3) * 0.5f;
    Vec2f p34  = (p3 + p4) * 0.5f;
    Vec2f p123 = (p12 + p23) * 0.5f;
    Vec2f p234  = (p23 + p34) * 0.5f;
    Vec2f p1234 = (p123 + p234) * 0.5f;
    flatten_cubic_bez(points, tessTol, p1, p12, p123, p1234, level);
    flatten_cubic_bez(points, tessTol, p1234, p234, p34, p4, level);
}

References flatten_cubic_bez(), and need_flattening().

Referenced by flatten_cubic_bez(), and linearize_path().

Here is the call graph for this function:

Here is the caller graph for this function:

is_line()

bool anonymous_namespace{NSVGUtils.cpp}::is_line	(	const float *	p,
		float	precision = 1e-4f )

                                             {
    //Vec2f p1(p[0], p[1]);
    //Vec2f p2(p[2], p[3]);
    //Vec2f p3(p[4], p[5]);
    //Vec2f p4(p[6], p[7]);
    float dx_3 = (p[6] - p[0]) / 3.f;
    float dy_3 = (p[7] - p[1]) / 3.f;
 
    return 
        is_approx(p[2], p[0] + dx_3, precision) && 
        is_approx(p[4], p[6] - dx_3, precision) && 
        is_approx(p[3], p[1] + dy_3, precision) &&
        is_approx(p[5], p[7] - dy_3, precision);
}

References Slic3r::is_approx().

Referenced by linearize_path(), and to_dashes().

Here is the call graph for this function:

Here is the caller graph for this function:

linearize_path()

LinesPath anonymous_namespace{NSVGUtils.cpp}::linearize_path	(	NSVGpath *	first_path,
		const NSVGLineParams &	param )

{
    LinesPath result;
    Polygons  &polygons  = result.polygons;
    Polylines &polylines = result.polylines;
 
    // multiple use of allocated memmory for points between paths
    Points points;
    for (NSVGpath *path = first_path; path != NULL; path = path->next) {
        // Flatten path
        Point::coord_type x = to_coor(path->pts[0], param.scale);
        Point::coord_type y = to_coor(path->pts[1], param.scale);
        points.emplace_back(x, y);
        size_t path_size = (path->npts > 1) ? static_cast<size_t>(path->npts - 1) : 0;
        for (size_t i = 0; i < path_size; i += 3) {
            const float *p = &path->pts[i * 2];
            if (is_line(p)) {
                // point p4
                Point::coord_type xx = to_coor(p[6], param.scale);
                Point::coord_type yy = to_coor(p[7], param.scale);
                points.emplace_back(xx, yy);
                continue;
            }
            Vec2f p1(p[0], p[1]);
            Vec2f p2(p[2], p[3]);
            Vec2f p3(p[4], p[5]);
            Vec2f p4(p[6], p[7]);
            flatten_cubic_bez(points, param.tesselation_tolerance, 
                p1 * param.scale, p2 * param.scale, p3 * param.scale, p4 * param.scale, 
                param.max_level);
        }
        assert(!points.empty());
        if (points.empty()) 
            continue;
 
        if (param.is_y_negative)
            for (Point &p : points)
                p.y() = -p.y();
 
        if (path->closed) {
            polygons.emplace_back(points);
        } else {
            polylines.emplace_back(points);
        }
        // prepare for new path - recycle alocated memory
        points.clear();
    }
    remove_same_neighbor(polygons);
    remove_same_neighbor(polylines);
    return result;
}

References flatten_cubic_bez(), is_line(), Slic3r::NSVGLineParams::is_y_negative, Slic3r::NSVGLineParams::max_level, anonymous_namespace{NSVGUtils.cpp}::LinesPath::polygons, anonymous_namespace{NSVGUtils.cpp}::LinesPath::polylines, Slic3r::remove_same_neighbor(), Slic3r::NSVGLineParams::scale, Slic3r::NSVGLineParams::tesselation_tolerance, and to_coor().

Here is the call graph for this function:

need_flattening()

bool anonymous_namespace{NSVGUtils.cpp}::need_flattening	(	float	tessTol,
		const Vec2f &	p1,
		const Vec2f &	p2,
		const Vec2f &	p3,
		const Vec2f &	p4 )

                                                                                                        {
    // f .. first
    // s .. second
    auto det = [](const Vec2f &f, const Vec2f &s) {
        return std::fabs(f.x() * s.y() - f.y() * s.x()); 
    };
 
    Vec2f pd  = (p4 - p1);
    Vec2f pd2 = (p2 - p4);
    float d2  = det(pd2, pd);
    Vec2f pd3 = (p3 - p4);
    float d3  = det(pd3, pd);
    float d23 = d2 + d3;
 
    return (d23 * d23) >= tessTol * pd.squaredNorm();
}

References Slic3r::f().

Referenced by flatten_cubic_bez().

Here is the call graph for this function:

Here is the caller graph for this function:

stroke_to_expolygons()

HealedExPolygons anonymous_namespace{NSVGUtils.cpp}::stroke_to_expolygons	(	const LinesPath &	lines_path,
		const NSVGshape &	shape,
		const NSVGLineParams &	param )

{
    // convert stroke to polygon
    JoinType join_type = jtSquare;
    switch (static_cast<NSVGlineJoin>(shape.strokeLineJoin)) {
    case NSVGlineJoin::NSVG_JOIN_BEVEL: join_type = jtSquare; break;
    case NSVGlineJoin::NSVG_JOIN_MITER: join_type = jtMiter; break;
    case NSVGlineJoin::NSVG_JOIN_ROUND: join_type = jtRound; break;
    }
 
    double mitter = shape.miterLimit * param.scale;
    if (join_type == jtRound) {
        // mitter is used as ArcTolerance
        // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Classes/ClipperOffset/Properties/ArcTolerance.htm
        mitter = std::pow(param.tesselation_tolerance, 1/3.);
    }
    float stroke_width = static_cast<float>(shape.strokeWidth * param.scale);
 
    EndType end_type = etOpenButt;
    switch (static_cast<NSVGlineCap>(shape.strokeLineCap)) {
    case NSVGlineCap::NSVG_CAP_BUTT: end_type = etOpenButt; break;
    case NSVGlineCap::NSVG_CAP_ROUND: end_type = etOpenRound; break;
    case NSVGlineCap::NSVG_CAP_SQUARE: end_type = etOpenSquare; break;
    }
 
    Polygons result;
    if (shape.strokeDashCount > 0) {
        DashesParam params(shape, param.scale);
        Polylines dashes;
        for (const Polyline &polyline : lines_path.polylines)
            polylines_append(dashes, to_dashes(polyline, params));
        for (const Polygon &polygon : lines_path.polygons)
            polylines_append(dashes, to_dashes(to_polyline(polygon), params));
        result = offset(dashes, stroke_width / 2, join_type, mitter, end_type);
    } else {
        result = contour_to_polygons(lines_path.polygons, stroke_width, join_type, mitter);
        polygons_append(result, offset(lines_path.polylines, stroke_width / 2, join_type, mitter, end_type));    
    }
 
    bool is_non_zero = true;
    return Emboss::heal_polygons(result, is_non_zero, param.max_heal_iteration);
}

References Slic3r::contour_to_polygons(), Slic3r::etOpenButt, Slic3r::etOpenRound, Slic3r::etOpenSquare, Slic3r::Emboss::heal_polygons(), Slic3r::jtMiter, Slic3r::jtRound, Slic3r::jtSquare, Slic3r::NSVGLineParams::max_heal_iteration, Slic3r::offset(), anonymous_namespace{NSVGUtils.cpp}::LinesPath::polygons, Slic3r::polygons_append(), anonymous_namespace{NSVGUtils.cpp}::LinesPath::polylines, Slic3r::polylines_append(), Slic3r::NSVGLineParams::scale, Slic3r::NSVGLineParams::tesselation_tolerance, to_dashes(), and Slic3r::to_polyline().

Here is the call graph for this function:

to_coor()

Point::coord_type anonymous_namespace{NSVGUtils.cpp}::to_coor	(	float	val,
		double	scale )

{ return static_cast<Point::coord_type>(std::round(val * scale)); }

References scale().

Referenced by linearize_path().

Here is the call graph for this function:

Here is the caller graph for this function:

to_dashes()

Polylines anonymous_namespace{NSVGUtils.cpp}::to_dashes	(	const Polyline &	polyline,
		const DashesParam &	param )

{
    Polylines dashes;
    Polyline dash; // cache for one dash in dashed line
    Point prev_point;        
    
    bool is_line = param.is_line;
    unsigned char dash_index = param.dash_index;
    float dash_length = param.dash_length; // current rest of dash distance
    for (const Point &point : polyline.points) {
        if (&point == &polyline.points.front()) {
            // is first point
            prev_point = point; // copy
            continue;
        }
 
        Point diff = point - prev_point;
        float line_segment_length = diff.cast<float>().norm();
        while (dash_length < line_segment_length) {
            // Calculate intermediate point
            float d = dash_length / line_segment_length;
            Point move_point   = diff * d;
            Point intermediate = prev_point + move_point;
            
            // add Dash in stroke
            if (is_line) {
                if (dash.empty()) {
                    dashes.emplace_back(Points{prev_point, intermediate});
                } else {
                    dash.append(prev_point);
                    dash.append(intermediate);
                    dashes.push_back(dash);
                    dash.clear();
                }
            }
 
            diff -= move_point;
            line_segment_length -= dash_length;
            prev_point = intermediate;
 
            // Advance dash pattern
            is_line = !is_line;
            dash_index = (dash_index + 1) % param.dash_count;
            dash_length = param.dash_array[dash_index];
        }
 
        if (is_line)
            dash.append(prev_point);
        dash_length -= line_segment_length;
        prev_point = point; // copy
    }
 
    // add last dash
    if (is_line){
        assert(!dash.empty());
        dash.append(prev_point); // prev_point == polyline.points.back()
        dashes.push_back(dash);
    }
    return dashes;
}

References Slic3r::Polyline::append(), Slic3r::Polyline::clear(), anonymous_namespace{NSVGUtils.cpp}::DashesParam::dash_array, anonymous_namespace{NSVGUtils.cpp}::DashesParam::dash_count, anonymous_namespace{NSVGUtils.cpp}::DashesParam::dash_index, anonymous_namespace{NSVGUtils.cpp}::DashesParam::dash_length, Slic3r::diff(), Slic3r::MultiPoint::empty(), anonymous_namespace{NSVGUtils.cpp}::DashesParam::is_line, is_line(), and Slic3r::MultiPoint::points.

Referenced by stroke_to_expolygons().

Here is the call graph for this function:

Here is the caller graph for this function: