Slic3r::anonymous_namespace{SL1.cpp} Namespace Reference

Classes
struct	PNGBuffer
struct	ArchiveData
struct	RasterParams
struct	SliceParams

Functions
boost::property_tree::ptree	read_ini (const mz_zip_archive_file_stat &entry, MZ_Archive &zip)
PNGBuffer	read_png (const mz_zip_archive_file_stat &entry, MZ_Archive &zip, const std::string &name)
ArchiveData	extract_sla_archive (const std::string &zipfname, const std::string &exclude)
ExPolygons	rings_to_expolygons (const std::vector< marchsq::Ring > &rings, double px_w, double px_h)
template<class Fn>
void	foreach_vertex (ExPolygon &poly, Fn &&fn)
void	invert_raster_trafo (ExPolygons &expolys, const sla::RasterBase::Trafo &trafo, coord_t width, coord_t height)
RasterParams	get_raster_params (const DynamicPrintConfig &cfg)
SliceParams	get_slice_params (const DynamicPrintConfig &cfg)
std::vector< ExPolygons >	extract_slices_from_sla_archive (ArchiveData &arch, const RasterParams &rstp, std::function< bool(int)> progr)
std::string	to_ini (const ConfMap &m)
std::string	get_cfg_value (const DynamicPrintConfig &cfg, const std::string &key)
void	fill_iniconf (ConfMap &m, const SLAPrint &print)
void	fill_slicerconf (ConfMap &m, const SLAPrint &print)

Variables
static const constexpr char *	CONFIG_FNAME = "config.ini"
static const constexpr char *	PROFILE_FNAME = "prusaslicer.ini"

---

Class Documentation

Slic3r::anonymous_namespace{SL1.cpp}::PNGBuffer

struct Slic3r::anonymous_namespace{SL1.cpp}::PNGBuffer

Collaboration diagram for Slic3r::anonymous_namespace{SL1.cpp}::PNGBuffer:

Class Members
vector< uint8_t >	buf
string	fname

Slic3r::anonymous_namespace{SL1.cpp}::ArchiveData

struct Slic3r::anonymous_namespace{SL1.cpp}::ArchiveData

Collaboration diagram for Slic3r::anonymous_namespace{SL1.cpp}::ArchiveData:

Class Members
ptree	config
vector< PNGBuffer >	images
ptree	profile

Slic3r::anonymous_namespace{SL1.cpp}::RasterParams

struct Slic3r::anonymous_namespace{SL1.cpp}::RasterParams

Collaboration diagram for Slic3r::anonymous_namespace{SL1.cpp}::RasterParams:

Class Members
coord_t	height
double	px_h
double	px_w
Trafo	trafo
coord_t	width
Coord	win

Slic3r::anonymous_namespace{SL1.cpp}::SliceParams

struct Slic3r::anonymous_namespace{SL1.cpp}::SliceParams

Class Members
double	initial_layerh = 0.
double	layerh = 0.

Function Documentation

extract_sla_archive()

ArchiveData Slic3r::anonymous_namespace{SL1.cpp}::extract_sla_archive	(	const std::string &	zipfname,
		const std::string &	exclude )

{
    ArchiveData arch;
 
    // Little RAII
    struct Arch: public MZ_Archive {
        Arch(const std::string &fname) {
            if (!open_zip_reader(&arch, fname))
                throw Slic3r::FileIOError(get_errorstr());
        }
 
        ~Arch() { close_zip_reader(&arch); }
    } zip (zipfname);
 
    mz_uint num_entries = mz_zip_reader_get_num_files(&zip.arch);
 
    for (mz_uint i = 0; i < num_entries; ++i)
    {
        mz_zip_archive_file_stat entry;
 
        if (mz_zip_reader_file_stat(&zip.arch, i, &entry))
        {
            std::string name = entry.m_filename;
            boost::algorithm::to_lower(name);
 
            if (boost::algorithm::contains(name, exclude)) continue;
 
            if (name == CONFIG_FNAME) arch.config = read_ini(entry, zip);
            if (name == PROFILE_FNAME) arch.profile = read_ini(entry, zip);
 
            if (boost::filesystem::path(name).extension().string() == ".png") {
                auto it = std::lower_bound(
                    arch.images.begin(), arch.images.end(), PNGBuffer{{}, name},
                    [](const PNGBuffer &r1, const PNGBuffer &r2) {
                        return std::less<std::string>()(r1.fname, r2.fname);
                    });
 
                arch.images.insert(it, read_png(entry, zip, name));
            }
        }
    }
 
    return arch;
}

