Slic3r::SVG Class Reference

#include <src/libslic3r/SVG.hpp>

Collaboration diagram for Slic3r::SVG:

Classes
struct	ExPolygonAttributes

Public Member Functions
	SVG (const char *afilename)
	SVG (const char *afilename, const BoundingBox &bbox, const coord_t bbox_offset=scale_(1.), bool flipY=true)
	SVG (const std::string &filename)
	SVG (const std::string &filename, const BoundingBox &bbox, const coord_t bbox_offset=scale_(1.), bool flipY=true)
	~SVG ()
bool	open (const char *filename)
bool	open (const char *filename, const BoundingBox &bbox, const coord_t bbox_offset=scale_(1.), bool flipY=true)
bool	open (const std::string &filename)
bool	open (const std::string &filename, const BoundingBox &bbox, const coord_t bbox_offset=scale_(1.), bool flipY=true)
void	draw (const Line &line, std::string stroke="black", coordf_t stroke_width=0)
void	draw (const ThickLine &line, const std::string &fill, const std::string &stroke, coordf_t stroke_width=0)
void	draw (const Lines &lines, std::string stroke="black", coordf_t stroke_width=0)
void	draw (const ExPolygon &expolygon, std::string fill="grey", const float fill_opacity=1.f)
void	draw_outline (const ExPolygon &polygon, std::string stroke_outer="black", std::string stroke_holes="blue", coordf_t stroke_width=0)
void	draw (const ExPolygons &expolygons, std::string fill="grey", const float fill_opacity=1.f)
void	draw_outline (const ExPolygons &polygons, std::string stroke_outer="black", std::string stroke_holes="blue", coordf_t stroke_width=0)
void	draw (const Surface &surface, std::string fill="grey", const float fill_opacity=1.f)
void	draw_outline (const Surface &surface, std::string stroke_outer="black", std::string stroke_holes="blue", coordf_t stroke_width=0)
void	draw (const Surfaces &surfaces, std::string fill="grey", const float fill_opacity=1.f)
void	draw_outline (const Surfaces &surfaces, std::string stroke_outer="black", std::string stroke_holes="blue", coordf_t stroke_width=0)
void	draw (const SurfacesPtr &surfaces, std::string fill="grey", const float fill_opacity=1.f)
void	draw_outline (const SurfacesPtr &surfaces, std::string stroke_outer="black", std::string stroke_holes="blue", coordf_t stroke_width=0)
void	draw (const Polygon &polygon, std::string fill="grey")
void	draw_outline (const Polygon &polygon, std::string stroke="black", coordf_t stroke_width=0)
void	draw (const Polygons &polygons, std::string fill="grey")
void	draw_outline (const Polygons &polygons, std::string stroke="black", coordf_t stroke_width=0)
void	draw (const Polyline &polyline, std::string stroke="black", coordf_t stroke_width=0)
void	draw (const Polylines &polylines, std::string stroke="black", coordf_t stroke_width=0)
void	draw (const ThickLines &thicklines, const std::string &fill="lime", const std::string &stroke="black", coordf_t stroke_width=0)
void	draw (const ThickPolylines &polylines, const std::string &stroke="black", coordf_t stroke_width=0)
void	draw (const ThickPolylines &thickpolylines, const std::string &fill, const std::string &stroke, coordf_t stroke_width)
void	draw (const Point &point, std::string fill="black", coord_t radius=0)
void	draw (const Points &points, std::string fill="black", coord_t radius=0)
void	draw (const ClipperLib::Path &polygon, double scale, std::string fill="grey", coordf_t stroke_width=0)
void	draw (const ClipperLib::Paths &polygons, double scale, std::string fill="grey", coordf_t stroke_width=0)
void	draw_text (const Point &pt, const char *text, const char *color, coordf_t font_size=20.f)
void	draw_legend (const Point &pt, const char *text, const char *color, coordf_t font_size=10.f)
void	Close ()

Static Public Member Functions
static void	export_expolygons (const char *path, const BoundingBox &bbox, const Slic3r::ExPolygons &expolygons, std::string stroke_outer="black", std::string stroke_holes="blue", coordf_t stroke_width=0)
static void	export_expolygons (const std::string &path, const BoundingBox &bbox, const Slic3r::ExPolygons &expolygons, std::string stroke_outer="black", std::string stroke_holes="blue", coordf_t stroke_width=0)
static void	export_expolygons (const char *path, const Slic3r::ExPolygons &expolygons, std::string stroke_outer="black", std::string stroke_holes="blue", coordf_t stroke_width=0)
static void	export_expolygons (const std::string &path, const Slic3r::ExPolygons &expolygons, std::string stroke_outer="black", std::string stroke_holes="blue", coordf_t stroke_width=0)
static void	export_expolygons (const char *path, const std::vector< std::pair< Slic3r::ExPolygons, ExPolygonAttributes > > &expolygons_with_attributes)
static void	export_expolygons (const std::string &path, const std::vector< std::pair< Slic3r::ExPolygons, ExPolygonAttributes > > &expolygons_with_attributes)

