Slic3r::SVGRaster Class Reference

Inheritance diagram for Slic3r::SVGRaster:

Collaboration diagram for Slic3r::SVGRaster:

Public Types
enum	Orientation { roLandscape , roPortrait }
using	TMirroring = std::array< bool, 2 >

Public Member Functions
	SVGRaster (const BoundingBox &svgarea, sla::Resolution res, Trafo tr={})
void	draw (const ExPolygon &poly) override
	Draw a polygon with holes.
Trafo	trafo () const override
	Get the resolution of the raster.
sla::EncodedRaster	encode (sla::RasterEncoder) const override

Static Public Attributes
static const constexpr TMirroring	NoMirror = {false, false}
static const constexpr TMirroring	MirrorX = {true, false}
static const constexpr TMirroring	MirrorY = {false, true}
static const constexpr TMirroring	MirrorXY = {true, true}

Private Attributes
BoundingBox	m_bb
sla::Resolution	m_res
Trafo	m_trafo
Vec2d	m_sc
std::string	m_svg

Detailed Description

Member Typedef Documentation

TMirroring

using Slic3r::sla::RasterBase::TMirroring = std::array<bool, 2>

inherited

Member Enumeration Documentation

Orientation

enum Slic3r::sla::RasterBase::Orientation

inherited

Enumerator
roLandscape
roPortrait

{ roLandscape, roPortrait };

Constructor & Destructor Documentation

SVGRaster()

Slic3r::SVGRaster::SVGRaster ( const BoundingBox &  svgarea, sla::Resolution  res, Trafo  tr = {}  )

inline

                                                                        {})
        : m_bb{svgarea}
        , m_res{res}
        , m_trafo{tr}
        , m_sc{double(m_res.width_px) / m_bb.size().x(), double(m_res.height_px) / m_bb.size().y()}
    {
        // Inside the svg header, the boundaries will be defined in mm to
        // the actual bed size. The viewport is then defined to work with our
        // scaled coordinates. All the exported polygons will be in these scaled
        // coordinates but svg rendering software will interpret them correctly
        // in mm due to the header's definition.
        std::string wf = float_to_string_decimal_point(unscaled<float>(m_bb.size().x()));
        std::string hf = float_to_string_decimal_point(unscaled<float>(m_bb.size().y()));
        std::string w  = coord2str(coord_t(m_res.width_px));
        std::string h  = coord2str(coord_t(m_res.height_px));
 
        // Notice the header also defines the fill-rule as nonzero which should
        // generate correct results for our ExPolygons.
 
        // Add svg header.
        m_svg =
            "<?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=\"" + hf + "mm" + "\" width=\"" + wf + "mm" + "\" viewBox=\"0 0 " + w + " " + h +
            "\" style=\"fill: white; stroke: none; fill-rule: nonzero\" "
            "xmlns=\"http://www.w3.org/2000/svg\" xmlns:svg=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n";
    }

Member Function Documentation

draw()

void Slic3r::SVGRaster::draw ( const ExPolygon &  poly )

inlineoverridevirtual

Draw a polygon with holes.

Implements Slic3r::sla::RasterBase.

    {
        auto cpoly = poly;
 
        double tol = std::min(m_bb.size().x() / double(m_res.width_px),
                              m_bb.size().y() / double(m_res.height_px));
 
        ExPolygons cpolys = poly.simplify(tol);
 
        for (auto &cpoly : cpolys) {
            transform(cpoly, m_trafo, m_bb);
 
            for (auto &p : cpoly.contour.points)
                p = {std::round(p.x() * m_sc.x()), std::round(p.y() * m_sc.y())};
 
            for (auto &h : cpoly.holes)
                for (auto &p : h)
                    p = {std::round(p.x() * m_sc.x()), std::round(p.y() * m_sc.y())};
 
            append_svg(m_svg, cpoly.contour);
            for (auto &h : cpoly.holes)
                append_svg(m_svg, h);
        }
    }

References Slic3r::sla::Resolution::height_px, m_bb, m_res, m_sc, m_svg, m_trafo, Slic3r::ExPolygon::simplify(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::transform(), and Slic3r::sla::Resolution::width_px.

Here is the call graph for this function:

encode()

sla::EncodedRaster Slic3r::SVGRaster::encode ( sla::RasterEncoder  ) const

inlineoverridevirtual

Implements Slic3r::sla::RasterBase.

    {
        std::vector<uint8_t> data;
        constexpr auto finish = "</svg>\n"sv;
 
        data.reserve(m_svg.size() + std::size(finish));
 
        std::copy(m_svg.begin(), m_svg.end(), std::back_inserter(data));
        std::copy(finish.begin(), finish.end() - 1, std::back_inserter(data));
 
        return sla::EncodedRaster{std::move(data), "svg"};
    }

References m_svg.

trafo()

Trafo Slic3r::SVGRaster::trafo ( ) const

inlineoverridevirtual

Get the resolution of the raster.

Implements Slic3r::sla::RasterBase.

{ return m_trafo; }

References m_trafo.

Member Data Documentation

m_bb

BoundingBox Slic3r::SVGRaster::m_bb

private

Referenced by draw().

m_res

sla::Resolution Slic3r::SVGRaster::m_res

private

Referenced by draw().

m_sc

Vec2d Slic3r::SVGRaster::m_sc

private

Referenced by draw().

m_svg

std::string Slic3r::SVGRaster::m_svg

private

Referenced by draw(), and encode().

m_trafo

Trafo Slic3r::SVGRaster::m_trafo

private

Referenced by draw(), and trafo().

MirrorX

const constexpr TMirroring Slic3r::sla::RasterBase::MirrorX = {true, false}

staticconstexprinherited

MirrorXY

const constexpr TMirroring Slic3r::sla::RasterBase::MirrorXY = {true, true}

staticconstexprinherited

MirrorY

const constexpr TMirroring Slic3r::sla::RasterBase::MirrorY = {false, true}

staticconstexprinherited

NoMirror

const constexpr TMirroring Slic3r::sla::RasterBase::NoMirror = {false, false}

staticconstexprinherited

---

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

• src/libslic3r/Format/SL1_SVG.cpp