References Slic3r::close_zip_reader(), Slic3r::anonymous_namespace{SL1.cpp}::ArchiveData::config, CONFIG_FNAME, extract_sla_archive(), Slic3r::anonymous_namespace{SL1.cpp}::PNGBuffer::fname, Slic3r::anonymous_namespace{SL1.cpp}::ArchiveData::images, Slic3r::open_zip_reader(), Slic3r::anonymous_namespace{SL1.cpp}::ArchiveData::profile, PROFILE_FNAME, read_ini(), and read_png().

Referenced by extract_sla_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_slices_from_sla_archive()

std::vector< ExPolygons > Slic3r::anonymous_namespace{SL1.cpp}::extract_slices_from_sla_archive	(	ArchiveData &	arch,
		const RasterParams &	rstp,
		std::function< bool(int)>	progr )

{
    auto jobdir = arch.config.get<std::string>("jobDir");
    for (auto &c : jobdir) c = std::tolower(c);
 
    std::vector<ExPolygons> slices(arch.images.size());
 
    struct Status
    {
        double          incr, val, prev;
        bool            stop = false;
        tbb::spin_mutex mutex = {};
    } st {100. / slices.size(), 0., 0.};
 
    tbb::parallel_for(size_t(0), arch.images.size(),
                     [&arch, &slices, &st, &rstp, progr](size_t i) {
        // Status indication guarded with the spinlock
        {
            std::lock_guard<tbb::spin_mutex> lck(st.mutex);
            if (st.stop) return;
 
            st.val += st.incr;
            double curr = std::round(st.val);
            if (curr > st.prev) {
                st.prev = curr;
                st.stop = !progr(int(curr));
            }
        }
 
        png::ImageGreyscale img;
        png::ReadBuf rb{arch.images[i].buf.data(), arch.images[i].buf.size()};
        if (!png::decode_png(rb, img)) return;
 
        uint8_t isoval = 128;
        auto rings = marchsq::execute(img, isoval, rstp.win);
        ExPolygons expolys = rings_to_expolygons(rings, rstp.px_w, rstp.px_h);
 
        // Invert the raster transformations indicated in the profile metadata
        invert_raster_trafo(expolys, rstp.trafo, rstp.width, rstp.height);
 
        slices[i] = std::move(expolys);
    });
 
    if (st.stop) slices = {};
 
    return slices;
}

References Slic3r::anonymous_namespace{SL1.cpp}::ArchiveData::config, Slic3r::png::decode_png(), marchsq::execute(), extract_slices_from_sla_archive(), Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::height, Slic3r::anonymous_namespace{SL1.cpp}::ArchiveData::images, invert_raster_trafo(), Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::px_h, Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::px_w, rings_to_expolygons(), Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::trafo, Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::width, and Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::win.

Referenced by extract_slices_from_sla_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_iniconf()

void Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf	(	ConfMap &	m,
		const SLAPrint &	print )