Public Attributes
bool	arrows
std::string	fill
std::string	stroke
Point	origin
float	height
bool	flipY

Private Member Functions
void	path (const std::string &d, bool fill, coordf_t stroke_width, const float fill_opacity)
std::string	get_path_d (const MultiPoint &mp, bool closed=false) const
std::string	get_path_d (const ClipperLib::Path &mp, double scale, bool closed=false) const
float	to_svg_y (float x) const throw ()

Static Private Member Functions
static float	to_svg_coord (float x) throw ()
static float	to_svg_x (float x) throw ()

Private Attributes
std::string	filename
FILE *	f

Detailed Description

Constructor & Destructor Documentation

SVG() [1/4]

Slic3r::SVG::SVG ( const char *  afilename )

inline

                               :
        arrows(false), fill("grey"), stroke("black"), filename(afilename), flipY(false)
        { open(filename); }

References filename, and open().

Here is the call graph for this function:

SVG() [2/4]

Slic3r::SVG::SVG ( const char *  afilename, const BoundingBox &  bbox, const coord_t  bbox_offset = scale_(1.), bool  flipY = true  )

inline

                                                                                                                   : 
        arrows(false), fill("grey"), stroke("black"), filename(afilename), origin(bbox.min - Point(bbox_offset, bbox_offset)), flipY(flipY)
        { open(filename, bbox, bbox_offset, flipY); }

References filename, flipY, and open().

Here is the call graph for this function:

SVG() [3/4]

Slic3r::SVG::SVG ( const std::string &  filename )

inline

                                   :
        arrows(false), fill("grey"), stroke("black"), filename(filename), flipY(false)
        { open(filename); }

References filename, and open().

Here is the call graph for this function:

SVG() [4/4]

Slic3r::SVG::SVG ( const std::string &  filename, const BoundingBox &  bbox, const coord_t  bbox_offset = scale_(1.), bool  flipY = true  )

inline

                                                                                                                       : 
        arrows(false), fill("grey"), stroke("black"), filename(filename), origin(bbox.min - Point(bbox_offset, bbox_offset)), flipY(flipY)
        { open(filename, bbox, bbox_offset, flipY); }

References filename, flipY, and open().

Here is the call graph for this function:

~SVG()

Slic3r::SVG::~SVG ( )

inline

{ if (f != NULL) Close(); }

References Close(), and f.

Here is the call graph for this function:

Member Function Documentation

Close()

void Slic3r::SVG::Close

(

)

{
    fprintf(this->f, "</svg>\n");
    fclose(this->f);
    this->f = NULL;
//    printf("SVG written to %s\n", this->filename.c_str());
}

References f.

