Slic3r::SL1_SVGReader Class Reference

#include <src/libslic3r/Format/SL1_SVG.hpp>

Inheritance diagram for Slic3r::SL1_SVGReader:

Collaboration diagram for Slic3r::SL1_SVGReader:

Public Member Functions
ConfigSubstitutions	read (std::vector< ExPolygons > &slices, DynamicPrintConfig &profile_out) override
ConfigSubstitutions	read (DynamicPrintConfig &profile) override
	SL1_SVGReader ()=default
	SL1_SVGReader (const std::string &fname, SLAImportQuality, const ProgrFn &progr)

Static Public Member Functions
static std::unique_ptr< SLAArchiveReader >	create (const std::string &fname, const std::string &format_id, SLAImportQuality quality=SLAImportQuality::Balanced, const ProgrFn &progr=[](int) { return false;})

Private Attributes
std::function< bool(int)>	m_progr
std::string	m_fname

Detailed Description

Constructor & Destructor Documentation

SL1_SVGReader() [1/2]

Slic3r::SL1_SVGReader::SL1_SVGReader ( )

default

SL1_SVGReader() [2/2]

Slic3r::SL1_SVGReader::SL1_SVGReader ( const std::string &  fname, SLAImportQuality  , const ProgrFn &  progr  )

inline

        : m_progr(progr), m_fname(fname)
    {}

Member Function Documentation

create()

std::unique_ptr< SLAArchiveReader > Slic3r::SLAArchiveReader::create ( const std::string &  fname, const std::string &  format_id, SLAImportQuality  quality = SLAImportQuality::Balanced, const ProgrFn &  progr = [](int) { return false; }  )

staticinherited

{
    // Create an instance of SLAArchiveReader using the registered archive
    // reader implementations.
    // If format_id is specified and valid, that archive format will be
    // preferred. When format_id is emtpy, the file extension is compared
    // with the advertised extensions of registered readers and the first
    // match will be used.
 
    std::string ext = boost::filesystem::path(fname).extension().string();
    boost::algorithm::to_lower(ext);
 
    std::unique_ptr<SLAArchiveReader> ret;
 
    auto registry = registered_sla_archives();
 
    auto arch_from = registry.begin();
    auto arch_to   = registry.end();
 
    auto arch_it = registry.find(ArchiveEntry{format_id.c_str()});
    if (arch_it != registry.end()) {
        arch_from = arch_it;
        arch_to   = arch_it;
    }
 
    if (!ext.empty()) {
        if (ext.front() == '.')
            ext.erase(ext.begin());
 
        for (auto it = arch_from; !ret && it != arch_to; ++it) {
            const auto &entry = *it;
            if (entry.rdfactoryfn) {
                auto extensions = get_extensions(entry);
                for (const std::string& supportedext : extensions) {
                    if (ext == supportedext) {
                        ret = entry.rdfactoryfn(fname, quality, progr);
                        break;
                    }
                }
            }
        }
    }
 
    return ret;
}

References Slic3r::get_extensions(), and Slic3r::registered_sla_archives().

Referenced by Slic3r::import_sla_archive(), and Slic3r::import_sla_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

read() [1/2]

ConfigSubstitutions Slic3r::SL1_SVGReader::read ( DynamicPrintConfig &  profile )

overridevirtual

Implements Slic3r::SLAArchiveReader.

{
    ZipperArchive arch = read_zipper_archive(m_fname, {"prusaslicer.ini"}, {});
    return out.load(arch.profile, ForwardCompatibilitySubstitutionRule::Enable);
}

References Slic3r::Enable, Slic3r::ConfigBase::load(), m_fname, Slic3r::ZipperArchive::profile, and Slic3r::read_zipper_archive().

Here is the call graph for this function:

read() [2/2]

ConfigSubstitutions Slic3r::SL1_SVGReader::read ( std::vector< ExPolygons > &  slices, DynamicPrintConfig &  profile_out  )

overridevirtual

Implements Slic3r::SLAArchiveReader.

{
    std::vector<std::string> includes = { CONFIG_FNAME, PROFILE_FNAME, "svg"};
    ZipperArchive arch = read_zipper_archive(m_fname, includes, {});
    auto [profile_use, config_substitutions] = extract_profile(arch, profile_out);
 
    RasterParams rstp = get_raster_params(profile_use);
 
    struct Status
    {
        double                                 incr, val, prev;
        bool                                   stop  = false;
    } st{100. / arch.entries.size(), 0., 0.};
 
    for (const EntryBuffer &entry : arch.entries) {
        if (st.stop) break;
 
        st.val += st.incr;
        double curr = std::round(st.val);
        if (curr > st.prev) {
            st.prev = curr;
            st.stop = !m_progr(int(curr));
        }
 
        // Don't want to use dirty casts for the buffer to be usable in
        // the NanoSVGParser until performance is not a bottleneck here.
        auto svgtxt = reserve_vector<char>(entry.buf.size() + 1);
        std::copy(entry.buf.begin(), entry.buf.end(), std::back_inserter(svgtxt));
        svgtxt.emplace_back('\0');
        NanoSVGParser svgp(svgtxt.data());
 
        Polygons polys;
        for (NSVGshape *shape = svgp.image->shapes; shape != nullptr; shape = shape->next) {
            for (NSVGpath *path = shape->paths; path != nullptr; path = path->next) {
                Polygon p;
                for (int i = 0; i < path->npts; ++i) {
                    size_t c = 2 * i;
                    p.points.emplace_back(scaled(Vec2f(path->pts[c], path->pts[c + 1])));
                }
                polys.emplace_back(p);
            }
        }
 
        // Create the slice from the read polygons. Here, the fill rule has to
        // be the same as stated in the svg file which is `nonzero` when exported
        // using SL1_SVGArchive. Would be better to parse it from the svg file,
        // but if it's different, the file is probably corrupted anyways.
        ExPolygons expolys = union_ex(polys, ClipperLib::pftNonZero);
        invert_raster_trafo(expolys, rstp.trafo, rstp.width, rstp.height);
        slices.emplace_back(expolys);
    }
 
    // Compile error without the move
    return std::move(config_substitutions);
}

References Slic3r::CONFIG_FNAME, Slic3r::ZipperArchive::entries, Slic3r::extract_profile(), Slic3r::get_raster_params(), Slic3r::RasterParams::height, Slic3r::NanoSVGParser::image, Slic3r::invert_raster_trafo(), m_fname, m_progr, ClipperLib::pftNonZero, Slic3r::MultiPoint::points, Slic3r::PROFILE_FNAME, Slic3r::read_zipper_archive(), Slic3r::scaled(), Slic3r::RasterParams::trafo, Slic3r::union_ex(), and Slic3r::RasterParams::width.

Here is the call graph for this function:

Member Data Documentation

m_fname

std::string Slic3r::SL1_SVGReader::m_fname

private

Referenced by read(), and read().

m_progr

std::function<bool(int)> Slic3r::SL1_SVGReader::m_progr

private

Referenced by read().

---

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

• src/libslic3r/Format/SL1_SVG.hpp
• src/libslic3r/Format/SL1_SVG.cpp