Slic3r::SL1Reader Class Reference

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

Inheritance diagram for Slic3r::SL1Reader:

Collaboration diagram for Slic3r::SL1Reader:

Public Member Functions
ConfigSubstitutions	read (std::vector< ExPolygons > &slices, DynamicPrintConfig &profile_out) override
ConfigSubstitutions	read (DynamicPrintConfig &profile) override
	SL1Reader ()=default
	SL1Reader (const std::string &fname, SLAImportQuality quality, std::function< bool(int)> 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
SLAImportQuality	m_quality = SLAImportQuality::Balanced
std::function< bool(int)>	m_progr
std::string	m_fname

Detailed Description

Constructor & Destructor Documentation

SL1Reader() [1/2]

Slic3r::SL1Reader::SL1Reader ( )

default

SL1Reader() [2/2]

Slic3r::SL1Reader::SL1Reader ( const std::string &  fname, SLAImportQuality  quality, std::function< bool(int)>  progr  )

inline

        : m_quality(quality), 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::SL1Reader::read ( DynamicPrintConfig &  profile )

overridevirtual

Implements Slic3r::SLAArchiveReader.

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

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

Here is the call graph for this function:

read() [2/2]

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

overridevirtual

Implements Slic3r::SLAArchiveReader.

{
    Vec2i windowsize;
 
    switch(m_quality)
    {
    case SLAImportQuality::Fast: windowsize = {8, 8}; break;
    case SLAImportQuality::Balanced: windowsize = {4, 4}; break;
    default:
    case SLAImportQuality::Accurate:
        windowsize = {2, 2}; break;
    };
 
    // Ensure minimum window size for marching squares
    windowsize.x() = std::max(2, windowsize.x());
    windowsize.y() = std::max(2, windowsize.y());
 
    std::vector<std::string> includes = { "ini", "png"};
    std::vector<std::string> excludes = { "thumbnail" };
    ZipperArchive arch = read_zipper_archive(m_fname, includes, excludes);
    auto [profile_use, config_substitutions] = extract_profile(arch, profile_out);
 
    RasterParams   rstp = get_raster_params(profile_use);
    marchsq::Coord win  = {windowsize.y(), windowsize.x()};
    slices = extract_slices_from_sla_archive(arch, rstp, win, m_progr);
 
    return std::move(config_substitutions);
}

References Slic3r::extract_profile(), Slic3r::get_raster_params(), and Slic3r::read_zipper_archive().

Here is the call graph for this function:

Member Data Documentation

m_fname

std::string Slic3r::SL1Reader::m_fname

private

m_progr

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

private

m_quality

SLAImportQuality Slic3r::SL1Reader::m_quality = SLAImportQuality::Balanced

private

---

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

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