Referenced by ~SVG(), Slic3r::contour_distance(), Slic3r::sla::anonymous_namespace{Pad.cpp}::create_pad_geometry(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::dump_voronoi_to_svg(), export_expolygons(), export_expolygons(), Slic3r::export_intersections_to_svg(), Slic3r::FFFSupport::export_print_z_polygons_and_extrusions_to_svg(), Slic3r::FFFSupport::export_print_z_polygons_to_svg(), Slic3r::LayerRegion::export_region_fill_surfaces_to_svg(), Slic3r::Layer::export_region_fill_surfaces_to_svg(), Slic3r::LayerRegion::export_region_slices_to_svg(), Slic3r::Layer::export_region_slices_to_svg(), Slic3r::SurfaceCollection::export_to_svg(), Slic3r::export_to_svg(), Slic3r::SupportGridPattern::extract_support(), Slic3r::FillRectilinear::fill_surface_by_lines(), Slic3r::generate_extra_perimeters_over_overhangs(), Slic3r::make_loops(), Slic3r::Algorithm::merge_expansions_into_expolygons(), Slic3r::FFFSupport::modulate_extrusion_by_overlapping_layers(), and Slic3r::slice_mesh().

Here is the caller graph for this function:

draw() [1/19]

void Slic3r::SVG::draw	(	const ClipperLib::Path &	polygon,
		double	scale,
		std::string	fill = "grey",
		coordf_t	stroke_width = 0
	)

{
    this->stroke = stroke;
    this->path(this->get_path_d(polygon, scale, true), false, stroke_width, 1.f);
}

References get_path_d(), path(), scale(), and stroke.

Here is the call graph for this function:

draw() [2/19]

void Slic3r::SVG::draw	(	const ClipperLib::Paths &	polygons,
		double	scale,
		std::string	fill = "grey",
		coordf_t	stroke_width = 0
	)

{
    for (ClipperLib::Paths::const_iterator it = polygons.begin(); it != polygons.end(); ++ it)
        draw(*it, scale, stroke, stroke_width);
}

References draw(), scale(), and stroke.

Here is the call graph for this function:

draw() [3/19]

void Slic3r::SVG::draw	(	const ExPolygon &	expolygon,
		std::string	fill = "grey",
		const float	fill_opacity = 1.f
	)

{
    this->fill = fill;
    
    std::string d;
    for (const Polygon &p : to_polygons(expolygon))
        d += this->get_path_d(p, true) + " ";
    this->path(d, true, 0, fill_opacity);
}

References fill, get_path_d(), path(), and Slic3r::to_polygons().

Here is the call graph for this function:

draw() [4/19]

void Slic3r::SVG::draw	(	const ExPolygons &	expolygons,
		std::string	fill = "grey",
		const float	fill_opacity = 1.f
	)

{
    for (ExPolygons::const_iterator it = expolygons.begin(); it != expolygons.end(); ++it)
        this->draw(*it, fill, fill_opacity);
}

References draw(), and fill.

Here is the call graph for this function:

draw() [5/19]

void Slic3r::SVG::draw	(	const Line &	line,
		std::string	stroke = "black",
		coordf_t	stroke_width = 0
	)

{
    fprintf(this->f,
        "   <line x1=\"%f\" y1=\"%f\" x2=\"%f\" y2=\"%f\" style=\"stroke: %s; stroke-width: %f\"",
        to_svg_x(line.a(0) - origin(0)), to_svg_y(line.a(1) - origin(1)), to_svg_x(line.b(0) - origin(0)), to_svg_y(line.b(1) - origin(1)), stroke.c_str(), (stroke_width == 0) ? 1.f : to_svg_coord(stroke_width));
    if (this->arrows)
        fprintf(this->f, " marker-end=\"url(#endArrow)\"");
    fprintf(this->f, "/>\n");
}

References Slic3r::Line::a, arrows, Slic3r::Line::b, f, origin, stroke, to_svg_coord(), to_svg_x(), and to_svg_y().

Referenced by Slic3r::ExPolygon::contains(), Slic3r::contour_distance(), Slic3r::contour_distance2(), Slic3r::sla::anonymous_namespace{Pad.cpp}::create_pad_geometry(), Slic3r::detect_overhangs(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::MultiPoint::douglas_peucker(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), Slic3r::dump_voronoi_to_svg(), Slic3r::expolygons_to_zpaths_shrunk(), export_expolygons(), export_expolygons(), Slic3r::export_intersections_to_svg(), Slic3r::FFFSupport::export_print_z_polygons_and_extrusions_to_svg(), Slic3r::FFFSupport::export_print_z_polygons_to_svg(), Slic3r::LayerRegion::export_region_fill_surfaces_to_svg(), Slic3r::Layer::export_region_fill_surfaces_to_svg(), Slic3r::LayerRegion::export_region_slices_to_svg(), Slic3r::Layer::export_region_slices_to_svg(), Slic3r::SurfaceCollection::export_to_svg(), Slic3r::export_to_svg(), Slic3r::SupportGridPattern::extract_support(), Slic3r::FillRectilinear::fill_surface_by_lines(), Slic3r::generate_extra_perimeters_over_overhangs(), Slic3r::line_rounded_thick_segment_collision(), Slic3r::make_loops(), Slic3r::mark_boundary_segments_touching_infill(), Slic3r::Algorithm::merge_expansions_into_expolygons(), Slic3r::mittered_offset_path_scaled(), Slic3r::FFFSupport::modulate_extrusion_by_overlapping_layers(), Slic3r::ExPolygon::overlaps(), priv::select_patches(), Slic3r::slice_mesh(), Slic3r::slice_region_by_vertical_lines(), Slic3r::Arachne::WallToolPaths::stitchToolPaths(), Slic3r::sla::SupportPointGenerator::uniformly_cover(), and priv::visualize_heal().

Here is the call graph for this function:

Here is the caller graph for this function:

draw() [6/19]

void Slic3r::SVG::draw	(	const Lines &	lines,
		std::string	stroke = "black",
		coordf_t	stroke_width = 0
	)

{
    for (const Line &l : lines)
        this->draw(l, stroke, stroke_width);
}

References draw(), and stroke.

Here is the call graph for this function:

draw() [7/19]

void Slic3r::SVG::draw	(	const Point &	point,
		std::string	fill = "black",
		coord_t	radius = 0
	)

{
    float radius = (iradius == 0) ? 3.f : to_svg_coord(iradius);
    std::ostringstream svg;
    svg << "   <circle cx=\"" << to_svg_x(point(0) - origin(0)) << "\" cy=\"" << to_svg_y(point(1) - origin(1))
        << "\" r=\"" << radius << "\" "
        << "style=\"stroke: none; fill: " << fill << "\" />";
    
    fprintf(this->f, "%s\n", svg.str().c_str());
}

References f, fill, origin, to_svg_coord(), to_svg_x(), and to_svg_y().

Here is the call graph for this function:

draw() [8/19]

void Slic3r::SVG::draw	(	const Points &	points,
		std::string	fill = "black",
		coord_t	radius = 0
	)

{
    for (Points::const_iterator it = points.begin(); it != points.end(); ++it)
        this->draw(*it, fill, radius);
}

References draw(), and fill.

Here is the call graph for this function:

draw() [9/19]

void Slic3r::SVG::draw	(	const Polygon &	polygon,
		std::string	fill = "grey"
	)

{
    this->fill = fill;
    this->path(this->get_path_d(polygon, true), !fill.empty(), 0, 1.f);
}

References fill, get_path_d(), and path().

Here is the call graph for this function:

draw() [10/19]

void Slic3r::SVG::draw	(	const Polygons &	polygons,
		std::string	fill = "grey"
	)

{
    for (Polygons::const_iterator it = polygons.begin(); it != polygons.end(); ++it)
        this->draw(*it, fill);
}

References draw(), and fill.

Here is the call graph for this function:

draw() [11/19]

void Slic3r::SVG::draw	(	const Polyline &	polyline,
		std::string	stroke = "black",
		coordf_t	stroke_width = 0
	)

{
    this->stroke = stroke;
    this->path(this->get_path_d(polyline, false), false, stroke_width, 1.f);
}

References get_path_d(), path(), and stroke.

Here is the call graph for this function:

draw() [12/19]

void Slic3r::SVG::draw	(	const Polylines &	polylines,
		std::string	stroke = "black",
		coordf_t	stroke_width = 0
	)

{
    for (Polylines::const_iterator it = polylines.begin(); it != polylines.end(); ++it)
        this->draw(*it, stroke, stroke_width);
}

References draw(), and stroke.

Here is the call graph for this function:

draw() [13/19]

void Slic3r::SVG::draw	(	const Surface &	surface,
		std::string	fill = "grey",
		const float	fill_opacity = 1.f
	)

{
    draw(surface.expolygon, fill, fill_opacity);
}

References draw(), Slic3r::Surface::expolygon, and fill.

Here is the call graph for this function:

draw() [14/19]

void Slic3r::SVG::draw	(	const Surfaces &	surfaces,
		std::string	fill = "grey",
		const float	fill_opacity = 1.f
	)

{
    for (Surfaces::const_iterator it = surfaces.begin(); it != surfaces.end(); ++it)
        this->draw(*it, fill, fill_opacity);
}

References draw(), and fill.

Here is the call graph for this function:

draw() [15/19]

void Slic3r::SVG::draw	(	const SurfacesPtr &	surfaces,
		std::string	fill = "grey",
		const float	fill_opacity = 1.f
	)

{
    for (SurfacesPtr::const_iterator it = surfaces.begin(); it != surfaces.end(); ++it)
        this->draw(*(*it), fill, fill_opacity);
}

References draw(), and fill.

Here is the call graph for this function:

draw() [16/19]

void Slic3r::SVG::draw	(	const ThickLine &	line,
		const std::string &	fill,
		const std::string &	stroke,
		coordf_t	stroke_width = 0
	)

{
    Vec2d dir(line.b(0)-line.a(0), line.b(1)-line.a(1));
    Vec2d perp(-dir(1), dir(0));
    coordf_t len = sqrt(perp(0)*perp(0) + perp(1)*perp(1));
    coordf_t da  = coordf_t(0.5)*line.a_width/len;
    coordf_t db  = coordf_t(0.5)*line.b_width/len;
    fprintf(this->f,
        "   <polygon points=\"%f,%f %f,%f %f,%f %f,%f\" style=\"fill:%s; stroke: %s; stroke-width: %f\"/>\n",
        to_svg_x(line.a(0)-da*perp(0)-origin(0)),
        to_svg_y(line.a(1)-da*perp(1)-origin(1)),
        to_svg_x(line.b(0)-db*perp(0)-origin(0)),
        to_svg_y(line.b(1)-db*perp(1)-origin(1)),
        to_svg_x(line.b(0)+db*perp(0)-origin(0)),
        to_svg_y(line.b(1)+db*perp(1)-origin(1)),
        to_svg_x(line.a(0)+da*perp(0)-origin(0)),
        to_svg_y(line.a(1)+da*perp(1)-origin(1)),
        fill.c_str(), stroke.c_str(),
        (stroke_width == 0) ? 1.f : to_svg_coord(stroke_width));
}

References Slic3r::Line::a, Slic3r::ThickLine::a_width, Slic3r::Line::b, Slic3r::ThickLine::b_width, f, fill, origin, Slic3r::perp(), sqrt(), stroke, to_svg_coord(), to_svg_x(), and to_svg_y().

Here is the call graph for this function:

draw() [17/19]

void Slic3r::SVG::draw	(	const ThickLines &	thicklines,
		const std::string &	fill = "lime",
		const std::string &	stroke = "black",
		coordf_t	stroke_width = 0
	)

{
    for (ThickLines::const_iterator it = thicklines.begin(); it != thicklines.end(); ++it)
        this->draw(*it, fill, stroke, stroke_width);
}

References draw(), fill, and stroke.

Here is the call graph for this function:

draw() [18/19]

void Slic3r::SVG::draw	(	const ThickPolylines &	polylines,
		const std::string &	stroke = "black",
		coordf_t	stroke_width = 0
	)

{
    for (const ThickPolyline &pl : polylines)
        this->draw(Polyline(pl.points), stroke, stroke_width);
}

References draw(), and stroke.

Here is the call graph for this function:

draw() [19/19]

void Slic3r::SVG::draw	(	const ThickPolylines &	thickpolylines,
		const std::string &	fill,
		const std::string &	stroke,
		coordf_t	stroke_width
	)

{
    for (ThickPolylines::const_iterator it = thickpolylines.begin(); it != thickpolylines.end(); ++ it)
        draw(it->thicklines(), fill, stroke, stroke_width);
}

References draw(), fill, and stroke.

Here is the call graph for this function:

draw_legend()

void Slic3r::SVG::draw_legend	(	const Point &	pt,
		const char *	text,
		const char *	color,
		coordf_t	font_size = 10.f
	)

{
    fprintf(this->f,
        R"(<circle cx="%f" cy="%f" r="%f" fill="%s"/>)",
        to_svg_x(float(pt.x() - origin.x())),
        to_svg_y(float(pt.y() - origin.y())),
        font_size,
        color);
    fprintf(this->f,
        R"(<text x="%f" y="%f" font-family="sans-serif" font-size="%fpx" fill="%s">%s</text>)",
        to_svg_x(float(pt.x() - origin.x())) + 20.f,
        to_svg_y(float(pt.y() - origin.y())),
        font_size,
        "black", text);
}

References f, origin, to_svg_x(), and to_svg_y().

Referenced by export_expolygons(), Slic3r::FFFSupport::export_support_surface_type_legend_to_svg(), and Slic3r::export_surface_type_legend_to_svg().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_outline() [1/7]

void Slic3r::SVG::draw_outline	(	const ExPolygon &	polygon,
		std::string	stroke_outer = "black",
		std::string	stroke_holes = "blue",
		coordf_t	stroke_width = 0
	)

{
    draw_outline(expolygon.contour, stroke_outer, stroke_width);
    for (Polygons::const_iterator it = expolygon.holes.begin(); it != expolygon.holes.end(); ++ it) {
        draw_outline(*it, stroke_holes, stroke_width);
    }
}

References Slic3r::ExPolygon::contour, draw_outline(), and Slic3r::ExPolygon::holes.

Referenced by Slic3r::Arachne::SkeletalTrapezoidation::constructFromPolygons(), Slic3r::ExPolygon::contains(), Slic3r::contour_distance(), Slic3r::contour_distance2(), Slic3r::PrintObject::discover_vertical_shells(), draw_outline(), draw_outline(), draw_outline(), draw_outline(), draw_outline(), draw_outline(), Slic3r::dump_voronoi_to_svg(), export_expolygons(), export_expolygons(), Slic3r::export_intersections_to_svg(), Slic3r::LayerRegion::export_region_fill_surfaces_to_svg(), Slic3r::SupportGridPattern::extract_support(), Slic3r::Algorithm::merge_expansions_into_expolygons(), Slic3r::mittered_offset_path_scaled(), Slic3r::ExPolygon::overlaps(), Slic3r::slice_mesh(), Slic3r::slice_region_by_vertical_lines(), and Slic3r::Arachne::WallToolPaths::stitchToolPaths().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_outline() [2/7]

void Slic3r::SVG::draw_outline	(	const ExPolygons &	polygons,
		std::string	stroke_outer = "black",
		std::string	stroke_holes = "blue",
		coordf_t	stroke_width = 0
	)

{
    for (ExPolygons::const_iterator it = expolygons.begin(); it != expolygons.end(); ++ it)
        draw_outline(*it, stroke_outer, stroke_holes, stroke_width);
}

References draw_outline().

Here is the call graph for this function:

draw_outline() [3/7]

void Slic3r::SVG::draw_outline	(	const Polygon &	polygon,
		std::string	stroke = "black",
		coordf_t	stroke_width = 0
	)

{
    this->stroke = stroke;
    this->path(this->get_path_d(polygon, true), false, stroke_width, 1.f);
}

References get_path_d(), path(), and stroke.

Here is the call graph for this function:

draw_outline() [4/7]

void Slic3r::SVG::draw_outline	(	const Polygons &	polygons,
		std::string	stroke = "black",
		coordf_t	stroke_width = 0
	)

{
    for (Polygons::const_iterator it = polygons.begin(); it != polygons.end(); ++ it)
        draw_outline(*it, stroke, stroke_width);
}

References draw_outline(), and stroke.

Here is the call graph for this function:

draw_outline() [5/7]

void Slic3r::SVG::draw_outline	(	const Surface &	surface,
		std::string	stroke_outer = "black",
		std::string	stroke_holes = "blue",
		coordf_t	stroke_width = 0
	)

{
    draw_outline(surface.expolygon, stroke_outer, stroke_holes, stroke_width);
}

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

Here is the call graph for this function:

draw_outline() [6/7]

void Slic3r::SVG::draw_outline	(	const Surfaces &	surfaces,
		std::string	stroke_outer = "black",
		std::string	stroke_holes = "blue",
		coordf_t	stroke_width = 0
	)

{
    for (Surfaces::const_iterator it = surfaces.begin(); it != surfaces.end(); ++ it)
        draw_outline(*it, stroke_outer, stroke_holes, stroke_width);
}

References draw_outline().

Here is the call graph for this function:

draw_outline() [7/7]

void Slic3r::SVG::draw_outline	(	const SurfacesPtr &	surfaces,
		std::string	stroke_outer = "black",
		std::string	stroke_holes = "blue",
		coordf_t	stroke_width = 0
	)

{
    for (SurfacesPtr::const_iterator it = surfaces.begin(); it != surfaces.end(); ++ it)
        draw_outline(*(*it), stroke_outer, stroke_holes, stroke_width);
}

References draw_outline().

Here is the call graph for this function:

draw_text()

void Slic3r::SVG::draw_text	(	const Point &	pt,
		const char *	text,
		const char *	color,
		coordf_t	font_size = 20.f
	)

{
    fprintf(this->f,
        R"(<text x="%f" y="%f" font-family="sans-serif" font-size="%fpx" fill="%s">%s</text>)",
        to_svg_x(float(pt.x() - origin.x())),
        to_svg_y(float(pt.y() - origin.y())),
        font_size,
        color, text);
}

References f, origin, to_svg_x(), and to_svg_y().

Referenced by Slic3r::SurfaceCollection::export_to_svg(), and priv::select_patches().

Here is the call graph for this function:

Here is the caller graph for this function:

export_expolygons() [1/6]

void Slic3r::SVG::export_expolygons ( const char *  path, const BoundingBox &  bbox, const Slic3r::ExPolygons &  expolygons, std::string  stroke_outer = "black", std::string  stroke_holes = "blue", coordf_t  stroke_width = 0  )

static

{
    SVG svg(path, bbox);
    svg.draw(expolygons);
    svg.draw_outline(expolygons, stroke_outer, stroke_holes, stroke_width);
    svg.Close();
}

References Close(), draw(), draw_outline(), and path().

Referenced by Slic3r::detect_overhangs(), Slic3r::elephant_foot_compensation(), export_expolygons(), export_expolygons(), export_expolygons(), export_expolygons(), Slic3r::SupportGridPattern::extract_support(), Slic3r::PrintObjectSupportMaterial::generate(), Slic3r::FFFTreeSupport::generate_overhangs(), Slic3r::FFFTreeSupport::TreeModelVolumes::precalculate(), and Slic3r::FFFSupport::remove_bridges_from_contacts().

Here is the call graph for this function:

Here is the caller graph for this function:

export_expolygons() [2/6]

static void Slic3r::SVG::export_expolygons ( const char *  path, const Slic3r::ExPolygons &  expolygons, std::string  stroke_outer = "black", std::string  stroke_holes = "blue", coordf_t  stroke_width = 0  )

inlinestatic

        { export_expolygons(path, get_extents(expolygons), expolygons, stroke_outer, stroke_holes, stroke_width); }

References export_expolygons(), Slic3r::get_extents(), and path().

Here is the call graph for this function:

export_expolygons() [3/6]

void Slic3r::SVG::export_expolygons ( const char *  path, const std::vector< std::pair< Slic3r::ExPolygons, ExPolygonAttributes > > &  expolygons_with_attributes  )

static

{
    if (expolygons_with_attributes.empty())
        return;
 
    size_t num_legend = std::count_if(expolygons_with_attributes.begin(), expolygons_with_attributes.end(), [](const auto &v){ return ! v.second.legend.empty(); });
    // Format in num_columns.
    size_t num_columns = 3;
    // Width of the column.
    coord_t step_x = scale_(20.);
    Point legend_size(scale_(1.) + num_columns * step_x, scale_(0.4 + 1.3 * (num_legend + num_columns - 1) / num_columns));
 
    BoundingBox bbox = get_extents(expolygons_with_attributes.front().first);
    for (size_t i = 0; i < expolygons_with_attributes.size(); ++ i)
        bbox.merge(get_extents(expolygons_with_attributes[i].first));
    // Legend y.
    coord_t pos_y  = bbox.max.y() + scale_(1.5);
    bbox.merge(Point(std::max(bbox.min.x() + legend_size.x(), bbox.max.x()), bbox.max.y() + legend_size.y()));
 
    SVG svg(path, bbox);
    for (const auto &exp_with_attr : expolygons_with_attributes)
        svg.draw(exp_with_attr.first, exp_with_attr.second.color_fill, exp_with_attr.second.fill_opacity);
    for (const auto &exp_with_attr : expolygons_with_attributes) {
        if (exp_with_attr.second.outline_width > 0) {
            std::string color_contour = exp_with_attr.second.color_contour;
            if (color_contour.empty())
                color_contour = exp_with_attr.second.color_fill;
            std::string color_holes = exp_with_attr.second.color_holes;
            if (color_holes.empty())
                color_holes = color_contour;
            svg.draw_outline(exp_with_attr.first, color_contour, color_holes, exp_with_attr.second.outline_width);
        }
    }
    for (const auto &exp_with_attr : expolygons_with_attributes)
      if (exp_with_attr.second.radius_points > 0)
      for (const ExPolygon &expoly : exp_with_attr.first)
          svg.draw(to_points(expoly), exp_with_attr.second.color_points, exp_with_attr.second.radius_points);
 
    // Export legend.
    // 1st row
    coord_t pos_x0 = bbox.min.x() + scale_(1.);
    coord_t pos_x  = pos_x0;
    size_t  i_legend = 0;
    for (const auto &exp_with_attr : expolygons_with_attributes) {
        if (! exp_with_attr.second.legend.empty()) {
            svg.draw_legend(Point(pos_x, pos_y), exp_with_attr.second.legend.c_str(), exp_with_attr.second.color_fill.c_str());
            if ((++ i_legend) % num_columns == 0) {
                pos_x  = pos_x0;
                pos_y += scale_(1.3);
            } else {
                pos_x += step_x;
            }
        }
    }
    svg.Close();
}

References Close(), draw(), draw_legend(), draw_outline(), Slic3r::get_extents(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, path(), scale_, and Slic3r::to_points().

Here is the call graph for this function:

export_expolygons() [4/6]

static void Slic3r::SVG::export_expolygons ( const std::string &  path, const BoundingBox &  bbox, const Slic3r::ExPolygons &  expolygons, std::string  stroke_outer = "black", std::string  stroke_holes = "blue", coordf_t  stroke_width = 0  )

inlinestatic

        { export_expolygons(path.c_str(), bbox, expolygons, stroke_outer, stroke_holes, stroke_width); }

References export_expolygons(), and path().

Here is the call graph for this function:

export_expolygons() [5/6]

static void Slic3r::SVG::export_expolygons ( const std::string &  path, const Slic3r::ExPolygons &  expolygons, std::string  stroke_outer = "black", std::string  stroke_holes = "blue", coordf_t  stroke_width = 0  )

inlinestatic

        { export_expolygons(path.c_str(), get_extents(expolygons), expolygons, stroke_outer, stroke_holes, stroke_width); }

References export_expolygons(), Slic3r::get_extents(), and path().

Here is the call graph for this function:

export_expolygons() [6/6]

static void Slic3r::SVG::export_expolygons ( const std::string &  path, const std::vector< std::pair< Slic3r::ExPolygons, ExPolygonAttributes > > &  expolygons_with_attributes  )

inlinestatic

        { export_expolygons(path.c_str(), expolygons_with_attributes); }

References export_expolygons(), and path().

Here is the call graph for this function:

get_path_d() [1/2]

std::string Slic3r::SVG::get_path_d ( const ClipperLib::Path &  mp, double  scale, bool  closed = false  ) const

private

{
    std::ostringstream d;
    d << "M ";
    for (ClipperLib::Path::const_iterator p = path.begin(); p != path.end(); ++p) {
        d << to_svg_x(scale * p->x() - origin(0)) << " ";
        d << to_svg_y(scale * p->y() - origin(1)) << " ";
    }
    if (closed) d << "z";
    return d.str();
}

References origin, path(), scale(), to_svg_x(), and to_svg_y().

Here is the call graph for this function:

get_path_d() [2/2]

std::string Slic3r::SVG::get_path_d ( const MultiPoint &  mp, bool  closed = false  ) const

private

{
    std::ostringstream d;
    d << "M ";
    for (Points::const_iterator p = mp.points.begin(); p != mp.points.end(); ++p) {
        d << to_svg_x((*p)(0) - origin(0)) << " ";
        d << to_svg_y((*p)(1) - origin(1)) << " ";
    }
    if (closed) d << "z";
    return d.str();
}

References origin, Slic3r::MultiPoint::points, to_svg_x(), and to_svg_y().

Referenced by draw(), draw(), draw(), draw(), and draw_outline().

Here is the call graph for this function:

Here is the caller graph for this function:

open() [1/4]

bool Slic3r::SVG::open

(

const char *

filename

)

{
    this->filename = afilename;
    this->f = boost::nowide::fopen(afilename, "w");
    if (this->f == NULL)
        return false;
    fprintf(this->f,
        "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n"
        "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\" \"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n"
        "<svg height=\"2000\" width=\"2000\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:svg=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n"
        "   <marker id=\"endArrow\" markerHeight=\"8\" markerUnits=\"strokeWidth\" markerWidth=\"10\" orient=\"auto\" refX=\"1\" refY=\"5\" viewBox=\"0 0 10 10\">\n"
        "      <polyline fill=\"darkblue\" points=\"0,0 10,5 0,10 1,5\" />\n"
        "   </marker>\n"
        );
    fprintf(this->f, "<rect fill='white' stroke='none' x='0' y='0' width='%f' height='%f'/>\n", 2000.f, 2000.f);
    return true;
}

References f, and filename.

Referenced by SVG(), SVG(), SVG(), SVG(), open(), and open().

Here is the caller graph for this function:

open() [2/4]

bool Slic3r::SVG::open	(	const char *	filename,
		const BoundingBox &	bbox,
		const coord_t	bbox_offset = scale_(1.),
		bool	flipY = true
	)

{
    this->filename = afilename;
    this->origin   = bbox.min - Point(bbox_offset, bbox_offset);
    this->flipY    = aflipY;
    this->f        = boost::nowide::fopen(afilename, "w");
    if (f == NULL)
        return false;
    float w = to_svg_coord(bbox.max(0) - bbox.min(0) + 2 * bbox_offset);
    float h = to_svg_coord(bbox.max(1) - bbox.min(1) + 2 * bbox_offset);
    this->height   = h;
    fprintf(this->f,
        "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n"
        "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\" \"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n"
        "<svg height=\"%f\" width=\"%f\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:svg=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n"
        "   <marker id=\"endArrow\" markerHeight=\"8\" markerUnits=\"strokeWidth\" markerWidth=\"10\" orient=\"auto\" refX=\"1\" refY=\"5\" viewBox=\"0 0 10 10\">\n"
        "      <polyline fill=\"darkblue\" points=\"0,0 10,5 0,10 1,5\" />\n"
        "   </marker>\n",
        h, w);
    fprintf(this->f, "<rect fill='white' stroke='none' x='0' y='0' width='%f' height='%f'/>\n", w, h);
    return true;
}

References f, filename, flipY, height, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, origin, and to_svg_coord().

Here is the call graph for this function:

open() [3/4]

bool Slic3r::SVG::open ( const std::string &  filename )

inline

        { return open(filename.c_str()); }

References filename, and open().

Here is the call graph for this function:

open() [4/4]

bool Slic3r::SVG::open ( const std::string &  filename, const BoundingBox &  bbox, const coord_t  bbox_offset = scale_(1.), bool  flipY = true  )

inline

        { return open(filename.c_str(), bbox, bbox_offset, flipY); }

References filename, flipY, and open().

Here is the call graph for this function:

path()

void Slic3r::SVG::path ( const std::string &  d, bool  fill, coordf_t  stroke_width, const float  fill_opacity  )

private

{
    float lineWidth = 0.f;
    if (! fill)
        lineWidth = (stroke_width == 0) ? 2.f : to_svg_coord(stroke_width);
 
    fprintf(
        this->f,
        "   <path d=\"%s\" style=\"fill: %s; stroke: %s; stroke-width: %f; fill-type: evenodd\" %s fill-opacity=\"%f\" />\n",
        d.c_str(),
        fill ? this->fill.c_str() : "none",
        this->stroke.c_str(),
        lineWidth, 
        (this->arrows && !fill) ? " marker-end=\"url(#endArrow)\"" : "",
        fill_opacity
    );
}

References arrows, f, fill, stroke, and to_svg_coord().

Referenced by draw(), draw(), draw(), draw(), draw_outline(), export_expolygons(), export_expolygons(), export_expolygons(), export_expolygons(), export_expolygons(), export_expolygons(), and get_path_d().

Here is the call graph for this function:

Here is the caller graph for this function:

to_svg_coord()

float Slic3r::SVG::to_svg_coord ( float  x ) throw ( )

staticprivate

{
    // return x;
    return unscale<float>(x) * 10.f;
}

Referenced by draw(), draw(), draw(), open(), path(), to_svg_x(), and to_svg_y().

Here is the caller graph for this function:

to_svg_x()

static float Slic3r::SVG::to_svg_x ( float  x ) throw ( )

inlinestaticprivate

{ return to_svg_coord(x); }

References to_svg_coord().

Referenced by draw(), draw(), draw(), draw_legend(), draw_text(), get_path_d(), and get_path_d().

Here is the call graph for this function:

Here is the caller graph for this function:

to_svg_y()

float Slic3r::SVG::to_svg_y ( float  x ) const throw ( )

inlineprivate

{ return flipY ? this->height - to_svg_coord(x) : to_svg_coord(x); }

References flipY, and to_svg_coord().

Referenced by draw(), draw(), draw(), draw_legend(), draw_text(), get_path_d(), and get_path_d().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

arrows

bool Slic3r::SVG::arrows

Referenced by draw(), and path().

f

FILE* Slic3r::SVG::f

private

Referenced by ~SVG(), Close(), draw(), draw(), draw(), draw_legend(), draw_text(), open(), open(), and path().

filename

std::string Slic3r::SVG::filename

private

Referenced by SVG(), SVG(), SVG(), SVG(), open(), open(), open(), and open().

fill

std::string Slic3r::SVG::fill

Referenced by draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), and path().

flipY

bool Slic3r::SVG::flipY

Referenced by SVG(), SVG(), open(), open(), and to_svg_y().

height

float Slic3r::SVG::height

Referenced by open().

origin

Point Slic3r::SVG::origin

Referenced by draw(), draw(), draw(), draw_legend(), draw_text(), get_path_d(), get_path_d(), and open().

stroke

std::string Slic3r::SVG::stroke

Referenced by draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw(), draw_outline(), draw_outline(), and path().

---

The documentation for this class was generated from the following files:

• src/libslic3r/SVG.hpp
• src/libslic3r/SVG.cpp