Slic3r::anonymous_namespace{SL1.cpp} Namespace Reference

Functions
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)
ExPolygons	rings_to_expolygons (const std::vector< marchsq::Ring > &rings, double px_w, double px_h)
std::vector< ExPolygons >	extract_slices_from_sla_archive (ZipperArchive &arch, const RasterParams &rstp, const marchsq::Coord &win, std::function< bool(int)> progr)

Function Documentation

extract_slices_from_sla_archive()

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

{
    std::vector<ExPolygons> slices(arch.entries.size());
 
    struct Status
    {
        double                                 incr, val, prev;
        bool                                   stop  = false;
        execution::SpinningMutex<ExecutionTBB> mutex = {};
    } st{100. / slices.size(), 0., 0.};
 
    execution::for_each(
        ex_tbb, size_t(0), arch.entries.size(),
        [&arch, &slices, &st, &rstp, &win, progr](size_t i) {
            // Status indication guarded with the spinlock
            {
                std::lock_guard 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.entries[i].buf.data(),
                            arch.entries[i].buf.size()};
            if (!png::decode_png(rb, img)) return;
 
            constexpr uint8_t isoval = 128;
            auto              rings = marchsq::execute(img, isoval, 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);
        },
        execution::max_concurrency(ex_tbb));
 
    if (st.stop) slices = {};
 
    return slices;
}

References Slic3r::png::decode_png(), Slic3r::ZipperArchive::entries, Slic3r::ex_tbb, extract_slices_from_sla_archive(), Slic3r::execution::for_each(), Slic3r::RasterParams::height, Slic3r::invert_raster_trafo(), Slic3r::RasterParams::px_h, Slic3r::RasterParams::px_w, rings_to_expolygons(), Slic3r::RasterParams::trafo, and Slic3r::RasterParams::width.

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");
    const std::string mps = get_cfg_value(cfg, "material_print_speed");
    m["expUserProfile"] = mps == "slow" ? "1" : mps == "fast" ? "0" : "2";
    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,
        //FIXME The print host keys should not be exported to full_print_config anymore. The following keys may likely be removed.
        "print_host"sv,
        "printhost_apikey"sv,
        "printhost_cafile"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(), Slic3r::PrintBase::full_print_config(), and Slic3r::ConfigBase::opt_serialize().

Referenced by fill_slicerconf().

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(), Slic3r::ConfigBase::option(), and Slic3r::ConfigOption::serialize().

Referenced by fill_iniconf(), and get_cfg_value().

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::MultiPoint::points, 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: