diff --git a/src/OrcaSlicer.cpp b/src/OrcaSlicer.cpp index 1939988261..3ed76b8976 100644 --- a/src/OrcaSlicer.cpp +++ b/src/OrcaSlicer.cpp @@ -2116,9 +2116,14 @@ int CLI::run(int argc, char **argv) // One resolver for the whole run, so presets from the same vendor tree share its load. std::unique_ptr system_preset_resolver; - auto resolve_preset = [&ensure_cli_preset_bundle, &system_preset_resolver](const std::string &file, DynamicPrintConfig &config, - std::string &config_type, const std::string &config_from, - bool probe_type, std::string &error) { + auto ensure_system_preset_resolver = [&system_preset_resolver]() -> PresetBundle & { + if (!system_preset_resolver) + system_preset_resolver = std::make_unique(); + return *system_preset_resolver; + }; + auto resolve_preset = [&ensure_cli_preset_bundle, &ensure_system_preset_resolver](const std::string &file, DynamicPrintConfig &config, + std::string &config_type, const std::string &config_from, + bool probe_type, std::string &error) { const auto *inherits = config.option(BBL_JSON_KEY_INHERITS); if (!probe_type && (inherits == nullptr || inherits->value.empty())) return true; @@ -2126,9 +2131,7 @@ int CLI::run(int argc, char **argv) PresetBundle *bundle = nullptr; bool allow_source_manifest = false; if (config_from == "system") { - if (!system_preset_resolver) - system_preset_resolver = std::make_unique(); - bundle = system_preset_resolver.get(); + bundle = &ensure_system_preset_resolver(); allow_source_manifest = true; } else { bundle = ensure_cli_preset_bundle(error); @@ -3120,6 +3123,44 @@ int CLI::run(int argc, char **argv) return 0; }; + // Load the project's printer and process settings as the GUI loads its presets: over the default preset, + // with every key the project does not list as changed, including keys saved before an option existed, + // taken from its current system preset. + auto load_project_preset = [this, &ensure_system_preset_resolver, ¤t_different_settings, filament_count](const std::string &system_name, Preset::Type type) { + if (system_name.empty()) + return; + // Preset bookkeeping the CLI keeps in its own groups, e.g. inherits_group and print_compatible_printers. + static const std::set bookkeeping_keys = {"inherits", "compatible_printers", "compatible_prints", "compatible_printers_condition", + "compatible_prints_condition", "print_settings_id", "printer_settings_id"}; + const size_t index = type == Preset::TYPE_PRINTER ? filament_count + 1 : 0; + PresetBundle &resolver = ensure_system_preset_resolver(); + DynamicPrintConfig system_config; + t_config_option_keys keys; + const DynamicPrintConfig config = Preset::load_external_config(type, + type == Preset::TYPE_PRINTER ? resolver.printers.default_preset_for(m_print_config).config : resolver.prints.default_preset().config, + m_print_config, PresetBundle::project_different_keys(index < current_different_settings.size() ? current_different_settings[index] : std::string()), + [&](const std::string &) -> DynamicPrintConfig * { + std::string error; + if (resolver.resolve_system_preset(system_config, type, system_name, config_substitution_rule, error)) + return &system_config; + BOOST_LOG_TRIVIAL(warning) << boost::format("CLI: system preset '%1%' not resolved (%2%); the project keeps its values") % system_name % error; + return nullptr; + }, &keys); + for (const std::string &key : keys) { + const ConfigOption *opt = config.option(key); + const ConfigOption *old = m_print_config.option(key); + if (bookkeeping_keys.count(key) != 0 || opt == nullptr || (old != nullptr && *old == *opt)) + continue; + BOOST_LOG_TRIVIAL(info) << boost::format("CLI: %1% from '%2%': %3% -> %4%") % key % system_name % (old ? old->serialize() : std::string("(missing)")) % opt->serialize(); + m_print_config.set_key_value(key, opt->clone()); + } + }; + // The --uptodate path refreshes the project from its own system configs. + if (new_printer_name.empty() && load_machine_config.empty()) + load_project_preset(current_printer_system_name, Preset::TYPE_PRINTER); + if (new_process_name.empty() && load_process_config.empty()) + load_project_preset(current_process_system_name, Preset::TYPE_PRINT); + std::vector& different_settings = m_print_config.option("different_settings_to_system", true)->values; std::vector& inherits_group = m_print_config.option("inherits_group", true)->values; inherits_group.resize(filament_count + 2, std::string()); diff --git a/src/libslic3r/Preset.cpp b/src/libslic3r/Preset.cpp index e8437f7c0b..cd02465fb0 100644 --- a/src/libslic3r/Preset.cpp +++ b/src/libslic3r/Preset.cpp @@ -976,6 +976,37 @@ void Preset::get_extruder_names_and_keysets(Type type, std::string& extruder_id_ } } +DynamicPrintConfig Preset::load_external_config(Type type, const DynamicPrintConfig &default_config, const DynamicPrintConfig &project_config, + const std::set &different_settings_list, + const std::function &find_base, + t_config_option_keys *keys) +{ + // Load the preset over a default preset, so that the missing fields are filled in from the default preset. + DynamicPrintConfig cfg(default_config); + // SoftFever: ignore print connection info from project + auto cfg_keys = cfg.keys(); + cfg_keys.erase(std::remove_if(cfg_keys.begin(), cfg_keys.end(), + [](std::string &val) { + return val == "print_host" || val == "print_host_webui" || val == "printhost_apikey" || + val == "printhost_cafile" || val == "printhost_user" || val == "printhost_password" || val == "printhost_port"; + }), + cfg_keys.end()); + cfg.apply_only(project_config, cfg_keys, true); + + //add different settings check logic, replace the old system preset's default value with new system preset's default values + if (!different_settings_list.empty()) { + if (DynamicPrintConfig *base_config = find_base(Preset::inherits(cfg))) { + std::string extruder_id_name, extruder_variant_name; + std::set *key_set1 = nullptr, *key_set2 = nullptr; + Preset::get_extruder_names_and_keysets(type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2); + cfg.update_non_diff_values_to_base_config(*base_config, cfg_keys, different_settings_list, extruder_id_name, extruder_variant_name, *key_set1, *key_set2); + } + } + if (keys) + *keys = std::move(cfg_keys); + return cfg; +} + bool Preset::has_lidar(PresetBundle *preset_bundle) { bool has_lidar = false; @@ -2640,20 +2671,6 @@ std::pair PresetCollection::load_external_preset( const Semver file_version, const std::string filament_id) { - // Load the preset over a default preset, so that the missing fields are filled in from the default preset. - DynamicPrintConfig cfg(this->default_preset_for(combined_config).config); - // SoftFever: ignore print connection info from project - auto keys = cfg.keys(); - keys.erase(std::remove_if(keys.begin(), keys.end(), - [](std::string &val) { - return val == "print_host" || val == "print_host_webui" || val == "printhost_apikey" || - val == "printhost_cafile" || val == "printhost_user" || val == "printhost_password" || val == "printhost_port"; - }), - keys.end()); - cfg.apply_only(combined_config, keys, true); - std::string &inherits = Preset::inherits(cfg); - - //add different settings check logic, replace the old system preset's default value with new system preset's default values std::deque::iterator it = this->find_preset_internal(original_name); bool found = it != m_presets.end() && it->name == original_name; if (! found) { @@ -2662,24 +2679,25 @@ std::pair PresetCollection::load_external_preset( found = it != m_presets.end(); } - std::string extruder_id_name, extruder_variant_name; - std::set *key_set1 = nullptr, *key_set2 = nullptr; - Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2); - - if (!inherits.empty() && (different_settings_list.size() > 0)) { - auto iter = this->find_preset_internal(inherits); - if (iter == m_presets.end() || iter->name != inherits) - iter = this->find_preset_renamed(inherits); - if (iter != m_presets.end()) { - //std::vector dirty_options = cfg.diff(iter->config); - BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": change preset %1% inherit %2% 's value to %3% 's values")%original_name %inherits %path; - cfg.update_non_diff_values_to_base_config(iter->config, keys, different_settings_list, extruder_id_name, extruder_variant_name, *key_set1, *key_set2); - } - } - else if (found && it->is_system && (different_settings_list.size() > 0)) { - BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": change preset %1% 's value to %2% 's values")%original_name %path; - cfg.update_non_diff_values_to_base_config(it->config, keys, different_settings_list, extruder_id_name, extruder_variant_name, *key_set1, *key_set2); - } + t_config_option_keys keys; + DynamicPrintConfig cfg = Preset::load_external_config(m_type, this->default_preset_for(combined_config).config, combined_config, different_settings_list, + [this, &original_name, &path, found, it](const std::string &inherits) -> DynamicPrintConfig * { + if (!inherits.empty()) { + auto iter = this->find_preset_internal(inherits); + if (iter == m_presets.end() || iter->name != inherits) + iter = this->find_preset_renamed(inherits); + if (iter == m_presets.end()) + return nullptr; + BOOST_LOG_TRIVIAL(info) << "load_external_preset" << boost::format(": change preset %1% inherit %2% 's value to %3% 's values")%original_name %inherits %path; + return &iter->config; + } + if (found && it->is_system) { + BOOST_LOG_TRIVIAL(info) << "load_external_preset" << boost::format(": change preset %1% 's value to %2% 's values")%original_name %path; + return &it->config; + } + return nullptr; + }, &keys); + std::string &inherits = Preset::inherits(cfg); //BBS: add config related logs BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" enter, type %1% , path %2%, name %3%, original_name %4%, inherits %5%")%Preset::get_type_string(m_type) %path %name %original_name %inherits; diff --git a/src/libslic3r/Preset.hpp b/src/libslic3r/Preset.hpp index 329e835afe..418ba19fc6 100644 --- a/src/libslic3r/Preset.hpp +++ b/src/libslic3r/Preset.hpp @@ -403,6 +403,15 @@ public: std::string get_current_printer_type(PresetBundle *preset_bundle); // get current preset type static void get_extruder_names_and_keysets(Type type, std::string& extruder_id_name, std::string& extruder_variant_name, std::set** p_key_set1, std::set** p_key_set2); + // Config of a preset loaded from a project or config file: the project's values over the type's + // default preset config, without the print-host keys. When different_settings_list is not empty, + // every key not listed in it is then refreshed from the base system preset, which find_base returns + // for the project's "inherits" (nullptr when there is none), with the listed per-variant values + // mapped onto the base's extruder variants. keys, if given, receives the keys taken from the project. + static DynamicPrintConfig load_external_config(Type type, const DynamicPrintConfig &default_config, const DynamicPrintConfig &project_config, + const std::set &different_settings_list, + const std::function &find_base, + t_config_option_keys *keys = nullptr); std::string get_printer_id() const { return vendor ? vendor->id : ""; } bool has_lidar(PresetBundle *preset_bundle); diff --git a/src/libslic3r/PresetBundle.cpp b/src/libslic3r/PresetBundle.cpp index c5b78a8e0f..63e3ba6105 100644 --- a/src/libslic3r/PresetBundle.cpp +++ b/src/libslic3r/PresetBundle.cpp @@ -581,18 +581,20 @@ bool PresetBundle::resolve_preset_config(DynamicPrintConfig &config, Preset::Typ const PresetBundle *PresetBundle::load_source_vendor(const boost::filesystem::path &root_dir, const std::string &vendor_id, ForwardCompatibilitySubstitutionRule compatibility_rule, - std::string &error) + std::string &error, bool allow_cache) { - auto key = std::make_tuple(root_dir.string(), vendor_id, compatibility_rule); + auto key = std::make_tuple(root_dir.string(), vendor_id, compatibility_rule, allow_cache); if (auto it = m_source_vendor_bundles.find(key); it != m_source_vendor_bundles.end()) return it->second.get(); // The library loads with no base of its own, so the tree a vendor inherits from // is the same one that resolves the library's own presets. - const PresetBundle *library = nullptr; + const std::string library_file = std::string(ORCA_FILAMENT_LIBRARY); + const PresetBundle *library = nullptr; if (vendor_id != ORCA_FILAMENT_LIBRARY && - boost::filesystem::is_regular_file(root_dir / (std::string(ORCA_FILAMENT_LIBRARY) + ".json"))) { - library = load_source_vendor(root_dir, ORCA_FILAMENT_LIBRARY, compatibility_rule, error); + (boost::filesystem::is_regular_file(root_dir / (library_file + ".json")) || + (allow_cache && boost::filesystem::is_regular_file(root_dir / (library_file + ".opc"))))) { + library = load_source_vendor(root_dir, ORCA_FILAMENT_LIBRARY, compatibility_rule, error, allow_cache); if (library == nullptr) { error = "OrcaFilamentLibrary contains invalid presets"; return nullptr; @@ -601,7 +603,7 @@ const PresetBundle *PresetBundle::load_source_vendor(const boost::filesystem::pa auto bundle = std::make_unique(); bundle->m_preserve_vendor_source_paths = true; - bundle->load_vendor_configs_from_json(root_dir.string(), vendor_id, LoadSystem, compatibility_rule, library, false); + bundle->load_vendor_configs_from_json(root_dir.string(), vendor_id, LoadSystem, compatibility_rule, library, allow_cache); if (bundle->error_count() != 0) { error = "Vendor bundle contains invalid presets"; return nullptr; @@ -644,6 +646,43 @@ bool PresetBundle::resolve_preset_config_type(DynamicPrintConfig &config, Preset return true; } +bool PresetBundle::resolve_system_preset(DynamicPrintConfig &config, Preset::Type type, const std::string &name, + ForwardCompatibilitySubstitutionRule compatibility_rule, std::string &error) +{ + const std::string vendor_id = find_preset_vendor(name, type); + if (vendor_id.empty()) { + error = "No vendor lists the preset"; + return false; + } + // Release builds ship a vendor as its preset cache alone, without the profile JSONs. + auto installed = [&vendor_id](const fs::path &root) { + return fs::is_regular_file(root / (vendor_id + ".json")) || fs::is_regular_file(root / (vendor_id + ".opc")); + }; + fs::path root_dir = fs::path(data_dir()) / PRESET_SYSTEM_DIR; + if (!installed(root_dir)) + root_dir = fs::path(resources_dir()) / PRESET_PROFILES_DIR; + const bool cache_only = !fs::is_regular_file(root_dir / (vendor_id + ".json")); + + try { + const PresetBundle *vendor = load_source_vendor(root_dir, vendor_id, compatibility_rule, error, cache_only); + if (vendor == nullptr) + return false; + const PresetCollection &collection = type == Preset::TYPE_PRINTER ? vendor->printers : + type == Preset::TYPE_PRINT ? vendor->prints : vendor->filaments; + const Preset *preset = collection.find_preset(name, false); + if (preset == nullptr) { + error = "Preset was not found in its vendor bundle"; + return false; + } + config = preset->config; + } catch (const std::exception &ex) { + error = ex.what(); + return false; + } + error.clear(); + return true; +} + PresetBundle::PresetBundle(const PresetBundle &rhs) { *this = rhs; @@ -4665,6 +4704,15 @@ const std::set ignore_settings_list ={ "print_settings_id", "filament_settings_id", "printer_settings_id" }; +std::set PresetBundle::project_different_keys(const std::string &different_settings) +{ + std::vector keys; + Slic3r::unescape_strings_cstyle(different_settings, keys); + std::set keys_set(keys.begin(), keys.end()); + keys_set.insert(ignore_settings_list.begin(), ignore_settings_list.end()); + return keys_set; +} + DynamicPrintConfig PresetBundle::full_fff_config(bool apply_extruder, std::optional> filament_maps_new, std::optional> filament_volume_maps_new) const { DynamicPrintConfig out; @@ -5372,15 +5420,7 @@ void PresetBundle::load_config_file_config(const std::string &name_or_path, bool if (!is_published) { //BBS: add different settings logic BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": load print preset from print_settings_id"); - std::vector print_different_keys_vector; - std::string print_different_settings = different_values[0]; - Slic3r::unescape_strings_cstyle(print_different_settings, print_different_keys_vector); - std::set print_different_keys_set(print_different_keys_vector.begin(), print_different_keys_vector.end()); - //if (!has_different_settings_to_system) { - // print_different_keys_set.clear(); - //} - //else - print_different_keys_set.insert(ignore_settings_list.begin(), ignore_settings_list.end()); + std::set print_different_keys_set = project_different_keys(different_values[0]); if (!print_compatible_printers.empty()) { ConfigOptionStrings* compatible_printers = config.option("compatible_printers", true); compatible_printers->values = print_compatible_printers; @@ -5391,15 +5431,7 @@ void PresetBundle::load_config_file_config(const std::string &name_or_path, bool //clear compatible printers clear_compatible_printers(config); - std::vector printer_different_keys_vector; - std::string printer_different_settings = different_values[num_filaments + 1]; - Slic3r::unescape_strings_cstyle(printer_different_settings, printer_different_keys_vector); - std::set printer_different_keys_set(printer_different_keys_vector.begin(), printer_different_keys_vector.end()); - //if (!has_different_settings_to_system) { - // printer_different_keys_set.clear(); - //} - //else - printer_different_keys_set.insert(ignore_settings_list.begin(), ignore_settings_list.end()); + std::set printer_different_keys_set = project_different_keys(different_values[num_filaments + 1]); //BBS: add config related logs BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": load printer preset from printer_settings_id"); load_preset(this->printers, num_filaments + 1, "printer_settings_id", printer_different_keys_set, std::string()); @@ -5418,15 +5450,7 @@ void PresetBundle::load_config_file_config(const std::string &name_or_path, bool Preset *loaded = nullptr; //BBS: add different settings logic - std::vector filament_different_keys_vector; - std::string filament_different_settings = different_values[1]; - Slic3r::unescape_strings_cstyle(filament_different_settings, filament_different_keys_vector); - std::set filament_different_keys_set(filament_different_keys_vector.begin(), filament_different_keys_vector.end()); - //if (!has_different_settings_to_system) { - // filament_different_keys_set.clear(); - //} - //else - filament_different_keys_set.insert(ignore_settings_list.begin(), ignore_settings_list.end()); + std::set filament_different_keys_set = project_different_keys(different_values[1]); std::string filament_id = filament_ids[0]; //BBS: add config related logs @@ -5489,15 +5513,7 @@ void PresetBundle::load_config_file_config(const std::string &name_or_path, bool cfg.opt_string("inherits", true) = inherits_values[i + 1]; //BBS: add different settings logic - std::vector filament_different_keys_vector; - std::string filament_different_settings = different_values[i+1]; - Slic3r::unescape_strings_cstyle(filament_different_settings, filament_different_keys_vector); - std::set filament_different_keys_set(filament_different_keys_vector.begin(), filament_different_keys_vector.end()); - //if (!has_different_settings_to_system) { - // filament_different_keys_set.clear(); - //} - //else - filament_different_keys_set.insert(ignore_settings_list.begin(), ignore_settings_list.end()); + std::set filament_different_keys_set = project_different_keys(different_values[i+1]); std::string filament_id = filament_ids[i]; diff --git a/src/libslic3r/PresetBundle.hpp b/src/libslic3r/PresetBundle.hpp index 0bf1bbd5a5..0db1f6d9b1 100644 --- a/src/libslic3r/PresetBundle.hpp +++ b/src/libslic3r/PresetBundle.hpp @@ -235,6 +235,9 @@ public: // ORCA: utility function to find the vendor for a given preset name static std::string find_preset_vendor(const std::string& preset_name, Preset::Type type); + // Keys a project keeps when its presets are loaded: those listed in its escaped + // "different_settings_to_system" entry for the preset, plus the preset bookkeeping keys. + static std::set project_different_keys(const std::string &different_settings); PresetBundle(); PresetBundle(const PresetBundle &rhs); @@ -274,6 +277,10 @@ public: const std::string &source_file, ForwardCompatibilitySubstitutionRule compatibility_rule, std::string &error, bool allow_source_manifest = true); + // Resolve a system preset by name. The vendor tree is read from data_dir()/system when installed + // there, as the GUI reads it, and from the bundled profiles otherwise. + bool resolve_system_preset(DynamicPrintConfig &config, Preset::Type type, const std::string &name, + ForwardCompatibilitySubstitutionRule compatibility_rule, std::string &error); // Load selections (current print, current filaments, current printer) from config.ini // This is done just once on application start up. @@ -808,13 +815,14 @@ private: // Vendor trees loaded by resolve_preset_config's manifest path, so every preset // resolved through this bundle shares one load per source root and vendor. The // filament library is one such tree, shared by every vendor under its root. - std::map, std::unique_ptr> + // A tree read from its preset cache is kept apart: its presets carry no source file. + std::map, std::unique_ptr> m_source_vendor_bundles; const PresetBundle *load_source_vendor(const boost::filesystem::path &root_dir, const std::string &vendor_id, ForwardCompatibilitySubstitutionRule compatibility_rule, - std::string &error); + std::string &error, bool allow_cache = false); // Orca: validation only - flag any printer with two or more compatible // filament presets sharing one filament_id (ambiguous AMS subtype match). diff --git a/tests/cli/CMakeLists.txt b/tests/cli/CMakeLists.txt index 6707159fb2..a0c9f2c078 100644 --- a/tests/cli/CMakeLists.txt +++ b/tests/cli/CMakeLists.txt @@ -15,3 +15,11 @@ set_tests_properties(cli_strict_mode PROPERTIES LABELS "CLI;RequiresApp" SKIP_RETURN_CODE 77 TIMEOUT 900) + +add_test(NAME cli_project_missing_keys + COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_project_missing_keys.sh $ ${ORCA_CLI_TEST_PYTHON} + ${CMAKE_SOURCE_DIR}/resources/profiles/BBL) +set_tests_properties(cli_project_missing_keys PROPERTIES + LABELS "CLI;RequiresApp" + SKIP_RETURN_CODE 77 + TIMEOUT 900) diff --git a/tests/cli/test_cli_project_missing_keys.sh b/tests/cli/test_cli_project_missing_keys.sh new file mode 100644 index 0000000000..4c55709ea0 --- /dev/null +++ b/tests/cli/test_cli_project_missing_keys.sh @@ -0,0 +1,96 @@ +#!/usr/bin/env bash +# End-to-end check that the CLI loads a project's printer and process settings as the GUI does. +# +# The GUI takes every key a project does not list as changed from the project's current system preset: +# keys saved before an option existed, and keys holding an older system value. Keys the project lists +# in different_settings_to_system keep the project's value. A project is exported from the shipped +# Bambu Lab P1S presets; one printer key and one process key are removed, one printer key and one +# process key are changed without being listed, one key is changed and listed, and it is sliced again. +# +# usage: test_cli_project_missing_keys.sh +set -u + +BIN="${1:-}" +PY="${2:-python3}" +PROFILES="${3:-}" +# 77 is the test's SKIP_RETURN_CODE. +[ -x "$BIN" ] || { echo "SKIP: orca-slicer binary not found: $BIN"; exit 77; } +[ -d "$PROFILES" ] || { echo "FAIL: profiles directory not found: $PROFILES"; exit 1; } + +WORK="$(mktemp -d "${TMPDIR:-/tmp}/orca-cli-missing-keys.XXXXXX")" +trap 'rm -rf "$WORK"' EXIT + +"$PY" - "$WORK/cube.stl" <<'EOF' +import sys + +v = [(x, y, z) for z in (0, 10) for y in (0, 10) for x in (0, 10)] +with open(sys.argv[1], "w") as f: + f.write("solid cube\n") + for a, b, c, d in ((0, 2, 3, 1), (4, 5, 7, 6), (0, 1, 5, 4), (2, 6, 7, 3), (0, 4, 6, 2), (1, 3, 7, 5)): + for tri in ((v[a], v[b], v[c]), (v[a], v[c], v[d])): + f.write("facet normal 0 0 0\nouter loop\n") + for p in tri: + f.write("vertex %g %g %g\n" % p) + f.write("endloop\nendfacet\n") + f.write("endsolid cube\n") +EOF + +# slice [option...]: slice into $WORK//out.3mf with a fresh data directory. +slice() { + local out="$WORK/$1" input="$2"; shift 2 + mkdir -p "$out" + timeout 300 "$BIN" --datadir "$out/datadir" "$@" --slice 0 --outputdir "$out" --export-3mf out.3mf "$input" \ + > "$out/log" 2>&1 || { echo "FAIL: $1: orca-slicer exited $?"; tail -n 40 "$out/log"; exit 1; } +} + +slice base "$WORK/cube.stl" \ + --load-settings "$PROFILES/machine/Bambu Lab P1S 0.4 nozzle.json;$PROFILES/process/0.20mm Standard @BBL X1C.json" \ + --load-filaments "$PROFILES/filament/Bambu PLA Basic @BBL P1S 0.4 nozzle.json" + +# The removed keys, with their option defaults from PrintConfig.cpp; stale keys changed without being +# listed as different, which must come back with the system value; and a listed key the project keeps. +"$PY" - "$WORK/base/out.3mf" "$WORK/old.3mf" <<'EOF' || exit $? +import json, sys, zipfile + +src, dst = sys.argv[1], sys.argv[2] +missing = {"extruder_clearance_dist_to_rod": "40", "sparse_infill_density": "20%"} +with zipfile.ZipFile(src) as zin, zipfile.ZipFile(dst, "w", zipfile.ZIP_DEFLATED) as zout: + for item in zin.infolist(): + data = zin.read(item.filename) + if item.filename == "Metadata/project_settings.config": + config = json.loads(data) + for key, default in missing.items(): + if config[key] == default: + print("SKIP: %s is %s in the system preset, the option default, so the test cannot tell them apart" % (key, default)) + sys.exit(77) + expected = {key: config.pop(key) for key in missing} + for key in ("top_shell_layers", "extruder_clearance_height_to_rod"): + expected[key] = config[key] + config[key] = str(int(float(config[key])) + 1) + expected["wall_loops"] = str(int(config["wall_loops"]) + 1) + config["wall_loops"] = expected["wall_loops"] + different = config["different_settings_to_system"] + different[0] = ";".join([k for k in different[0].split(";") if k] + ["wall_loops"]) + data = json.dumps(config, indent=4) + zout.writestr(item, data) +with open(dst + ".expected.json", "w") as f: + json.dump(expected, f) +EOF + +slice project "$WORK/old.3mf" + +"$PY" - "$WORK/project/out.3mf" "$WORK/old.3mf.expected.json" <<'EOF' +import json, sys, zipfile + +with zipfile.ZipFile(sys.argv[1]) as z: + config = json.loads(z.read("Metadata/project_settings.config")) +with open(sys.argv[2]) as f: + expected = json.load(f) +errors = ["%s is %r, want %r" % (key, config.get(key), want) for key, want in expected.items() if config.get(key) != want] +for e in errors: + print("FAIL: " + e) +sys.exit(1 if errors else 0) +EOF +status=$? +[ "$status" -eq 0 ] || { tail -n 40 "$WORK/project/log"; exit 1; } +echo "PASS" diff --git a/tests/libslic3r/test_preset_bundle_loading.cpp b/tests/libslic3r/test_preset_bundle_loading.cpp index 49f0f90214..b1ec3903bb 100644 --- a/tests/libslic3r/test_preset_bundle_loading.cpp +++ b/tests/libslic3r/test_preset_bundle_loading.cpp @@ -5571,6 +5571,35 @@ struct ScopedDataDir ~ScopedDataDir() { set_data_dir(previous); } }; +// resources_dir() is process-wide too; system preset lookups scan its profiles directory. +struct ScopedResourcesDir +{ + std::string previous = resources_dir(); + explicit ScopedResourcesDir(const fs::path &dir) { set_resources_dir(dir.string()); } + ~ScopedResourcesDir() { set_resources_dir(previous); } +}; + +// An "Acme" vendor under root whose "Acme Printer" inherits extruder_clearance_dist_to_rod from an +// abstract base, with the printer in a nested sub_path so the name cannot be derived from the file. +void write_acme_printer_vendor(const fs::path &root, double dist_to_rod) +{ + const fs::path machine_dir = root / "Acme" / "machine"; + fs::create_directories(machine_dir / "nested"); + std::ofstream((root / "Acme.json").string()) + << R"({"version":"1.0.0","name":"Acme",)" + << R"("machine_model_list":[{"name":"Acme One","sub_path":"machine/model.json"}],"machine_list":[)" + << R"({"name":"fdm_acme_common","sub_path":"machine/base.json"},)" + << R"({"name":"Acme Printer","sub_path":"machine/nested/printer.json"}]})"; + std::ofstream((machine_dir / "model.json").string()) + << R"({"type":"machine_model","name":"Acme One","nozzle_diameter":"0.4"})"; + std::ofstream((machine_dir / "base.json").string()) + << R"({"type":"machine","name":"fdm_acme_common","from":"system","instantiation":"false",)" + << R"("extruder_clearance_dist_to_rod":")" << dist_to_rod << R"("})"; + std::ofstream((machine_dir / "nested" / "printer.json").string()) + << R"({"type":"machine","name":"Acme Printer","from":"system","instantiation":"true","inherits":"fdm_acme_common",)" + << R"("printer_model":"Acme One","printer_variant":"0.4"})"; +} + std::string read_file(const fs::path &file) { std::ifstream in(file.string(), std::ios::binary); @@ -5684,3 +5713,230 @@ TEST_CASE("A project saved with pressure advance per filament applies it to ever check_double_vector(pla.opt("filament_flow_ratio")->values, { 0.95, 0.96 }); check_double_vector(petg.opt("filament_flow_ratio")->values, { 0.97 }); } + +TEST_CASE("A system preset resolves by name from the bundled profiles", "[Preset][Bundle]") +{ + ScopedTemporaryDir temp_dir; + ScopedDataDir data(temp_dir.path() / "data"); + ScopedResourcesDir resources(temp_dir.path() / "resources"); + write_acme_printer_vendor(temp_dir.path() / "resources" / "profiles", 33.); + + PresetBundle bundle; + DynamicPrintConfig config; + std::string error; + REQUIRE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Acme Printer", + ForwardCompatibilitySubstitutionRule::EnableSilent, error)); + CHECK(error.empty()); + CHECK_THAT(config.opt_float("extruder_clearance_dist_to_rod"), Catch::Matchers::WithinAbs(33., 1e-6)); +} + +TEST_CASE("A system preset resolves from the data directory copy of its vendor", "[Preset][Bundle]") +{ + ScopedTemporaryDir temp_dir; + ScopedDataDir data(temp_dir.path() / "data"); + ScopedResourcesDir resources(temp_dir.path() / "resources"); + write_acme_printer_vendor(temp_dir.path() / "resources" / "profiles", 33.); + write_acme_printer_vendor(temp_dir.path() / "data" / PRESET_SYSTEM_DIR, 35.); + + PresetBundle bundle; + DynamicPrintConfig config; + std::string error; + REQUIRE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Acme Printer", + ForwardCompatibilitySubstitutionRule::EnableSilent, error)); + CHECK_THAT(config.opt_float("extruder_clearance_dist_to_rod"), Catch::Matchers::WithinAbs(35., 1e-6)); +} + +TEST_CASE("A system preset resolves from a vendor shipped as its preset cache alone", "[Preset][Bundle]") +{ + ScopedTemporaryDir temp_dir; + ScopedDataDir data(temp_dir.path() / "data"); + ScopedResourcesDir resources(temp_dir.path() / "resources"); + const fs::path profiles = temp_dir.path() / "resources" / "profiles"; + write_acme_printer_vendor(profiles, 33.); + + PresetBundle writer; + writer.set_generate_vendor_caches(true); + writer.load_vendor_configs_from_json(profiles.string(), "Acme", PresetBundle::LoadSystem, + ForwardCompatibilitySubstitutionRule::EnableSilent); + REQUIRE(fs::exists(profiles / "Acme.opc")); + // Release builds ship the cache and drop the profile JSONs, manifest included. + fs::remove(profiles / "Acme.json"); + fs::remove_all(profiles / "Acme"); + + PresetBundle bundle; + DynamicPrintConfig config; + std::string error; + REQUIRE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Acme Printer", + ForwardCompatibilitySubstitutionRule::EnableSilent, error)); + CHECK_THAT(config.opt_float("extruder_clearance_dist_to_rod"), Catch::Matchers::WithinAbs(33., 1e-6)); +} + +TEST_CASE("A system preset no vendor lists is not resolved", "[Preset][Bundle]") +{ + ScopedTemporaryDir temp_dir; + ScopedDataDir data(temp_dir.path() / "data"); + ScopedResourcesDir resources(temp_dir.path() / "resources"); + write_acme_printer_vendor(temp_dir.path() / "resources" / "profiles", 33.); + + PresetBundle bundle; + DynamicPrintConfig config; + std::string error; + CHECK_FALSE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Unknown Printer", + ForwardCompatibilitySubstitutionRule::EnableSilent, error)); + CHECK_FALSE(error.empty()); +} + +namespace { + +// A default preset config for type, built the way PresetBundle builds its default presets. +DynamicPrintConfig external_default_config(Preset::Type type) +{ + DynamicPrintConfig config; + config.apply_only(static_cast(FullPrintConfig::defaults()), + type == Preset::TYPE_PRINTER ? Preset::printer_options() : Preset::print_options()); + Preset::inherits(config); + return config; +} + +// A find_base callback that counts its calls and returns base. +auto base_finder(DynamicPrintConfig *base, int &calls) +{ + return [base, &calls](const std::string &) { + ++calls; + return base; + }; +} + +} // namespace + +TEST_CASE("A key missing from a project takes the default preset value when there is no base", "[Preset][ExternalPreset]") +{ + DynamicPrintConfig defaults = external_default_config(Preset::TYPE_PRINT); + defaults.set("wall_loops", 7, true); + const DynamicPrintConfig project; + int calls = 0; + + const DynamicPrintConfig config = Preset::load_external_config(Preset::TYPE_PRINT, defaults, project, {"sparse_infill_density"}, + base_finder(nullptr, calls)); + CHECK(calls == 1); + CHECK(config.opt_int("wall_loops") == 7); +} + +TEST_CASE("A key missing from a project takes its base preset value", "[Preset][ExternalPreset]") +{ + DynamicPrintConfig defaults = external_default_config(Preset::TYPE_PRINT); + defaults.set("wall_loops", 7, true); + DynamicPrintConfig base = defaults; + base.set("wall_loops", 5, true); + const DynamicPrintConfig project; + int calls = 0; + + const DynamicPrintConfig config = Preset::load_external_config(Preset::TYPE_PRINT, defaults, project, {"sparse_infill_density"}, + base_finder(&base, calls)); + CHECK(config.opt_int("wall_loops") == 5); +} + +TEST_CASE("A project key listed as different keeps the project value", "[Preset][ExternalPreset]") +{ + const DynamicPrintConfig defaults = external_default_config(Preset::TYPE_PRINT); + DynamicPrintConfig base = defaults; + base.set("wall_loops", 5, true); + DynamicPrintConfig project; + project.set("wall_loops", 4, true); + int calls = 0; + + const DynamicPrintConfig config = Preset::load_external_config(Preset::TYPE_PRINT, defaults, project, {"wall_loops"}, + base_finder(&base, calls)); + CHECK(config.opt_int("wall_loops") == 4); +} + +TEST_CASE("A project key not listed as different is refreshed to the base value", "[Preset][ExternalPreset]") +{ + const DynamicPrintConfig defaults = external_default_config(Preset::TYPE_PRINT); + DynamicPrintConfig base = defaults; + base.set("wall_loops", 5, true); + DynamicPrintConfig project; + project.set("wall_loops", 4, true); + project.set("inherits", "Base Process", true); + std::string inherits; + + const DynamicPrintConfig config = Preset::load_external_config(Preset::TYPE_PRINT, defaults, project, {"sparse_infill_density"}, + [&base, &inherits](const std::string &name) { + inherits = name; + return &base; + }); + CHECK(inherits == "Base Process"); + CHECK(config.opt_int("wall_loops") == 5); +} + +TEST_CASE("An empty different settings list keeps the project values without a base", "[Preset][ExternalPreset]") +{ + DynamicPrintConfig defaults = external_default_config(Preset::TYPE_PRINT); + defaults.set("top_shell_layers", 7, true); + DynamicPrintConfig base = defaults; + base.set("wall_loops", 5, true); + base.set("top_shell_layers", 9, true); + DynamicPrintConfig project; + project.set("wall_loops", 4, true); + int calls = 0; + + const DynamicPrintConfig config = Preset::load_external_config(Preset::TYPE_PRINT, defaults, project, {}, base_finder(&base, calls)); + CHECK(calls == 0); + CHECK(config.opt_int("wall_loops") == 4); + CHECK(config.opt_int("top_shell_layers") == 7); +} + +TEST_CASE("Print-host keys are never taken from a project", "[Preset][ExternalPreset]") +{ + DynamicPrintConfig defaults = external_default_config(Preset::TYPE_PRINTER); + defaults.set("print_host", "", true); + defaults.set("printhost_apikey", "", true); + DynamicPrintConfig project; + project.set("print_host", "http://project-host", true); + project.set("printhost_apikey", "project-key", true); + project.set("printer_notes", "project notes", true); + t_config_option_keys keys; + int calls = 0; + + const DynamicPrintConfig config = Preset::load_external_config(Preset::TYPE_PRINTER, defaults, project, {"printer_notes"}, + base_finder(nullptr, calls), &keys); + CHECK(config.opt_string("print_host").empty()); + CHECK(config.opt_string("printhost_apikey").empty()); + CHECK(config.opt_string("printer_notes") == "project notes"); + CHECK_FALSE(contains_key(keys, "print_host")); + CHECK_FALSE(contains_key(keys, "printhost_apikey")); + CHECK(contains_key(keys, "printer_notes")); +} + +TEST_CASE("A per-variant project value maps onto its base preset's variant layout", "[Preset][ExternalPreset]") +{ + const DynamicPrintConfig defaults = external_default_config(Preset::TYPE_PRINT); + DynamicPrintConfig base = defaults; + base.set_key_value("print_extruder_id", new ConfigOptionInts({1, 1})); + base.set_key_value("print_extruder_variant", new ConfigOptionStrings({"Direct Drive Standard", "Direct Drive High Flow"})); + base.set_key_value("outer_wall_speed", new ConfigOptionFloats({200., 300.})); + base.set_key_value("inner_wall_speed", new ConfigOptionFloats({250., 350.})); + // A project saved before its printer had a High Flow variant. + DynamicPrintConfig project; + project.set_key_value("print_extruder_id", new ConfigOptionInts({1})); + project.set_key_value("print_extruder_variant", new ConfigOptionStrings({"Direct Drive Standard"})); + project.set_key_value("outer_wall_speed", new ConfigOptionFloats({100.})); + project.set_key_value("inner_wall_speed", new ConfigOptionFloats({150.})); + int calls = 0; + + const DynamicPrintConfig config = Preset::load_external_config(Preset::TYPE_PRINT, defaults, project, {"outer_wall_speed"}, + base_finder(&base, calls)); + CHECK(config.option("print_extruder_variant")->values == + std::vector{"Direct Drive Standard", "Direct Drive High Flow"}); + // The listed key keeps the project's Standard value and takes High Flow from the base. + check_double_vector(config.option("outer_wall_speed")->values, {100., 300.}); + check_double_vector(config.option("inner_wall_speed")->values, {250., 350.}); +} + +TEST_CASE("A project's different settings always keep the preset bookkeeping keys", "[Preset][ExternalPreset]") +{ + const std::set keys = PresetBundle::project_different_keys(escape_strings_cstyle({"wall_loops", "top_shell_layers"})); + for (const char *key : {"wall_loops", "top_shell_layers", "inherits", "print_settings_id", "filament_settings_id", "printer_settings_id"}) + CHECK(keys.count(key) == 1); + CHECK(PresetBundle::project_different_keys(std::string()).count("inherits") == 1); +}