anonymous_namespace{OrcaSlicer_profile_validator.cpp} Namespace Reference

Typedefs
using	Templates = std::set<std::pair<std::string, std::string>>

Functions
Vec2d	printable_area_center (const DynamicPrintConfig &cfg)
Vec2d	place_wipe_tower (DynamicPrintConfig &cfg, const Vec2d &center)
std::string	slice_two_color_cube_and_export (DynamicPrintConfig cfg, bool is_bbl, bool by_object)
void	select_printer_default_presets (PresetBundle &bundle)
void	install_slice_context_log_sink ()
DynamicPrintConfig	slice_config (PresetBundle &bundle)
std::string	slice_selection (PresetBundle &bundle, const std::string &what, bool by_object, const std::string &outdir, const std::string &file_base)
Templates	preset_templates (const DynamicPrintConfig &cfg)
int	slice_all_printers (const std::string &vendor, const std::string &outdir)

Variables
static std::string	g_slice_context

Typedef Documentation

Templates

using anonymous_namespace{OrcaSlicer_profile_validator.cpp}::Templates = std::set<std::pair<std::string, std::string>>

Function Documentation

install_slice_context_log_sink()

void anonymous_namespace{OrcaSlicer_profile_validator.cpp}::install_slice_context_log_sink

(

)

{
    namespace logging = boost::log;
    namespace sinks   = boost::log::sinks;
    namespace expr    = boost::log::expressions;
 
    auto backend = boost::make_shared<sinks::text_ostream_backend>();
    backend->add_stream(boost::shared_ptr<std::ostream>(&std::clog, boost::null_deleter()));
    backend->auto_flush(true);
 
    auto sink = boost::make_shared<sinks::synchronous_sink<sinks::text_ostream_backend>>(backend);
    sink->set_formatter([](const logging::record_view &rec, logging::formatting_ostream &strm) {
        strm << "[" << rec[logging::trivial::severity] << "]";
        if (!g_slice_context.empty())
            strm << " [" << g_slice_context << "]";
        strm << " " << rec[expr::smessage];
    });
 
    logging::core::get()->remove_all_sinks(); // drop the default trivial sink so lines are not doubled
    logging::core::get()->add_sink(sink);
}

References g_slice_context.

Referenced by slice_all_printers().

Here is the caller graph for this function:

place_wipe_tower()

Vec2d anonymous_namespace{OrcaSlicer_profile_validator.cpp}::place_wipe_tower	(	DynamicPrintConfig &	cfg,
		const Vec2d &	center )

{
    const auto *area = cfg.option<ConfigOptionPoints>("printable_area");
    if (area == nullptr || area->values.size() < 3)
        return Vec2d::Zero();
    const WipeTowerFootprint footprint = estimate_wipe_tower_footprint(cfg, resolve_wipe_tower_type(cfg), {0, 1}, cfg.opt_float("layer_height"), 10.);
    if (footprint.depth < EPSILON)
        return Vec2d::Zero();
    const double margin = WIPE_TOWER_MARGIN + footprint.brim_width;
    // The position is the tower's own origin; a rotated tower extends from it in another
    // direction, so place the rotated box's extents rather than the origin.
    Slic3r::Polygon box({Point::new_scale(0., 0.), Point::new_scale(footprint.width, 0.), Point::new_scale(footprint.width, footprint.depth), Point::new_scale(0., footprint.depth)});
    box.rotate(Geometry::deg2rad(cfg.opt_float("wipe_tower_rotation_angle")));
    const BoundingBox local = get_extents(box);
    const Vec2d       lo    = unscale(local.min);
    const Vec2d       size  = unscale(local.max) - lo;
    Vec2d             pos(center.x() + 5. + margin + 5. - lo.x(), center.y() - size.y() / 2. - lo.y());
    box.translate(Point::new_scale(pos.x(), pos.y()));
    // A bed too small for the pair keeps the cube at its centre and places the tower alone.
    const Polygons    bed{Polygon::new_scale(area->values)};
    const BoundingBox tower = get_extents(box);
    BoundingBox       pair  = tower;
    pair.merge(Point::new_scale(center.x() - 5., center.y() - 5.));
    pair.merge(Point::new_scale(center.x() + 5., center.y() + 5.));
    const Point       room  = get_extents(bed).size() - Point::new_scale(2. * margin, 2. * margin);
    const bool        rigid = pair.size().x() < room.x() && pair.size().y() < room.y();
    const Vec2d       move  = WipeTower::move_box_inside_polygon(rigid ? pair : tower, bed, scaled<coord_t>(margin)).cast<double>();
    pos += move;
    cfg.option<ConfigOptionFloats>("wipe_tower_x", true)->values = {pos.x()};
    cfg.option<ConfigOptionFloats>("wipe_tower_y", true)->values = {pos.y()};
    return rigid ? move : Vec2d::Zero();
}

References Slic3r::area(), Slic3r::WipeTowerFootprint::brim_width, Slic3r::center(), Slic3r::Geometry::deg2rad(), Slic3r::WipeTowerFootprint::depth, EPSILON, Slic3r::estimate_wipe_tower_footprint(), Slic3r::get_extents(), Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::WipeTower::move_box_inside_polygon(), Slic3r::Point::new_scale(), Slic3r::Polygon::new_scale(), Slic3r::DynamicConfig::opt_float(), Slic3r::ConfigBase::option(), Slic3r::resolve_wipe_tower_type(), Slic3r::MultiPoint::rotate(), Slic3r::scaled(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::unscale(), Slic3r::WipeTowerFootprint::width, and WIPE_TOWER_MARGIN.

Referenced by slice_two_color_cube_and_export().

Here is the call graph for this function:

Here is the caller graph for this function:

preset_templates()

Templates anonymous_namespace{OrcaSlicer_profile_validator.cpp}::preset_templates

(

const DynamicPrintConfig &

cfg

)

{
    Templates out;
    for (const std::string &key : cfg.keys()) {
        if (key != "filename_format" && !boost::algorithm::ends_with(key, "_gcode"))
            continue;
        const ConfigOption *opt = cfg.option(key);
        if (opt->type() == coString) {
            if (const std::string &text = static_cast<const ConfigOptionString *>(opt)->value; !text.empty())
                out.emplace(key, text);
        } else if (opt->type() == coStrings) {
            for (const std::string &text : static_cast<const ConfigOptionStrings *>(opt)->values)
                if (!text.empty())
                    out.emplace(key, text);
        }
    }
    return out;
}

References Slic3r::coString, Slic3r::coStrings, Slic3r::ConfigOptionString::empty(), Slic3r::DynamicConfig::keys(), and Slic3r::ConfigBase::option().

Referenced by slice_all_printers().

Here is the call graph for this function:

Here is the caller graph for this function:

printable_area_center()

Vec2d anonymous_namespace{OrcaSlicer_profile_validator.cpp}::printable_area_center

(

const DynamicPrintConfig &

cfg

)

{
    const auto *opt = cfg.option<ConfigOptionPoints>("printable_area");
    if (opt == nullptr || opt->values.empty())
        return Vec2d(100., 100.);
    Vec2d lo = opt->values.front(), hi = opt->values.front();
    for (const Vec2d &p : opt->values) { lo = lo.cwiseMin(p); hi = hi.cwiseMax(p); }
    return 0.5 * (lo + hi);
}

References Slic3r::ConfigBase::option().

Referenced by slice_two_color_cube_and_export().

Here is the call graph for this function:

Here is the caller graph for this function:

select_printer_default_presets()

void anonymous_namespace{OrcaSlicer_profile_validator.cpp}::select_printer_default_presets

(

PresetBundle &

bundle

)

{
    const Preset &printer_preset = bundle.printers.get_selected_preset();
    const std::string def_print = printer_preset.config.opt_string("default_print_profile");
    if (!def_print.empty())
        bundle.prints.select_preset_by_name(def_print, /*force=*/true);
    if (const auto *def_fil = printer_preset.config.option<ConfigOptionStrings>("default_filament_profile");
        def_fil != nullptr && !def_fil->values.empty())
        bundle.filaments.select_preset_by_name(def_fil->values.front(), /*force=*/true);
    // Re-seed the per-slot filament list from that selection, or the sweep's result depends on the
    // printer sliced before it. Once there are 2+ slots, full_config() builds the filament config from
    // filament_presets and ignores the selected preset (PresetBundle::full_fff_config), while
    // update_compatible() only replaces a slot that has gone *incompatible* - and when it does, it ranks
    // the outgoing preset's alias, then its filament type, above the printer's own default. The sweep
    // grows every printer to 2 slots and update_multi_material_filament_presets() never shrinks them, so
    // a material picked up on the first printer rides the whole run. With all vendors loaded the first
    // printer inherits a TPU (the load-time pick is whichever filament sorts first), the type match
    // re-resolves it to "Generic TPU @System", and its alias then pins every later printer to that
    // vendor's own "Generic TPU @..." - which the BBL dual-nozzle profiles rightly refuse to group.
    bundle.filament_presets.assign(1, bundle.filaments.get_selected_preset_name());
}

References Slic3r::Preset::config, Slic3r::PresetBundle::filament_presets, Slic3r::PresetBundle::filaments, Slic3r::PresetCollection::get_selected_preset(), Slic3r::PresetCollection::get_selected_preset_name(), Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), Slic3r::PresetBundle::printers, Slic3r::PresetBundle::prints, Slic3r::PresetCollection::select_preset_by_name(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by slice_all_printers().

Here is the call graph for this function:

Here is the caller graph for this function:

slice_all_printers()

int anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers	(	const std::string &	vendor,
		const std::string &	outdir )

{
    install_slice_context_log_sink();
    PlaceholderParser::check_inactive_branches = true;
 
    if (!outdir.empty()) {
        boost::system::error_code ec;
        fs::create_directories(outdir, ec);
        if (ec) {
            BOOST_LOG_TRIVIAL(error) << "Could not create output directory \"" << outdir << "\": " << ec.message();
            std::cout << "Validation failed" << std::endl;
            return 1;
        }
        std::cout << "Saving sliced g-code to " << outdir << std::endl;
    }
 
    PresetBundle bundle;
    bundle.set_is_validation_mode(true);
    bundle.set_vendor_to_validate(vendor); // empty == all vendors
    AppConfig app_config;
    app_config.set("preset_folder", "default");
    try {
        bundle.load_presets(app_config, ForwardCompatibilitySubstitutionRule::Disable);
    } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << ex.what();
        std::cout << "Validation failed" << std::endl;
        return 1;
    }
 
    // Enable every instantiable model/variant in AppConfig - system printers are hidden until enabled;
    // without this select_preset_by_name silently falls back to the "Default Printer".
    std::vector<std::pair<std::string, std::string>> printers; // (vendor name, preset name)
    for (const Preset &p : bundle.printers.get_presets()) {
        if (p.vendor == nullptr) continue;                 // skips the Default Printer
        const std::string model   = p.config.opt_string("printer_model");
        const std::string variant = p.config.opt_string("printer_variant");
        if (model.empty() || variant.empty()) continue;    // skip non-instantiable base/common configs
        app_config.set_variant(p.vendor->id, model, variant, true);
        printers.push_back({p.vendor->name, p.name});
    }
    bundle.load_installed_printers(app_config);
 
    if (printers.empty()) {
        BOOST_LOG_TRIVIAL(error) << "No instantiable printer presets found"
            << (vendor.empty() ? "" : " for vendor " + vendor);
        std::cout << "Validation failed" << std::endl;
        return 1;
    }
    std::cout << "Slicing " << printers.size() << " printer preset(s)"
              << (vendor.empty() ? "" : " for vendor " + vendor) << "..." << std::endl;
 
    Templates covered; // the process and filament templates some slice has expanded
    auto cover = [&covered](const Preset &preset) {
        const Templates templates = preset_templates(preset.config);
        covered.insert(templates.begin(), templates.end());
    };
    auto is_covered = [&covered](const Preset &preset) {
        const Templates templates = preset_templates(preset.config);
        return std::includes(covered.begin(), covered.end(), templates.begin(), templates.end());
    };
    int failures = 0, extra_processes = 0, extra_filaments = 0, by_object_slices = 0;
    for (const auto &[vendor_name, printer] : printers) {
        g_slice_context = vendor_name + " / " + printer; // tag every engine log line from this slice
        const bool selected = bundle.printers.select_preset_by_name(printer, /*force=*/true);
        if (!selected || bundle.printers.get_selected_preset_name() != printer) {
            BOOST_LOG_TRIVIAL(error) << "Printer preset \"" << printer << "\" could not be selected";
            ++failures;
            continue;
        }
 
        select_printer_default_presets(bundle);          // slice with the printer's shipped process/filament
        bundle.update_multi_material_filament_presets();  // size filament_presets to nozzle count
        bundle.update_compatible(PresetSelectCompatibleType::Always);
 
        // Never slice with a generic default preset - that would validate stand-in settings, not the
        // real profile (a legit per-profile error).
        if (bundle.prints.get_selected_preset().is_default || bundle.filaments.get_selected_preset().is_default) {
            BOOST_LOG_TRIVIAL(error) << "Printer \"" << printer << "\" fell back to a default preset (process=\""
                << bundle.prints.get_selected_preset_name() << "\", filament=\""
                << bundle.filaments.get_selected_preset_name() << "\")";
            ++failures;
            continue;
        }
 
        const std::string print_name    = bundle.prints.get_selected_preset_name();
        const std::string filament_name = bundle.filaments.get_selected_preset_name();
        const std::string what          = "Printer \"" + printer + "\"";
        const std::string file_base     = sanitize_filename(vendor_name) + "__" + sanitize_filename(printer);
        // A belt printer has no wipe tower (it purges into a prism object on the belt), so its
        // filament change is the plain tool change set_extruder() emits rather than the tower's block.
        const bool        belt   = bundle.printers.get_selected_preset().config.opt_bool("belt_printer");
        const std::string marker = belt ? "\nT1\n" : "CP TOOLCHANGE START";
        if (const std::string out = slice_selection(bundle, what, false, outdir, file_base); out.empty())
            ++failures;
        else if (out.find(marker) == std::string::npos) {
            // The filament change never fired, so change_filament_gcode was not exercised.
            BOOST_LOG_TRIVIAL(error) << what << " sliced but the filament change never fired (no "
                                     << (belt ? "T1" : "CP TOOLCHANGE START") << ")";
            ++failures;
        }
        cover(bundle.prints.get_selected_preset());
        cover(bundle.filaments.get_selected_preset());
 
        const std::string &by_object_gcode = bundle.printers.get_selected_preset().config.opt_string("printing_by_object_gcode");
        if (!by_object_gcode.empty() && covered.emplace("printing_by_object_gcode", by_object_gcode).second) {
            ++by_object_slices;
            g_slice_context = vendor_name + " / " + printer + " / by object";
            if (slice_selection(bundle, what + " printing by object", true, outdir, file_base + "__by_object").empty())
                ++failures;
        }
 
        // The first process of this printer that compatible_prints lets an otherwise incompatible filament
        // use, judged as update_compatible() would with that process selected; empty if there is none.
        const PresetWithVendorProfile printer_with_vendor = bundle.printers.get_edited_preset_with_vendor_profile();
        auto limiting_process = [&bundle, &printer_with_vendor](const Preset &filament) -> std::string {
            const auto *processes = filament.config.option<ConfigOptionStrings>("compatible_prints");
            if (processes == nullptr || processes->values.empty())
                return {};
            const PresetWithVendorProfile filament_with_vendor = bundle.filaments.get_preset_with_vendor_profile(filament);
            if (!is_compatible_with_printer(filament_with_vendor, printer_with_vendor))
                return {};
            for (const std::string &name : processes->values)
                if (const Preset *process = bundle.prints.find_preset(name);
                    process != nullptr && process->is_visible && process->is_compatible &&
                    is_compatible_with_print(filament_with_vendor, bundle.prints.get_preset_with_vendor_profile(*process), printer_with_vendor))
                    return name;
            return {};
        };
        // The compatibility flags are still this printer's, from update_compatible() above, which judged the
        // filaments against the printer's own process. A hidden preset cannot be selected, so it is counted,
        // not sliced.
        std::vector<std::pair<const Preset *, std::string>> extras; // (extra preset, process to slice it with)
        size_t                                              hidden = 0;
        for (const PresetCollection *presets : {&bundle.prints, &bundle.filaments})
            for (const Preset &preset : presets->get_presets()) {
                if (!preset.is_system || preset.is_default)
                    continue;
                std::string process;
                if (preset.is_compatible)
                    process = preset.type == Preset::TYPE_PRINT ? preset.name : print_name;
                else if (preset.type == Preset::TYPE_FILAMENT)
                    process = limiting_process(preset);
                if (process.empty() || is_covered(preset))
                    continue;
                if (preset.is_visible)
                    extras.emplace_back(&preset, process);
                else
                    ++hidden;
            }
        if (hidden > 0)
            BOOST_LOG_TRIVIAL(warning) << "Printer \"" << printer << "\": " << hidden
                << " compatible system preset(s) with unexpanded templates are hidden and were not sliced";
 
        // Each extra slice swaps one preset into the printer's own selection. update_compatible() is not
        // run again: it could swap filament slots. The filament change is not required to ride the tower
        // here (a vase-mode process has none): the printer's own slice above already expanded its hooks.
        for (const auto &[preset, process] : extras) {
            if (is_covered(*preset))
                continue; // an earlier extra slice expanded the same texts
            const bool         is_print = preset->type == Preset::TYPE_PRINT;
            const std::string &filament = is_print ? filament_name : preset->name;
            std::string        extra    = std::string(is_print ? "process" : "filament") + " \"" + preset->name + "\"";
            if (!is_print && process != print_name)
                extra += " and process \"" + process + "\"";
            g_slice_context = vendor_name + " / " + printer + " / " + extra;
            if (is_print)
                ++extra_processes;
            else
                ++extra_filaments;
            cover(*preset);
            bundle.prints.select_preset_by_name(process, /*force=*/true);
            bundle.filaments.select_preset_by_name(filament, /*force=*/true);
            bundle.filament_presets.assign(1, bundle.filaments.get_selected_preset_name());
            bundle.update_multi_material_filament_presets();
            // select_preset_by_name() falls back to another preset, and still returns true, when it cannot select this one.
            if (bundle.prints.get_selected_preset_name() != process || bundle.filaments.get_selected_preset_name() != filament) {
                BOOST_LOG_TRIVIAL(error) << what << " could not select " << extra;
                ++failures;
                continue;
            }
            if (slice_selection(bundle, what + " with " + extra, false, outdir, file_base + "__" + sanitize_filename(preset->name)).empty())
                ++failures;
        }
        // Leave the printer's own selection for the next printer to start from, as without the extra slices.
        bundle.prints.select_preset_by_name(print_name, /*force=*/true);
        bundle.filaments.select_preset_by_name(filament_name, /*force=*/true);
    }
    g_slice_context.clear();
 
    const int slices = int(printers.size()) + extra_processes + extra_filaments + by_object_slices;
    std::cout << "Sliced " << printers.size() << " printer preset(s), " << extra_processes << " more process preset(s), "
              << extra_filaments << " more filament preset(s) and " << by_object_slices << " printer(s) by object" << std::endl;
    if (failures > 0) {
        std::cout << failures << " of " << slices << " slice(s) failed" << std::endl;
        std::cout << "Validation failed" << std::endl;
        return 1;
    }
    std::cout << "All " << slices << " slice(s) succeeded" << std::endl;
    std::cout << "Validation completed successfully" << std::endl;
    return 0;
}

References Slic3r::Always, Slic3r::PlaceholderParser::check_inactive_branches, Slic3r::Preset::config, Slic3r::Disable, Slic3r::empty(), Slic3r::PresetBundle::filament_presets, Slic3r::PresetBundle::filaments, Slic3r::PresetCollection::find_preset(), g_slice_context, Slic3r::PresetCollection::get_edited_preset_with_vendor_profile(), Slic3r::PresetCollection::get_preset_with_vendor_profile(), Slic3r::PresetCollection::get_presets(), Slic3r::PresetCollection::get_selected_preset(), Slic3r::PresetCollection::get_selected_preset_name(), install_slice_context_log_sink(), Slic3r::is_compatible_with_print(), Slic3r::is_compatible_with_printer(), Slic3r::Preset::is_default, Slic3r::PresetBundle::load_installed_printers(), Slic3r::PresetBundle::load_presets(), Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_string(), preset_templates(), Slic3r::PresetBundle::printers, Slic3r::PresetBundle::prints, Slic3r::sanitize_filename(), Slic3r::PresetCollection::select_preset_by_name(), select_printer_default_presets(), Slic3r::AppConfig::set(), Slic3r::PresetBundle::set_is_validation_mode(), Slic3r::AppConfig::set_variant(), Slic3r::PresetBundle::set_vendor_to_validate(), slice_selection(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::PresetBundle::update_compatible(), and Slic3r::PresetBundle::update_multi_material_filament_presets().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

slice_config()

DynamicPrintConfig anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_config

(

PresetBundle &

bundle

)

{
    // Grow to a 2nd filament so the cube can change colour; never shrink a multi-nozzle printer
    // below its nozzle count, or full_config()'s flush-volume matrix no longer matches validate().
    const size_t nozzles = bundle.printers.get_selected_preset().config.option<ConfigOptionFloats>("nozzle_diameter")->size();
    bundle.set_num_filaments((unsigned int) std::max<size_t>(2, nozzles));
 
    // Mirror the app's manual filament->nozzle assignment for a multi-nozzle BBL printer: put each
    // filament on its own nozzle and pin the map (fmmManual) so full_config() collapses every filament to
    // the variant of the nozzle it actually prints from, and the engine keeps that assignment instead of
    // auto-remapping it during process(). Without this the synthetic 2nd filament keeps nozzle 1's variant
    // while the auto map moves it to nozzle 2 - harmless, but on the one printer whose nozzles differ in
    // type (Direct Drive + Bowden) the mismatched lookup spams [error] lines. Single-nozzle and non-BBL
    // printers keep the default map (their toolchange rides the AMS/tool-changer path unchanged).
    const bool pin_filament_map = bundle.is_bbl_vendor() && nozzles > 1;
    auto &fmap = bundle.project_config.option<ConfigOptionInts>("filament_map", true)->values;
    if (pin_filament_map) {
        for (size_t i = 0; i < fmap.size(); ++i)
            fmap[i] = int(i % nozzles) + 1;
    }
 
    // A fresh printer selection uses its declared nozzle volumes, just like the
    // app. Otherwise a high-flow preset is silently sliced with Standard tuning.
    bundle.reset_default_nozzle_volume_type();
    bundle.project_config.option<ConfigOptionInts>("filament_volume_map", true)->values =
        bundle.get_default_nozzle_volume_types_for_filaments(fmap);
 
    DynamicPrintConfig cfg = bundle.full_config();
    cfg.set_key_value("enable_prime_tower", new ConfigOptionBool(true)); // force a purge tower so the change is detectable
    // The map above drives full_config()'s per-filament variant collapse; fmmManual on the sliced config
    // stops process() from auto-remapping filaments back onto a different nozzle (which would re-introduce
    // the variant mismatch this pinning avoids).
    if (pin_filament_map)
        cfg.set_key_value("filament_map_mode", new ConfigOptionEnum<FilamentMapMode>(fmmManual));
 
    // full_config() grows filament_extruder_variant to one entry per filament, but because the synthetic
    // 2nd filament is a duplicate of the first (set_num_filaments copies the same preset), it leaves
    // filament_self_index at size 1. That makes update_values_to_printer_extruders_for_multiple_filaments
    // fail to resolve the 2nd filament's variant - a benign fallback that spams [error] lines. A real
    // 2-colour project ships filament_self_index = 1,2,...; mirror that so the sweep log stays clean. The
    // slice output is unaffected: the duplicated filament's per-variant values are identical to the first.
    if (auto *variants = cfg.option<ConfigOptionStrings>("filament_extruder_variant")) {
        auto &self_index = cfg.option<ConfigOptionInts>("filament_self_index", true)->values;
        if (self_index.size() != variants->size()) {
            self_index.resize(variants->size());
            for (size_t i = 0; i < self_index.size(); ++i)
                self_index[i] = int(i) + 1;
        }
    }
    return cfg;
}

References Slic3r::Preset::config, Slic3r::fmmManual, Slic3r::PresetBundle::full_config(), Slic3r::PresetBundle::get_default_nozzle_volume_types_for_filaments(), Slic3r::PresetCollection::get_selected_preset(), Slic3r::PresetBundle::is_bbl_vendor(), Slic3r::ConfigBase::option(), Slic3r::PresetBundle::printers, Slic3r::PresetBundle::project_config, Slic3r::PresetBundle::reset_default_nozzle_volume_type(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::PresetBundle::set_num_filaments().

Referenced by slice_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

slice_selection()

std::string anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_selection	(	PresetBundle &	bundle,
		const std::string &	what,
		bool	by_object,
		const std::string &	outdir,
		const std::string &	file_base )

{
    try {
        const std::string out = slice_two_color_cube_and_export(slice_config(bundle), bundle.is_bbl_vendor(), by_object);
        if (!outdir.empty() && !out.empty())
            save_string_file(fs::path(outdir) / (file_base + ".gcode"), out);
        if (out.empty() || out.find("G1") == std::string::npos) {
            BOOST_LOG_TRIVIAL(error) << what << " produced no g-code";
            return {};
        }
        return out;
    } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << what << " failed to slice: " << ex.what();
        return {};
    }
}

References Slic3r::PresetBundle::is_bbl_vendor(), Slic3r::save_string_file(), slice_config(), and slice_two_color_cube_and_export().

Referenced by slice_all_printers().

Here is the call graph for this function:

Here is the caller graph for this function:

slice_two_color_cube_and_export()

std::string anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export	(	DynamicPrintConfig	cfg,
		bool	is_bbl,
		bool	by_object )

{
    const Vec2d        center = printable_area_center(cfg);
    const bool         belt   = cfg.opt_bool("belt_printer");
    std::vector<Vec2d> cube_mins;
    if (by_object) {
        // By-object printing fires the hook only without a wipe tower, and rules out clumping detection and
        // smooth timelapse. No skirt, so the two cubes' own skirts cannot overlap.
        cfg.set_key_value("print_sequence", new ConfigOptionEnum<PrintSequence>(PrintSequence::ByObject));
        cfg.set_key_value("enable_prime_tower", new ConfigOptionBool(false));
        cfg.set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
        cfg.set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
        cfg.set_key_value("skirt_loops", new ConfigOptionInt(0));
        cube_mins = {center + Vec2d(-20., -5.), center + Vec2d(10., -5.)};
    } else if (belt) {
        // A belt object's slicing Z starts at the belt below its leading end, well below its first
        // printed layer, so a height range in slicing Z does not map onto the part. Two cubes one
        // behind the other along the belt, the second on filament 2, give the one filament change
        // instead (the purge prism is an object the GUI adds, so there is no tower to place).
        cube_mins = {center - Vec2d(5., 15.), center + Vec2d(-5., 5.)};
    } else {
        // Clumping detection changes the tower footprint, so turn it on before placing the tower.
        if (!cfg.opt_string("wrapping_detection_gcode").empty())
            cfg.set_key_value("enable_wrapping_detection", new ConfigOptionBool(true));
        cube_mins = {center - Vec2d(5., 5.) + place_wipe_tower(cfg, center)};
    }
 
    Model  model;
    Print  print;
    print.is_BBL_printer() = is_bbl;
    for (const Vec2d &cube_min : cube_mins) {
        TriangleMesh m = make_cube(10, 10, 10);
        m.translate(static_cast<float>(cube_min.x()), static_cast<float>(cube_min.y()), 0.f);
        ModelObject *obj = model.add_object();
        obj->name = "cube"; // populates [input_filename_base] the way a loaded model does
        obj->add_volume(m);
        obj->add_instance();
        if (belt && !by_object) {
            // The second cube along the belt is on filament 2 (see cube_mins above).
            if (&cube_min == &cube_mins.back())
                obj->config.set_key_value("extruder", new ConfigOptionInt(2));
        } else {
            // Filament 2 is used only above z=4, so the upper layers carry a single filament change.
            DynamicPrintConfig range_config;
            range_config.set_key_value("extruder",     new ConfigOptionInt(2));
            // Every range must carry a layer_height; use the process's own so a fine nozzle (e.g. 0.15 mm
            // printing ~0.1 mm layers) isn't forced to a height its extrusion width can't support - that
            // trips Flow::with_spacing.
            range_config.set_key_value("layer_height", new ConfigOptionFloat(cfg.opt_float("layer_height")));
            obj->layer_config_ranges[{4.0, 10.0}].assign_config(std::move(range_config));
        }
        obj->ensure_on_bed();
        print.auto_assign_extruders(obj);
    }
    // Custom g-codes per print_z apply to layer-by-layer printing only (ToolOrdering::assign_custom_gcodes).
    if (!by_object)
        model.plates_custom_gcodes[model.curr_plate_index].gcodes = {{2., CustomGCode::PausePrint, 1, "", ""},
                                                                     {7., CustomGCode::Template, 1, "", ""}};
    print.apply(model, cfg);
    print.validate();
 
    // Process + export to a temp file, then read it back (the app's own export path is where the
    // custom *_gcode placeholders expand).
    print.set_status_silent();
    print.process();
    const fs::path tmp = fs::temp_directory_path() / fs::unique_path("orca-validate-%%%%-%%%%.gcode");
    print.export_gcode(tmp.string(), nullptr, nullptr);
    std::ifstream in(tmp.string());
    std::string   out((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
    in.close();
    boost::system::error_code ec;
    fs::remove(tmp, ec);
    print.output_filename(); // names the export as the app does, expanding filename_format
    return out;
}

References Slic3r::ModelObject::add_instance(), Slic3r::Model::add_object(), Slic3r::ModelObject::add_volume(), Slic3r::Print::apply(), Slic3r::Print::auto_assign_extruders(), Slic3r::ByObject, Slic3r::center(), Slic3r::ModelObject::config, Slic3r::ConfigOptionFloat, Slic3r::Model::curr_plate_index, Slic3r::ModelObject::ensure_on_bed(), Slic3r::Print::export_gcode(), Slic3r::Print::is_BBL_printer(), Slic3r::ModelObject::layer_config_ranges, Slic3r::make_cube(), Slic3r::ModelObject::name, Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_string(), Slic3r::Print::output_filename(), Slic3r::CustomGCode::PausePrint, place_wipe_tower(), Slic3r::Model::plates_custom_gcodes, printable_area_center(), Slic3r::Print::process(), Slic3r::DynamicConfig::set_key_value(), Slic3r::ModelConfig::set_key_value(), Slic3r::PrintBase::set_status_silent(), Slic3r::CustomGCode::Template, Slic3r::tlTraditional, Slic3r::TriangleMesh::translate(), and Slic3r::Print::validate().

Referenced by slice_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

g_slice_context

std::string anonymous_namespace{OrcaSlicer_profile_validator.cpp}::g_slice_context

static

Referenced by install_slice_context_log_sink(), and slice_all_printers().