{
    CNumericLocalesSetter locales_setter; // for to_string
    auto &cfg = print.full_print_config();
    m["layerHeight"]    = get_cfg_value(cfg, "layer_height");
    m["expTime"]        = get_cfg_value(cfg, "exposure_time");
    m["expTimeFirst"]   = get_cfg_value(cfg, "initial_exposure_time");
    m["expUserProfile"] = get_cfg_value(cfg, "material_print_speed") == "slow" ? "1" : "0";
    m["materialName"]   = get_cfg_value(cfg, "sla_material_settings_id");
    m["printerModel"]   = get_cfg_value(cfg, "printer_model");
    m["printerVariant"] = get_cfg_value(cfg, "printer_variant");
    m["printerProfile"] = get_cfg_value(cfg, "printer_settings_id");
    m["printProfile"]   = get_cfg_value(cfg, "sla_print_settings_id");
    m["fileCreationTimestamp"] = Utils::utc_timestamp();
    m["prusaSlicerVersion"]    = SLIC3R_BUILD_ID;
    
    SLAPrintStatistics stats = print.print_statistics();
    // Set statistics values to the printer
    
    double used_material = (stats.objects_used_material +
                            stats.support_used_material) / 1000;
    
    int num_fade = print.default_object_config().faded_layers.getInt();
    num_fade = num_fade >= 0 ? num_fade : 0;
    
    m["usedMaterial"] = std::to_string(used_material);
    m["numFade"]      = std::to_string(num_fade);
    m["numSlow"]      = std::to_string(stats.slow_layers_count);
    m["numFast"]      = std::to_string(stats.fast_layers_count);
    m["printTime"]    = std::to_string(stats.estimated_print_time);
 
    bool hollow_en = false;
    auto it = print.objects().begin();
    while (!hollow_en && it != print.objects().end())
        hollow_en = (*it++)->config().hollowing_enable;
 
    m["hollow"] = hollow_en ? "1" : "0";
    
    m["action"] = "print";
}

References Slic3r::SLAPrint::default_object_config(), Slic3r::SLAPrintStatistics::estimated_print_time, Slic3r::SLAPrintStatistics::fast_layers_count, fill_iniconf(), Slic3r::PrintBase::full_print_config(), get_cfg_value(), Slic3r::SLAPrint::objects(), Slic3r::SLAPrintStatistics::objects_used_material, Slic3r::SLAPrint::print_statistics(), Slic3r::SLAPrintStatistics::slow_layers_count, Slic3r::SLAPrintStatistics::support_used_material, and Slic3r::Utils::utc_timestamp().

Referenced by fill_iniconf().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_slicerconf()

void Slic3r::anonymous_namespace{SL1.cpp}::fill_slicerconf	(	ConfMap &	m,
		const SLAPrint &	print )

{
    using namespace std::literals::string_view_literals;
    
    // Sorted list of config keys, which shall not be stored into the ini.
    static constexpr auto banned_keys = { 
    "compatible_printers"sv,
        "compatible_prints"sv
    };
    
    assert(std::is_sorted(banned_keys.begin(), banned_keys.end()));
    auto is_banned = [](const std::string &key) {
        return std::binary_search(banned_keys.begin(), banned_keys.end(), key);
    };
    
    auto &cfg = print.full_print_config();
    for (const std::string &key : cfg.keys())
        if (! is_banned(key) && ! cfg.option(key)->is_nil())
            m[key] = cfg.opt_serialize(key);
    
}

References fill_slicerconf(), and Slic3r::PrintBase::full_print_config().

Referenced by fill_slicerconf().

Here is the call graph for this function:

Here is the caller graph for this function:

foreach_vertex()

template<class Fn>

void Slic3r::anonymous_namespace{SL1.cpp}::foreach_vertex	(	ExPolygon &	poly,
		Fn &&	fn )

{
    for (auto &p : poly.contour.points) fn(p);
    for (auto &h : poly.holes)
        for (auto &p : h.points) fn(p);
}

References foreach_vertex().

Referenced by foreach_vertex(), and invert_raster_trafo().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cfg_value()

std::string Slic3r::anonymous_namespace{SL1.cpp}::get_cfg_value	(	const DynamicPrintConfig &	cfg,
		const std::string &	key )

{
    std::string ret;
    
    if (cfg.has(key)) {
        auto opt = cfg.option(key);
        if (opt) ret = opt->serialize();
    }
    
    return ret;    
}

References get_cfg_value(), Slic3r::ConfigOptionResolver::has(), and Slic3r::ConfigBase::option().

Referenced by fill_iniconf(), and get_cfg_value().

Here is the call graph for this function:

Here is the caller graph for this function:

get_raster_params()

RasterParams Slic3r::anonymous_namespace{SL1.cpp}::get_raster_params

(

const DynamicPrintConfig &

cfg

)

{
    auto *opt_disp_cols = cfg.option<ConfigOptionInt>("display_pixels_x");
    auto *opt_disp_rows = cfg.option<ConfigOptionInt>("display_pixels_y");
    auto *opt_disp_w    = cfg.option<ConfigOptionFloat>("display_width");
    auto *opt_disp_h    = cfg.option<ConfigOptionFloat>("display_height");
    auto *opt_mirror_x  = cfg.option<ConfigOptionBool>("display_mirror_x");
    auto *opt_mirror_y  = cfg.option<ConfigOptionBool>("display_mirror_y");
    auto *opt_orient    = cfg.option<ConfigOptionEnum<SLADisplayOrientation>>("display_orientation");
 
    if (!opt_disp_cols || !opt_disp_rows || !opt_disp_w || !opt_disp_h ||
        !opt_mirror_x || !opt_mirror_y || !opt_orient)
        throw MissingProfileError("Invalid SL1 / SL1S file");
 
    RasterParams rstp;
 
    rstp.px_w = opt_disp_w->value / (opt_disp_cols->value - 1);
    rstp.px_h = opt_disp_h->value / (opt_disp_rows->value - 1);
 
    rstp.trafo = sla::RasterBase::Trafo{opt_orient->value == sladoLandscape ?
                                     sla::RasterBase::roLandscape :
                                     sla::RasterBase::roPortrait,
                                 {opt_mirror_x->value, opt_mirror_y->value}};
 
    rstp.height = scaled(opt_disp_h->value);
    rstp.width  = scaled(opt_disp_w->value);
 
    return rstp;
}

References get_raster_params(), Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::height, Slic3r::ConfigBase::option(), Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::px_h, Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::px_w, Slic3r::sla::RasterBase::roLandscape, Slic3r::sla::RasterBase::roPortrait, Slic3r::scaled(), Slic3r::sladoLandscape, Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::trafo, Slic3r::ConfigOptionSingle< T >::value, and Slic3r::anonymous_namespace{SL1.cpp}::RasterParams::width.

Referenced by get_raster_params().

Here is the call graph for this function:

Here is the caller graph for this function:

get_slice_params()

SliceParams Slic3r::anonymous_namespace{SL1.cpp}::get_slice_params

(

const DynamicPrintConfig &

cfg

)

{
    auto *opt_layerh = cfg.option<ConfigOptionFloat>("layer_height");
    auto *opt_init_layerh = cfg.option<ConfigOptionFloat>("initial_layer_height");
 
    if (!opt_layerh || !opt_init_layerh)
        throw MissingProfileError("Invalid SL1 / SL1S file");
 
    return SliceParams{opt_layerh->getFloat(), opt_init_layerh->getFloat()};
}

References get_slice_params(), Slic3r::ConfigOptionFloat::getFloat(), and Slic3r::ConfigBase::option().

Referenced by get_slice_params().

Here is the call graph for this function:

Here is the caller graph for this function:

invert_raster_trafo()

void Slic3r::anonymous_namespace{SL1.cpp}::invert_raster_trafo	(	ExPolygons &	expolys,
		const sla::RasterBase::Trafo &	trafo,
		coord_t	width,
		coord_t	height )

{
    if (trafo.flipXY) std::swap(height, width);
 
    for (auto &expoly : expolys) {
        if (trafo.mirror_y)
            foreach_vertex(expoly, [height](Point &p) {p.y() = height - p.y(); });
 
        if (trafo.mirror_x)
            foreach_vertex(expoly, [width](Point &p) {p.x() = width - p.x(); });
 
        expoly.translate(-trafo.center_x, -trafo.center_y);
 
        if (trafo.flipXY)
            foreach_vertex(expoly, [](Point &p) { std::swap(p.x(), p.y()); });
 
        if ((trafo.mirror_x + trafo.mirror_y + trafo.flipXY) % 2) {
            expoly.contour.reverse();
            for (auto &h : expoly.holes) h.reverse();
        }
    }
}

References Slic3r::sla::RasterBase::Trafo::center_x, Slic3r::sla::RasterBase::Trafo::center_y, Slic3r::sla::RasterBase::Trafo::flipXY, foreach_vertex(), invert_raster_trafo(), Slic3r::sla::RasterBase::Trafo::mirror_x, and Slic3r::sla::RasterBase::Trafo::mirror_y.

Referenced by extract_slices_from_sla_archive(), and invert_raster_trafo().

Here is the call graph for this function:

Here is the caller graph for this function:

read_ini()

boost::property_tree::ptree Slic3r::anonymous_namespace{SL1.cpp}::read_ini	(	const mz_zip_archive_file_stat &	entry,
		MZ_Archive &	zip )

{
    std::string buf(size_t(entry.m_uncomp_size), '\0');
 
    if (!mz_zip_reader_extract_file_to_mem(&zip.arch, entry.m_filename,
                                           buf.data(), buf.size(), 0))
        throw Slic3r::FileIOError(zip.get_errorstr());
 
    boost::property_tree::ptree tree;
    std::stringstream ss(buf);
    boost::property_tree::read_ini(ss, tree);
    return tree;
}

References Slic3r::MZ_Archive::arch, Slic3r::MZ_Archive::get_errorstr(), and read_ini().

Referenced by extract_sla_archive(), and read_ini().

Here is the call graph for this function:

Here is the caller graph for this function:

read_png()

PNGBuffer Slic3r::anonymous_namespace{SL1.cpp}::read_png	(	const mz_zip_archive_file_stat &	entry,
		MZ_Archive &	zip,
		const std::string &	name )

{
    std::vector<uint8_t> buf(entry.m_uncomp_size);
 
    if (!mz_zip_reader_extract_file_to_mem(&zip.arch, entry.m_filename,
                                           buf.data(), buf.size(), 0))
        throw Slic3r::FileIOError(zip.get_errorstr());
 
    return {std::move(buf), (name.empty() ? entry.m_filename : name)};
}

References Slic3r::MZ_Archive::arch, Slic3r::MZ_Archive::get_errorstr(), and read_png().

Referenced by extract_sla_archive(), and read_png().

Here is the call graph for this function:

Here is the caller graph for this function:

rings_to_expolygons()

ExPolygons Slic3r::anonymous_namespace{SL1.cpp}::rings_to_expolygons	(	const std::vector< marchsq::Ring > &	rings,
		double	px_w,
		double	px_h )

{
    auto polys = reserve_vector<ExPolygon>(rings.size());
 
    for (const marchsq::Ring &ring : rings) {
        Polygon poly; Points &pts = poly.points;
        pts.reserve(ring.size());
 
        for (const marchsq::Coord &crd : ring)
            pts.emplace_back(scaled(crd.c * px_w), scaled(crd.r * px_h));
 
        polys.emplace_back(poly);
    }
 
    // TODO: Is a union necessary?
    return union_ex(polys);
}

References Slic3r::reserve_vector(), rings_to_expolygons(), Slic3r::scaled(), and Slic3r::union_ex().

Referenced by extract_slices_from_sla_archive(), and rings_to_expolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

to_ini()

std::string Slic3r::anonymous_namespace{SL1.cpp}::to_ini

(

const ConfMap &

m

)

{
    std::string ret;
    for (auto &param : m) ret += param.first + " = " + param.second + "\n";
    
    return ret;
}

References to_ini().

Referenced by to_ini().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

CONFIG_FNAME

const constexpr char* Slic3r::anonymous_namespace{SL1.cpp}::CONFIG_FNAME = "config.ini"

staticconstexpr

Referenced by extract_sla_archive().

PROFILE_FNAME

const constexpr char* Slic3r::anonymous_namespace{SL1.cpp}::PROFILE_FNAME = "prusaslicer.ini"

staticconstexpr

Referenced by extract_sla_archive().