Re-Add libslic3r Includes After the Clipper2 2.0.1 Migration

Rebasing onto main took main's version of the files the Clipper2 migration rewrote, so their added includes are restored here, along with includes for main's new code. Clipper2's individual headers are now ignored by clang-tidy: they only build the Z variant through clipper2_z.hpp, which defines USINGZ first, so including clipper.core.h and the like directly broke ClipperZUtils.cpp.

.claude/skills/orca-wxwidgets/SKILL.md

@@ -30,9 +30,8 @@ how you read the wx docs:
 Look things up in the source the app is built from — it beats memory, and 3.3 changed real behaviour:
 
 ```bash
-WX=$(find -L deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets' 2>/dev/null | head -1)
-# macOS: deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets   Linux, Windows: deps/<tree>/dep_wxWidgets-prefix/...
-# -L follows a worktree's deps/<tree> symlinked to the main checkout. Not a glob: zsh aborts on one that matches nothing.
+WX=$(find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets' | head -1)
+# macOS: deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets   Linux: deps/build/dep_wxWidgets-prefix/...
 # If deps are not built: git clone --depth 1 -b v3.3.2 https://github.com/SoftFever/Orca-deps-wxWidgets
 grep -n "CaptureMouse" -A 30 $WX/interface/wx/window.h      # documented contract (doxygen source)
 grep -rn "@onlyfor\|not implemented" $WX/interface/wx/popupwin.h   # documented platform limits
@@ -41,13 +40,6 @@ grep -n "IsDark" $WX/docs/changes.txt                         # what changed in
 grep -n "NotifyCaptureLost" -r $WX/src/osx $WX/src/gtk $WX/src/msw   # what each port actually does
 ```
 
-On Windows these lookups are bash: run them from Git Bash. PowerShell has no `grep`, and its `find` is
-Windows' text-search `find.exe`. To locate the wx tree from PowerShell:
-
-```powershell
-$WX = Resolve-Path deps\*\dep_wxWidgets-prefix\src\dep_wxWidgets, deps\*\*\dep_wxWidgets-prefix\src\dep_wxWidgets -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty Path
-```
-
 `interface/wx/<class>.h` is the documentation; `src/common` holds shared behaviour and
 `src/{msw,osx,gtk,unix,generic}` the per-port implementation. When the docs and the source disagree,
 the source is what runs — the references mark such facts **[source]**. Orca-side design docs live in

.claude/skills/orca-wxwidgets/references/controls-dataview.md

@@ -331,10 +331,6 @@ OrcaSlicer: integer spinners are `::SpinInput` ([below](#spininput)); progress b
 Contract:
 - A page must be created with the book as its parent and added once; the book owns and deletes it
   (`interface/wx/bookctrl.h:253-254, 273`). `RemovePage` detaches without deleting, and you then own it (`:324-330`).
-- Removing the selected page selects the page before it (the new first page if it was first) through `SetSelection`,
-  so that page is shown and PAGE_CHANGING/CHANGED are sent; removing a page before the selection only shifts the
-  index. This is `wxBookCtrlBase::DoSetSelectionAfterRemoval` (`src/common/bookctrl.cpp:477-495` **[source]**),
-  called from `DoRemovePage` by `wxSimplebook`, `wxChoicebook`, `wxListbook`, `wxToolbook` and Orca's `Notebook`.
 - `GetSelection()` inside a `PAGE_CHANGED` handler may return the old or the new page depending on the platform; use
   `event.GetSelection()` (`interface/wx/bookctrl.h:160-166`).
 - `wxSimplebook` has no UI; switch with `ChangeSelection()`. `SetSelection()` sends PAGE_CHANGING/CHANGED

.claude/skills/orca-wxwidgets/references/mouse-keyboard-focus.md

@@ -10,7 +10,7 @@ wx asserts are compiled out in Orca (`wxDEBUG_LEVEL=0`), so every misuse below t
 an assert fails silently. "GTK" means wxGTK3, Orca's Linux default (X11 and Wayland); GTK2 is only
 an opt-out build (`-DDEP_WX_GTK3=OFF`), noted where it differs. Paths starting `interface/`,
 `include/`, `src/`, `docs/` are in the wx tree
-(located as in `SKILL.md` §Ground truth); Orca paths are
+(`find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets'`); Orca paths are
 relative to `src/slic3r/GUI/`.
 
 Contents: [Rules](#rules) · [Mouse capture](#mouse-capture) · [Mouse events](#mouse-events) ·

.claude/skills/orca-wxwidgets/references/orca-architecture.md

@@ -332,9 +332,7 @@ indices: pages come and go per printer and per feature flag.
   pages depending on the printer and on `use_printer_agents`; a removed page stays registered but is
   not prebuilt (its `LazyPage::in_book()` is false).
 - Plugin pages are appended by `PluginPages::initialize` (`plugin/host/PluginPages.hpp`) with
-  namespaced ids (`plugin.<plugin_key>.<name>`) that cannot collide with `TAB_ID_*`. Each is a
-  `LazyPage<PluginPage>` with order −1, destroyed when its capability goes away.
-  → [Deferred construction](#deferred-construction-lazy-lazypage-stagedbuild-idlescheduler)
+  namespaced ids (`plugin.<plugin_key>.<name>`) that cannot collide with `TAB_ID_*`.
 
 ### Preset tabs
 
@@ -531,32 +529,6 @@ the main frame does nothing to a panel after creating it.
   m_idle.add(m_diff_dialog);
   ```
   Cite: `IdleScheduler::tick`, `docs/HLSD/deferred-page-construction.md`.
-- **Rule:** A lazy page that can be destroyed while the main frame lives takes a negative order and
-  stays out of `m_lazy_pages`.
-  **Why:** `m_lazy_pages` and `PrebuildQueue` hold raw `LazyBase*` and nothing removes one
-  (`PrebuildQueue` has only `add` and `clear`). The queue calls `pending()` on every task each slice,
-  and `prebuild_pages_when_idle` reads every entry of `m_lazy_pages`, so a page destroyed while still
-  listed can be read after it is freed. A page only taken out of the book is fine: it stays registered
-  and its `pending()` is false (`MainFrame::show_device`).
-  ```cpp
-  // Right (PluginPages::create_page): order -1, and no m_lazy_pages.push_back
-  auto* page = new GUI::LazyPage<PluginPage>(m_parent, name, -1, [capability](wxWindow* parent) {
-      return new PluginPage(parent, capability);
-  });
-  ```
-  Cite: `PluginPages::create_page`, `PluginPages::remove_page`.
-- **Rule:** Remove several lazy pages from a book left to right.
-  **Why:** removing the selected page selects and shows the page before it
-  (`references/controls-dataview.md` §Book controls), and showing an unbuilt `LazyPage` while the frame
-  is shown builds it. In any other order the page before the selected one can be one removed next,
-  built only to be destroyed; left to right it is one that stays (unless the selected page is the
-  book's first).
-  ```cpp
-  // Right (PluginPages::shutdown): m_order is the tabs' left-to-right order
-  for (const PluginCapabilityId& id : std::vector<PluginCapabilityId>(m_order))
-      remove_page(id);
-  ```
-  Cite: `PluginPages::shutdown`, `PluginPages::relayout`, `PluginPages::on_plugin_deregister`.
 
 ## Plater and Sidebar
 

.claude/skills/orca-wxwidgets/references/painting-custom-widgets.md

@@ -6,7 +6,7 @@ to write a custom control on the wx side and how to author an Orca widget on the
 `StaticBox`/`StateHandler` foundation. Read it before writing or reviewing any `wxEVT_PAINT`
 handler, `render`/`doRender` method, `messureSize`, or a new class under `src/slic3r/GUI/Widgets/`.
 
-wx cites are relative to the pinned wx 3.3.2 tree (located as in `SKILL.md` §Ground truth).
+wx cites are relative to the pinned wx 3.3.2 tree (`deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets`).
 Orca builds wx with `wxBUILD_DEBUG_LEVEL=0` and `libslic3r_gui` with `wxDEBUG_LEVEL=0`: every
 wx assert below is compiled out and `wxCHECK*` returns silently, so paint misuse shows up only as
 wrong, missing or stale pixels, never as an assert dialog.

.claude/skills/orca-wxwidgets/references/platforms.md

@@ -78,9 +78,8 @@ Contents: [Rules](#rules) · [The wx build Orca uses](#the-wx-build-orca-uses)
   `references/colours-dark-mode.md`.
 - The checked-out source is the tree that every wx citation in this skill refers to:
   `deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets` on macOS and
-  `deps/<tree>/dep_wxWidgets-prefix/src/dep_wxWidgets` on Linux and Windows (`deps/build` for a
-  release build; `build_win.bat` names the others). Locate it with the bash or PowerShell lookup in
-  `SKILL.md` §Ground truth. On macOS its
+  `deps/build/dep_wxWidgets-prefix/src/dep_wxWidgets` on Linux. Find it with
+  `find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets'`. On macOS its
   `src/osx/cocoa/colour.mm` already has the patch applied.
 - **Flatpak builds wx separately.** `deps/CMakeLists.txt` leaves `dep_wxWidgets` out of the deps
   target when `FLATPAK` is set. Instead, `scripts/flatpak/com.orcaslicer.OrcaSlicer.yml` has its own

.claude/skills/orca-wxwidgets/references/popups-menus.md

@@ -5,7 +5,7 @@ How wx 3.3.2 popups and menus behave on each port, and the Orca wrappers built o
 `append_menu_item`, `Plater::PopupMenu` and the macOS menubar versus `BBLTopbar`. Read it before you add
 or change anything that opens over other UI and must close by itself, or any context menu or menubar item.
 
-wx cites are relative to the wx tree root (located as in `SKILL.md` §Ground truth).
+wx cites are relative to the wx tree root (`deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets`).
 **[source]** marks behaviour derived from the implementation that the wx docs do not state or contradict.
 Orca builds wx with `wxBUILD_DEBUG_LEVEL=0`, so every "asserts" below means "fails silently in Orca".
 "GTK" means wxGTK3 (X11 and Wayland), the default Linux build; GTK2 is only an opt-out (`-DDEP_WX_GTK3=OFF`).

.claude/skills/orca-wxwidgets/references/threads-timers-app.md

@@ -7,7 +7,7 @@ yields and nested event loops, progress dialogs, startup, shutdown and exception
 screen, and the access rules for `wxGetApp()` and `app_config`. Read it whenever code runs off the
 main thread, defers work, starts a timer, yields, shows progress, or runs during startup or shutdown.
 
-wx cites are relative to the pinned wx 3.3.2 tree (located as in `SKILL.md` §Ground truth).
+wx cites are relative to the pinned wx 3.3.2 tree (`deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets`).
 Orca builds wx with `wxBUILD_DEBUG_LEVEL=0` and `libslic3r_gui` with `wxDEBUG_LEVEL=0`, so `wxASSERT`
 is compiled out and `wxCHECK*` returns silently: a timer started off the main thread never fires on macOS,
 `Exit()` on a loop that is not the active one is ignored, `Start(0)` on macOS fails — all without

.claude/skills/orca-wxwidgets/references/windows-dialogs.md

@@ -6,9 +6,10 @@ port; what Orca's `DPIDialog`/`DPIFrame` add; the Orca dialog recipe; and the `M
 Read it before writing or reviewing any dialog, frame, close handler, `Destroy()`/`delete`, or code
 that keeps a pointer to a window across an event, a `CallAfter` or a modal loop.
 
-wx cites are relative to the pinned wx 3.3.2 tree (located as in `SKILL.md` §Ground truth). wx is
-built with `wxBUILD_DEBUG_LEVEL=0` and `libslic3r_gui` with `wxDEBUG_LEVEL=0`: every wx assert
-quoted below is compiled out, so misuse fails silently (dropped call, stuck loop, freed memory), never with an assert dialog. "GTK" below
+wx cites are relative to the pinned wx 3.3.2 tree (`find deps -maxdepth 5 -type d -path
+'*dep_wxWidgets-prefix/src/dep_wxWidgets'`). wx is built with `wxBUILD_DEBUG_LEVEL=0` and
+`libslic3r_gui` with `wxDEBUG_LEVEL=0`: every wx assert quoted below is compiled out, so misuse
+fails silently (dropped call, stuck loop, freed memory), never with an assert dialog. "GTK" below
 means wxGTK as Orca builds it on Linux: GTK3 by default (X11 or Wayland); GTK2 is only an opt-out.
 
 Contents: [Rules](#rules) · [1 Creating and parenting](#1-creating-and-parenting-windows) ·

.claude/skills/orca-wxwidgets/references/wx-33-changes.md

@@ -14,7 +14,7 @@ Contents: [Rules](#rules) · [1 Reading the change logs](#1-reading-the-change-l
 [8 Migration done in Orca](#8-migration-already-done-in-orca)
 
 All `docs/`, `interface/`, `include/`, `src/`, `build/` cites are relative to the pinned wx tree
-(located as in `SKILL.md` §Ground truth), except paths
+(`find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets'`), except paths
 explicitly called Orca's (`deps/…`, Orca's `src/CMakeLists.txt`) and bare Orca file + symbol cites.
 
 ## Rules

src/OrcaSlicer.cpp

@@ -685,6 +685,162 @@ static void load_default_gcodes_to_config(DynamicPrintConfig& config, Preset::Ty
     }
 }
 
+static int load_assemble_plate_list(std::string config_file, std::vector<assemble_plate_info_t> &assemble_plate_info_list)
+{
+    int ret = 0;
+    boost::filesystem::path directory_path(config_file);
+
+    BOOST_LOG_TRIVIAL(info) << boost::format("%1% enter, file %2%")%__FUNCTION__ % config_file;
+    if (!fs::exists(directory_path)) {
+        BOOST_LOG_TRIVIAL(error) << boost::format("directory %1% not exist.")%config_file;
+        return CLI_FILE_NOTFOUND;
+    }
+
+    try {
+        json root_json;
+        boost::nowide::ifstream ifs(config_file);
+        ifs >> root_json;
+        ifs.close();
+
+        int plate_count = root_json[JSON_ASSEMPLE_PLATES].size();
+        if ((plate_count <= 0) || (plate_count > MAX_PLATE_COUNT)) {
+            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid plate count %1%")%plate_count;
+            return CLI_CONFIG_FILE_ERROR;
+        }
+        assemble_plate_info_list.resize(plate_count);
+
+        for (int plate_index = 0; plate_index < plate_count; plate_index++)
+        {
+            assemble_plate_info_t &assemble_plate = assemble_plate_info_list[plate_index];
+            const json& plate_json = root_json[JSON_ASSEMPLE_PLATES][plate_index];
+            assemble_plate.plate_name = plate_json[JSON_ASSEMPLE_PLATE_NAME];
+            assemble_plate.need_arrange = plate_json[JSON_ASSEMPLE_PLATE_NEED_ARRANGE];
+
+            if (plate_json.contains(JSON_ASSEMPLE_PLATE_PARAMS)) {
+                assemble_plate.plate_params = plate_json[JSON_ASSEMPLE_PLATE_PARAMS].get<std::map<std::string, std::string>>();
+                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
+            }
+
+            int object_count = plate_json[JSON_ASSEMPLE_OBJECTS].size();
+            if (object_count <= 0) {
+                BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid object count %1% in plate %2%")%object_count %(plate_index+1);
+                return CLI_CONFIG_FILE_ERROR;
+            }
+
+            assemble_plate.assemble_obj_list.resize(object_count);
+            for (int object_index = 0; object_index < object_count; object_index++)
+            {
+                assemble_object_info_t& assemble_object = assemble_plate.assemble_obj_list[object_index];
+                const json& object_json = plate_json[JSON_ASSEMPLE_OBJECTS][object_index];
+
+                assemble_object.path = object_json[JSON_ASSEMPLE_OBJECT_PATH];
+                assemble_object.count = object_json[JSON_ASSEMPLE_OBJECT_COUNT];
+
+                if (assemble_object.count <= 0) {
+                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": invalid object clone count %1% in plate %2% Object %3%") % assemble_object.count % (plate_index + 1) % assemble_object.path;
+                    return CLI_CONFIG_FILE_ERROR;
+                }
+
+                assemble_object.filaments = object_json.at(JSON_ASSEMPLE_OBJECT_FILAMENTS).get<std::vector<int>>();
+                if ((assemble_object.filaments.size() > 0) && (assemble_object.filaments.size() != assemble_object.count) && (assemble_object.filaments.size() != 1))
+                {
+                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s filaments count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.filaments.size() % assemble_object.count;
+                    return CLI_CONFIG_FILE_ERROR;
+                }
+
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX)) {
+                    assemble_object.assemble_index = object_json[JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX].get<std::vector<int>>();
+                    if ((assemble_object.assemble_index.size() > 0) && (assemble_object.assemble_index.size() != assemble_object.count) && (assemble_object.assemble_index.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s assemble_index count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.assemble_index.size() % assemble_object.count;
+                        return CLI_CONFIG_FILE_ERROR;
+                    }
+                }
+
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_X)) {
+                    assemble_object.pos_x = object_json[JSON_ASSEMPLE_OBJECT_POS_X].get<std::vector<float>>();
+                    if ((assemble_object.pos_x.size() > 0) && (assemble_object.pos_x.size() != assemble_object.count) && (assemble_object.pos_x.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_x count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_x.size() % assemble_object.count;
+                        return CLI_CONFIG_FILE_ERROR;
+                    }
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Y)) {
+                    assemble_object.pos_y = object_json[JSON_ASSEMPLE_OBJECT_POS_Y].get<std::vector<float>>();
+                    if ((assemble_object.pos_y.size() > 0) && (assemble_object.pos_y.size() != assemble_object.count) && (assemble_object.pos_y.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_y count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_y.size() % assemble_object.count;
+                        return CLI_CONFIG_FILE_ERROR;
+                    }
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Z)) {
+                    assemble_object.pos_z = object_json[JSON_ASSEMPLE_OBJECT_POS_Z].get<std::vector<float>>();
+                    if ((assemble_object.pos_z.size() > 0) && (assemble_object.pos_z.size() != assemble_object.count) && (assemble_object.pos_z.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_z count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_z.size() % assemble_object.count;
+                        return CLI_CONFIG_FILE_ERROR;
+                    }
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
+                    assemble_object.print_params = object_json[JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
+                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% print params") % (plate_index + 1) %assemble_object.path % assemble_object.print_params.size();
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
+                    json height_range_json = object_json[JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
+                    int range_count = height_range_json.size();
+
+                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% height ranges") % (plate_index + 1) %assemble_object.path % range_count;
+
+                    assemble_object.height_ranges.resize(range_count);
+                    for (int range_index = 0; range_index < range_count; range_index++)
+                    {
+                        height_range_info_t& height_range = assemble_object.height_ranges[range_index];
+                        height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
+                        height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
+                        height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
+                    }
+                }
+            }
+            if (plate_json.contains(JSON_ASSEMPLE_ASSEMBLE_PARAMS)) {
+                json assemble_params_json = plate_json[JSON_ASSEMPLE_ASSEMBLE_PARAMS];
+                int assemble_count = assemble_params_json.size();
+                for (int i = 0; i < assemble_count; i++)
+                {
+                    assembled_param_info_t assembled_param;
+                    int assemble_index = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX];
+                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
+                        assembled_param.print_params = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
+                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% print params") % (plate_index + 1) %i % assembled_param.print_params.size();
+                    }
+                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
+                        json height_range_json = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
+                        int range_count = height_range_json.size();
+
+                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% height ranges") % (plate_index + 1) %i % range_count;
+
+                        assembled_param.height_ranges.resize(range_count);
+                        for (int range_index = 0; range_index < range_count; range_index++)
+                        {
+                            height_range_info_t& height_range = assembled_param.height_ranges[range_index];
+                            height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
+                            height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
+                            height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
+                        }
+                    }
+                    assemble_plate.assembled_param_list.emplace(assemble_index, std::move(assembled_param));
+                }
+                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
+            }
+        }
+    }
+    catch(std::exception &err) {
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse file "<<config_file<<" got a generic exception, reason = " << err.what();
+        ret = CLI_CONFIG_FILE_ERROR;
+    }
+
+    return ret;
+}
+
 void merge_or_add_object(assemble_plate_info_t& assemble_plate_info, Model &model, int assemble_index, std::map<int, ModelObject*> &merged_objects, ModelObject *ori_object)
 {
     if (assemble_index > 0) {
@@ -1750,14 +1906,6 @@ int CLI::run(int argc, char **argv)
 
                     BOOST_LOG_TRIVIAL(info) << boost::format("current_printer_name %1%, current_process_name %2%")%current_printer_name %current_process_name;
                     ConfigOptionStrings* option_strings = config.option<ConfigOptionStrings>("inherits_group");
-                    // One entry for the process, one per filament and one for the printer. A group of another
-                    // length still has the process first and the printer last; one too short for that is ignored.
-                    if (option_strings && option_strings->values.size() != current_filaments_name.size() + 2) {
-                        boost::nowide::cerr << "Warning: inherits_group has " << option_strings->values.size() << " entries, expected "
-                                            << current_filaments_name.size() + 2 << " for " << current_filaments_name.size() << " filaments" << std::endl;
-                        if (option_strings->values.size() < 2)
-                            option_strings = nullptr;
-                    }
                     if (option_strings) {
                         current_inherits_group = option_strings->values;
                         size_t size = current_inherits_group.size();
@@ -1779,11 +1927,14 @@ int CLI::run(int argc, char **argv)
                             BOOST_LOG_TRIVIAL(info) << boost::format("inherits of process valid, current_process_system_name is %1%") %current_process_system_name;
                         }
 
-                        // A filament without an entry of its own counts as a system preset.
-                        current_filaments_system_name = current_filaments_name;
-                        for (size_t index = 1; index < size - 1 && index <= current_filaments_name.size(); index++) {
-                            if (!current_inherits_group[index].empty())
+                        current_filaments_system_name.resize(size - 2);
+                        for (int index = 1; index < (size - 1); index++) {
+                            if (current_inherits_group[index].empty()) {
+                                current_filaments_system_name[index-1] = current_filaments_name[index-1];
+                            }
+                            else {
                                 current_filaments_system_name[index-1] = current_inherits_group[index];
+                            }
                         }
                     }
                     else {
@@ -1916,12 +2067,7 @@ int CLI::run(int argc, char **argv)
         //parse the json and assemble object here
         Model model;
 
-        AssembleListResult list_result = load_assemble_plate_list(load_assemble_list, assemble_plate_info_list, MAX_PLATE_COUNT);
-        int ret = CLI_SUCCESS;
-        if (list_result == AssembleListResult::FileNotFound)
-            ret = CLI_FILE_NOTFOUND;
-        else if (list_result == AssembleListResult::ConfigError)
-            ret = CLI_CONFIG_FILE_ERROR;
+        int ret = load_assemble_plate_list(load_assemble_list, assemble_plate_info_list);
         if (ret) {
             record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
             flush_and_exit(ret);
@@ -2677,37 +2823,6 @@ int CLI::run(int argc, char **argv)
         fetch_compatible_values = true;
     }
 
-    // Refresh every project filament no loaded filament replaces from its current system preset, as the GUI
-    // does when it loads the project; the filament merge below keeps the keys the project lists as changed.
-    // Entries stay in slot order, which the merge's variant bookkeeping relies on.
-    std::vector<bool> load_filaments_refresh(load_filaments_config.size(), false);
-    if (is_bbl_3mf && new_printer_name.empty()) {
-        const ConfigOptionStrings *project_filament_ids = m_print_config.option<ConfigOptionStrings>("filament_ids");
-        for (size_t index = 0; index < current_filaments_system_name.size(); index++) {
-            const int slot = static_cast<int>(index) + 1;
-            if (std::find(load_filaments_index.begin(), load_filaments_index.end(), slot) != load_filaments_index.end())
-                continue;
-            std::string system_name = current_filaments_system_name[index];
-            if (system_name.empty())
-                continue;
-            PresetBundle::convert_filament_preset_name(current_printer_name, system_name);
-            DynamicPrintConfig config;
-            std::string        error;
-            if (!ensure_system_preset_resolver().resolve_system_preset(config, Preset::TYPE_FILAMENT, system_name, config_substitution_rule, error)) {
-                BOOST_LOG_TRIVIAL(warning) << boost::format("CLI: system filament preset '%1%' not resolved (%2%); filament %3% keeps its values") % system_name % error % slot;
-                continue;
-            }
-            const size_t at = std::upper_bound(load_filaments_index.begin(), load_filaments_index.end(), slot) - load_filaments_index.begin();
-            load_filaments_id.insert(load_filaments_id.begin() + at,
-                project_filament_ids != nullptr && index < project_filament_ids->size() ? project_filament_ids->values[index] : std::string());
-            load_filaments_name.insert(load_filaments_name.begin() + at, system_name);
-            load_filaments_config.insert(load_filaments_config.begin() + at, std::move(config));
-            load_filaments_index.insert(load_filaments_index.begin() + at, slot);
-            load_filaments_inherit.insert(load_filaments_inherit.begin() + at, system_name);
-            load_filaments_refresh.insert(load_filaments_refresh.begin() + at, true);
-        }
-    }
-
     //fetch upward_compatible_machine
     if (fetch_upward_values) {
         if (!current_printer_system_name.empty()) {
@@ -3398,7 +3513,7 @@ int CLI::run(int argc, char **argv)
     }
 
     //set the filament settings into print config
-    if ((load_filament_count > 0) || (up_config_to_date) || !load_filaments_config.empty())
+    if ((load_filament_count > 0) || (up_config_to_date))
     {
         //std::vector<int> filament_variant_count(filament_count, 1);
         std::vector<int> old_start_indice(filament_count, 0);
@@ -3457,8 +3572,6 @@ int CLI::run(int argc, char **argv)
         for (int index = 0; index < load_filaments_config.size(); index++) {
             DynamicPrintConfig&  config = load_filaments_config[index];
             int filament_index = load_filaments_index[index];
-            // A filament given with --load-filaments replaces the slot; a refreshed one keeps the project's changed keys.
-            const bool loaded = load_filament_count > 0 && !load_filaments_refresh[index];
             std::vector<std::string> different_keys;
 
             //ORCA: diff before load_default_gcodes_to_config, the way the process and machine
@@ -3468,12 +3581,12 @@ int CLI::run(int argc, char **argv)
             //      compared" to "compared as empty against the parent" and land in the column
             //      as an override the user never made.
             std::string filament_different_settings;
-            if (loaded)
+            if (load_filament_count > 0)
                 filament_different_settings = cli_different_settings(config, load_filaments_inherit[index], Preset::TYPE_FILAMENT);
 
             load_default_gcodes_to_config(config, Preset::TYPE_FILAMENT);
 
-            if (loaded) {
+            if (load_filament_count > 0) {
                 ConfigOptionStrings *opt_filament_settings = static_cast<ConfigOptionStrings *> (m_print_config.option("filament_settings_id", true));
                 std::string& filament_name = load_filaments_name[index];
                 ConfigOptionString* filament_name_setting = new ConfigOptionString(filament_name);
@@ -3545,7 +3658,7 @@ int CLI::run(int argc, char **argv)
                     flush_and_exit(CLI_CONFIG_FILE_ERROR);
                 }
 
-                if (!loaded && !different_keys_set.empty())
+                if ((load_filament_count == 0) && !different_keys_set.empty())
                 {
                     std::set<std::string>::iterator iter = different_keys_set.find(opt_key);
                     if ( iter != different_keys_set.end()) {
@@ -4735,11 +4848,6 @@ int CLI::run(int argc, char **argv)
                 record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                 flush_and_exit(CLI_INVALID_PARAMS);
             }
-            if (m_models.empty()) {
-                boost::nowide::cerr << "Invalid params: --assemble needs at least one input model." << std::endl;
-                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
-                flush_and_exit(CLI_INVALID_PARAMS);
-            }
             Model m;
             ModelObject* new_object = m.add_object();
             new_object->name = _u8L("Assembly");
@@ -5680,7 +5788,7 @@ int CLI::run(int argc, char **argv)
                         float w = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("prime_tower_width"))->value;
                         float a = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("wipe_tower_rotation_angle"))->value;
                         float v = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("prime_volume"))->value;
-                        unsigned int filaments_cnt = (plate_data_src.size() >= static_cast<size_t>(plate_to_slice)) ? plate_data_src[plate_to_slice-1]->slice_filaments_info.size() : 0;
+                        unsigned int filaments_cnt = plate_data_src[plate_to_slice-1]->slice_filaments_info.size();
                         if ((filaments_cnt == 0) || need_skip)
                         {
                             // slice filaments info invalid

src/OrcaSlicer.hpp

@@ -12,7 +12,6 @@
 
 #include "libslic3r/Config.hpp"
 #include "libslic3r/Model.hpp"
-#include "libslic3r/Format/AssembleList.hpp"
 
 namespace Slic3r {
 
@@ -27,6 +26,64 @@ namespace IO {
     };
 }
 
+#define JSON_ASSEMPLE_PLATES                   "plates"
+#define JSON_ASSEMPLE_PLATE_PARAMS             "plate_params"
+#define JSON_ASSEMPLE_PLATE_NAME               "plate_name"
+#define JSON_ASSEMPLE_PLATE_NEED_ARRANGE       "need_arrange"
+#define JSON_ASSEMPLE_OBJECTS                  "objects"
+#define JSON_ASSEMPLE_OBJECT_PATH              "path"
+#define JSON_ASSEMPLE_OBJECT_COUNT             "count"
+#define JSON_ASSEMPLE_OBJECT_FILAMENTS         "filaments"
+#define JSON_ASSEMPLE_OBJECT_POS_X             "pos_x"
+#define JSON_ASSEMPLE_OBJECT_POS_Y             "pos_y"
+#define JSON_ASSEMPLE_OBJECT_POS_Z             "pos_z"
+#define JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX    "assemble_index"
+#define JSON_ASSEMPLE_OBJECT_PRINT_PARAMS      "print_params"
+#define JSON_ASSEMPLE_ASSEMBLE_PARAMS         "assembled_params"
+
+
+#define JSON_ASSEMPLE_OBJECT_MIN_Z              "min_z"
+#define JSON_ASSEMPLE_OBJECT_MAX_Z              "max_z"
+#define JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES      "height_ranges"
+#define JSON_ASSEMPLE_OBJECT_RANGE_PARAMS       "range_params"
+
+typedef struct _height_range_info {
+    float         min_z;
+    float         max_z;
+
+    std::map<std::string, std::string> range_params;
+}height_range_info_t;
+
+typedef struct _assembled_param_info {
+    std::map<std::string, std::string> print_params;
+    std::vector<height_range_info_t> height_ranges;
+}assembled_param_info_t;
+
+typedef struct _assemble_object_info {
+    std::string         path;
+    int                 count;
+
+    std::vector<int>    filaments;
+    std::vector<int>    assemble_index;
+    std::vector<float>  pos_x;
+    std::vector<float>  pos_y;
+    std::vector<float>  pos_z;
+    std::map<std::string, std::string> print_params;
+    std::vector<height_range_info_t> height_ranges;
+}assemble_object_info_t;
+
+typedef struct _assemble_plate_info {
+    std::string         plate_name;
+    bool                need_arrange {false};
+    int                 filaments_count {0};
+
+    std::map<std::string, std::string> plate_params;
+    std::vector<assemble_object_info_t> assemble_obj_list;
+    std::vector<ModelObject *> loaded_obj_list;
+    std::map<int, assembled_param_info_t> assembled_param_list;
+}assemble_plate_info_t;
+
+
 typedef struct _printer_plate_info {
     std::string         printer_name;
     int                 printable_width{0};

src/libslic3r/AABBTreeLines.hpp

@@ -358,7 +358,7 @@ namespace AABBTreeLines {
             return dist;
         }
 
-        std::vector<size_t> all_lines_in_radius(const Vec<LineType::Dim, Scalar>& point, Floating radius) const
+        std::vector<size_t> all_lines_in_radius(const Vec<LineType::Dim, Scalar>& point, Floating radius)
         {
             return AABBTreeLines::all_lines_in_radius(this->lines, this->tree, point.template cast<Floating>(), radius * radius);
         }

src/libslic3r/CMakeLists.txt

@@ -202,8 +202,6 @@ set(lisbslic3r_sources
     Format/3mf.hpp
     Format/AMF.cpp
     Format/AMF.hpp
-    Format/AssembleList.cpp
-    Format/AssembleList.hpp
     Format/DRC.cpp
     Format/DRC.hpp
     Format/bbs_3mf.cpp

src/libslic3r/Config.cpp

@@ -871,6 +871,19 @@ ConfigSubstitutions ConfigBase::load_from_json(const std::string &file, ForwardC
     return std::move(substitutions_ctxt.substitutions);
 }
 
+// Case-insensitive compare of a JSON key against a fixed ASCII one, without
+// boost::iequals, whose std::locale() takes a lock the whole process shares in the
+// MSVC runtime.
+static bool ascii_iequals(const std::string &key, const char *literal)
+{
+    auto lower = [](char c) { return (c >= 'A' && c <= 'Z') ? char(c - 'A' + 'a') : c; };
+    size_t i = 0;
+    for (; i < key.size() && literal[i] != '\0'; ++ i)
+        if (lower(key[i]) != lower(literal[i]))
+            return false;
+    return i == key.size() && literal[i] == '\0';
+}
+
 int ConfigBase::load_from_json(const std::string &file, ConfigSubstitutionContext& substitution_context, bool load_inherits_to_config, std::map<std::string, std::string>& key_values, std::string& reason)
 {
     json j;

src/libslic3r/ExtrusionEntityCollection.hpp

@@ -175,23 +175,6 @@ private:
     bool is_reverse{true};
 };
 
-// Calls `f` for every ExtrusionPath in `entity`, descending into collections, loops and multi-paths.
-template<typename F> void for_each_extrusion_path(const ExtrusionEntity &entity, F &&f)
-{
-    if (auto *collection = dynamic_cast<const ExtrusionEntityCollection *>(&entity)) {
-        for (const ExtrusionEntity *child : collection->entities)
-            for_each_extrusion_path(*child, f);
-    } else if (auto *loop = dynamic_cast<const ExtrusionLoop *>(&entity)) {
-        for (const ExtrusionPath &path : loop->paths)
-            f(path);
-    } else if (auto *multi_path = dynamic_cast<const ExtrusionMultiPath *>(&entity)) {
-        for (const ExtrusionPath &path : multi_path->paths)
-            f(path);
-    } else if (auto *path = dynamic_cast<const ExtrusionPath *>(&entity)) {
-        f(*path);
-    }
-}
-
 } // namespace Slic3r
 
 #endif

src/libslic3r/Format/AssembleList.cpp

@@ -1,204 +0,0 @@
-#include "AssembleList.hpp"
-
-#include <algorithm>
-
-#include <boost/filesystem.hpp>
-#include <boost/format.hpp>
-#include <boost/log/trivial.hpp>
-#include <boost/nowide/fstream.hpp>
-
-#include "nlohmann/json.hpp"
-
-#define JSON_ASSEMPLE_PLATES                   "plates"
-#define JSON_ASSEMPLE_PLATE_PARAMS             "plate_params"
-#define JSON_ASSEMPLE_PLATE_NAME               "plate_name"
-#define JSON_ASSEMPLE_PLATE_NEED_ARRANGE       "need_arrange"
-#define JSON_ASSEMPLE_OBJECTS                  "objects"
-#define JSON_ASSEMPLE_OBJECT_PATH              "path"
-#define JSON_ASSEMPLE_OBJECT_COUNT             "count"
-#define JSON_ASSEMPLE_OBJECT_FILAMENTS         "filaments"
-#define JSON_ASSEMPLE_OBJECT_POS_X             "pos_x"
-#define JSON_ASSEMPLE_OBJECT_POS_Y             "pos_y"
-#define JSON_ASSEMPLE_OBJECT_POS_Z             "pos_z"
-#define JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX    "assemble_index"
-#define JSON_ASSEMPLE_OBJECT_PRINT_PARAMS      "print_params"
-#define JSON_ASSEMPLE_ASSEMBLE_PARAMS         "assembled_params"
-
-
-#define JSON_ASSEMPLE_OBJECT_MIN_Z              "min_z"
-#define JSON_ASSEMPLE_OBJECT_MAX_Z              "max_z"
-#define JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES      "height_ranges"
-#define JSON_ASSEMPLE_OBJECT_RANGE_PARAMS       "range_params"
-
-namespace Slic3r {
-
-using json = nlohmann::json;
-
-AssembleListResult load_assemble_plate_list(const std::string &config_file, std::vector<assemble_plate_info_t> &assemble_plate_info_list, int max_plate_count)
-{
-    AssembleListResult ret = AssembleListResult::Success;
-    boost::filesystem::path directory_path(config_file);
-
-    BOOST_LOG_TRIVIAL(info) << boost::format("%1% enter, file %2%")%__FUNCTION__ % config_file;
-    if (!boost::filesystem::exists(directory_path)) {
-        BOOST_LOG_TRIVIAL(error) << boost::format("directory %1% not exist.")%config_file;
-        return AssembleListResult::FileNotFound;
-    }
-
-    try {
-        json root_json;
-        boost::nowide::ifstream ifs(config_file);
-        ifs >> root_json;
-        ifs.close();
-
-        int plate_count = root_json[JSON_ASSEMPLE_PLATES].size();
-        if ((plate_count <= 0) || (plate_count > max_plate_count)) {
-            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid plate count %1%")%plate_count;
-            return AssembleListResult::ConfigError;
-        }
-        assemble_plate_info_list.resize(plate_count);
-
-        for (int plate_index = 0; plate_index < plate_count; plate_index++)
-        {
-            assemble_plate_info_t &assemble_plate = assemble_plate_info_list[plate_index];
-            const json& plate_json = root_json[JSON_ASSEMPLE_PLATES][plate_index];
-            assemble_plate.plate_name = plate_json[JSON_ASSEMPLE_PLATE_NAME];
-            assemble_plate.need_arrange = plate_json[JSON_ASSEMPLE_PLATE_NEED_ARRANGE];
-
-            if (plate_json.contains(JSON_ASSEMPLE_PLATE_PARAMS)) {
-                assemble_plate.plate_params = plate_json[JSON_ASSEMPLE_PLATE_PARAMS].get<std::map<std::string, std::string>>();
-                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
-            }
-
-            int object_count = plate_json[JSON_ASSEMPLE_OBJECTS].size();
-            if (object_count <= 0) {
-                BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid object count %1% in plate %2%")%object_count %(plate_index+1);
-                return AssembleListResult::ConfigError;
-            }
-
-            assemble_plate.assemble_obj_list.resize(object_count);
-            for (int object_index = 0; object_index < object_count; object_index++)
-            {
-                assemble_object_info_t& assemble_object = assemble_plate.assemble_obj_list[object_index];
-                const json& object_json = plate_json[JSON_ASSEMPLE_OBJECTS][object_index];
-
-                assemble_object.path = object_json[JSON_ASSEMPLE_OBJECT_PATH];
-                assemble_object.count = object_json[JSON_ASSEMPLE_OBJECT_COUNT];
-
-                if (assemble_object.count <= 0) {
-                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": invalid object clone count %1% in plate %2% Object %3%") % assemble_object.count % (plate_index + 1) % assemble_object.path;
-                    return AssembleListResult::ConfigError;
-                }
-
-                assemble_object.filaments = object_json.at(JSON_ASSEMPLE_OBJECT_FILAMENTS).get<std::vector<int>>();
-                if (assemble_object.filaments.empty())
-                {
-                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s filaments list is empty") % assemble_object.path;
-                    return AssembleListResult::ConfigError;
-                }
-                if ((assemble_object.filaments.size() != assemble_object.count) && (assemble_object.filaments.size() != 1))
-                {
-                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s filaments count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.filaments.size() % assemble_object.count;
-                    return AssembleListResult::ConfigError;
-                }
-                // 0 keeps the default filament, as it does for --load-filament-ids.
-                if (std::any_of(assemble_object.filaments.begin(), assemble_object.filaments.end(), [](int id) { return id < 0; }))
-                {
-                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1% has a negative filament id") % assemble_object.path;
-                    return AssembleListResult::ConfigError;
-                }
-
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX)) {
-                    assemble_object.assemble_index = object_json[JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX].get<std::vector<int>>();
-                    if ((assemble_object.assemble_index.size() > 0) && (assemble_object.assemble_index.size() != assemble_object.count) && (assemble_object.assemble_index.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s assemble_index count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.assemble_index.size() % assemble_object.count;
-                        return AssembleListResult::ConfigError;
-                    }
-                }
-
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_X)) {
-                    assemble_object.pos_x = object_json[JSON_ASSEMPLE_OBJECT_POS_X].get<std::vector<float>>();
-                    if ((assemble_object.pos_x.size() > 0) && (assemble_object.pos_x.size() != assemble_object.count) && (assemble_object.pos_x.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_x count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_x.size() % assemble_object.count;
-                        return AssembleListResult::ConfigError;
-                    }
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Y)) {
-                    assemble_object.pos_y = object_json[JSON_ASSEMPLE_OBJECT_POS_Y].get<std::vector<float>>();
-                    if ((assemble_object.pos_y.size() > 0) && (assemble_object.pos_y.size() != assemble_object.count) && (assemble_object.pos_y.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_y count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_y.size() % assemble_object.count;
-                        return AssembleListResult::ConfigError;
-                    }
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Z)) {
-                    assemble_object.pos_z = object_json[JSON_ASSEMPLE_OBJECT_POS_Z].get<std::vector<float>>();
-                    if ((assemble_object.pos_z.size() > 0) && (assemble_object.pos_z.size() != assemble_object.count) && (assemble_object.pos_z.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_z count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_z.size() % assemble_object.count;
-                        return AssembleListResult::ConfigError;
-                    }
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
-                    assemble_object.print_params = object_json[JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
-                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% print params") % (plate_index + 1) %assemble_object.path % assemble_object.print_params.size();
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
-                    json height_range_json = object_json[JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
-                    int range_count = height_range_json.size();
-
-                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% height ranges") % (plate_index + 1) %assemble_object.path % range_count;
-
-                    assemble_object.height_ranges.resize(range_count);
-                    for (int range_index = 0; range_index < range_count; range_index++)
-                    {
-                        height_range_info_t& height_range = assemble_object.height_ranges[range_index];
-                        height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
-                        height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
-                        height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
-                    }
-                }
-            }
-            if (plate_json.contains(JSON_ASSEMPLE_ASSEMBLE_PARAMS)) {
-                json assemble_params_json = plate_json[JSON_ASSEMPLE_ASSEMBLE_PARAMS];
-                int assemble_count = assemble_params_json.size();
-                for (int i = 0; i < assemble_count; i++)
-                {
-                    assembled_param_info_t assembled_param;
-                    int assemble_index = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX];
-                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
-                        assembled_param.print_params = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
-                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% print params") % (plate_index + 1) %i % assembled_param.print_params.size();
-                    }
-                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
-                        json height_range_json = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
-                        int range_count = height_range_json.size();
-
-                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% height ranges") % (plate_index + 1) %i % range_count;
-
-                        assembled_param.height_ranges.resize(range_count);
-                        for (int range_index = 0; range_index < range_count; range_index++)
-                        {
-                            height_range_info_t& height_range = assembled_param.height_ranges[range_index];
-                            height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
-                            height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
-                            height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
-                        }
-                    }
-                    assemble_plate.assembled_param_list.emplace(assemble_index, std::move(assembled_param));
-                }
-                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
-            }
-        }
-    }
-    catch(std::exception &err) {
-        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse file "<<config_file<<" got a generic exception, reason = " << err.what();
-        ret = AssembleListResult::ConfigError;
-    }
-
-    return ret;
-}
-
-} // namespace Slic3r

src/libslic3r/Format/AssembleList.hpp

@@ -1,60 +0,0 @@
-#ifndef slic3r_Format_AssembleList_hpp_
-#define slic3r_Format_AssembleList_hpp_
-
-#include <map>
-#include <string>
-#include <vector>
-
-namespace Slic3r {
-
-class ModelObject;
-
-typedef struct _height_range_info {
-    float         min_z;
-    float         max_z;
-
-    std::map<std::string, std::string> range_params;
-}height_range_info_t;
-
-typedef struct _assembled_param_info {
-    std::map<std::string, std::string> print_params;
-    std::vector<height_range_info_t> height_ranges;
-}assembled_param_info_t;
-
-typedef struct _assemble_object_info {
-    std::string         path;
-    int                 count;
-
-    std::vector<int>    filaments;
-    std::vector<int>    assemble_index;
-    std::vector<float>  pos_x;
-    std::vector<float>  pos_y;
-    std::vector<float>  pos_z;
-    std::map<std::string, std::string> print_params;
-    std::vector<height_range_info_t> height_ranges;
-}assemble_object_info_t;
-
-typedef struct _assemble_plate_info {
-    std::string         plate_name;
-    bool                need_arrange {false};
-    int                 filaments_count {0};
-
-    std::map<std::string, std::string> plate_params;
-    std::vector<assemble_object_info_t> assemble_obj_list;
-    std::vector<ModelObject *> loaded_obj_list;
-    std::map<int, assembled_param_info_t> assembled_param_list;
-}assemble_plate_info_t;
-
-enum class AssembleListResult {
-    Success,
-    FileNotFound,
-    // Malformed JSON, a missing required field, or a value that fails validation.
-    ConfigError
-};
-
-// Read the JSON assemble list used by the CLI's --load-assemble-list into one entry per plate.
-AssembleListResult load_assemble_plate_list(const std::string &config_file, std::vector<assemble_plate_info_t> &assemble_plate_info_list, int max_plate_count);
-
-} // namespace Slic3r
-
-#endif /* slic3r_Format_AssembleList_hpp_ */

src/libslic3r/GCode.cpp

@@ -806,13 +806,13 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)
         GCodeReader parser;
         parser.parse_buffer(gcode, [&changes](GCodeReader &parser, const GCodeReader::GCodeLine &line) {
             const std::string_view cmd = line.cmd();
-            if (ascii_iequals(cmd, "M204") || ascii_iequals(cmd, "M201") ||
-                ascii_iequals(cmd, "M202"))
+            if (boost::iequals(cmd, "M204") || boost::iequals(cmd, "M201") ||
+                boost::iequals(cmd, "M202"))
                 changes.acceleration = true;
-            else if ((ascii_iequals(cmd, "M205") || ascii_iequals(cmd, "M207") || ascii_iequals(cmd, "M566")) &&
+            else if ((boost::iequals(cmd, "M205") || boost::iequals(cmd, "M207") || boost::iequals(cmd, "M566")) &&
                      custom_gcode_line_has_xy_parameter(line.raw()))
                 changes.jerk = true;
-            else if (ascii_iequals(cmd, "SET_VELOCITY_LIMIT")) {
+            else if (boost::iequals(cmd, "SET_VELOCITY_LIMIT")) {
                 changes.acceleration |= boost::icontains(line.raw(), "ACCEL=");
                 changes.jerk         |= boost::icontains(line.raw(), "SQUARE_CORNER_VELOCITY=");
             }
@@ -4404,75 +4404,6 @@ size_t GCode::get_nozzle_config_index(int filament_id) const
     return get_extruder_id(filament_id);
 }
 
-namespace {
-struct PrecomputedLayer
-{
-    size_t                                    index{size_t(-1)}; // size_t(-1) for the empty layer after the last
-    std::vector<PrecomputedOverhangLayer>     overhang_layers;
-};
-} // namespace
-
-template<typename BoolsOption> static bool any_enabled(const BoolsOption &option)
-{
-    return std::any_of(option.values.begin(), option.values.end(), [](unsigned char enabled) { return enabled != 0; });
-}
-
-// Whether process_layer() prepares the overhang estimator for `layer`.
-template<typename OverhangSpeed>
-static bool prepares_overhang_estimator(const Layer &layer, bool overhang_fan, OverhangSpeed overhang_speed)
-{
-    const LayerRegionPtrs &regions = layer.regions();
-    return std::any_of(regions.begin(), regions.end(), [overhang_fan, &overhang_speed](const LayerRegion *region) {
-        return region->has_extrusions() && (overhang_fan || overhang_speed(*region));
-    });
-}
-
-std::vector<PrecomputedOverhangLayer> precompute_overhang_layers(const std::vector<GCode::LayerToPrint> &layers, bool overhang_fan)
-{
-    // Any filament may print the layer, so a region's overhang speed counts if it is enabled for any.
-    auto overhang_speed = [](const LayerRegion &region) { return any_enabled(region.region().config().enable_overhang_speed); };
-    std::vector<PrecomputedOverhangLayer> out;
-    for (const GCode::LayerToPrint &layer : layers)
-        if (layer.object_layer != nullptr && layer.object_layer->lower_layer != nullptr &&
-            prepares_overhang_estimator(*layer.object_layer, overhang_fan, overhang_speed)) {
-            const LayerRegionPtrs &regions = layer.object_layer->regions();
-            const bool curled_lines = std::any_of(regions.begin(), regions.end(), [](const LayerRegion *region) {
-                return any_enabled(region->region().config().slowdown_for_curled_perimeters);
-            });
-            out.push_back(precompute_overhang_layer(layer.original_object, *layer.object_layer, curled_lines));
-        }
-    return out;
-}
-
-// Hands out the index of each layer to process_layers(), then computes the layers' overhang data in parallel.
-template<typename LayersAt>
-static auto precomputed_layers_source(size_t &next_index, size_t layer_count, bool nop_layer, bool overhang_fan, LayersAt layers_at)
-{
-    return tbb::make_filter<void, PrecomputedLayer>(slic3r_tbb_filtermode::serial_in_order,
-               [&next_index, layer_count, nop_layer](tbb::flow_control &fc) -> PrecomputedLayer {
-                   if (next_index < layer_count)
-                       return {next_index++};
-                   // The pressure equalizer returns one layer back, so it gets an empty layer after the last.
-                   if (next_index == layer_count + (nop_layer ? 1 : 0))
-                       fc.stop();
-                   else
-                       ++next_index;
-                   return {};
-               }) &
-           tbb::make_filter<PrecomputedLayer, PrecomputedLayer>(slic3r_tbb_filtermode::parallel,
-               [layers_at, overhang_fan](PrecomputedLayer layer) -> PrecomputedLayer {
-                   if (layer.index != size_t(-1))
-                       layer.overhang_layers = precompute_overhang_layers(layers_at(layer.index), overhang_fan);
-                   return layer;
-               });
-}
-
-// Whether the overhang fan can switch on for any filament.
-static bool overhang_fan_enabled(const PrintConfig &config, bool cooling_markers)
-{
-    return cooling_markers && any_enabled(config.enable_overhang_bridge_fan);
-}
-
 // Process all layers of all objects (non-sequential mode) with a parallel pipeline:
 // Generate G-code, run the filters (vase mode, cooling buffer), run the G-code analyser
 // and export G-code into file.
@@ -4485,23 +4416,29 @@ void GCode::process_layers(
 {
     // The pipeline is variable: The vase mode filter is optional.
     size_t layer_to_print_idx = 0;
-    const auto source = precomputed_layers_source(layer_to_print_idx, layers_to_print.size(), m_pressure_equalizer != nullptr,
-        overhang_fan_enabled(print.config(), m_enable_cooling_markers),
-        [&layers_to_print](size_t index) -> const std::vector<LayerToPrint> & { return layers_to_print[index].second; });
-    const auto generator = tbb::make_filter<PrecomputedLayer, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
-        [this, &print, &tool_ordering, &print_object_instances_ordering, &layers_to_print](PrecomputedLayer precomputed) -> LayerResult {
-            if (precomputed.index == size_t(-1))
-                return LayerResult::make_nop_layer_result();
-            const std::pair<coordf_t, std::vector<LayerToPrint>>& layer = layers_to_print[precomputed.index];
-            const LayerTools& layer_tools = tool_ordering.tools_for_layer(layer.first);
-            print.set_status(80, Slic3r::format(_(L("Generating G-code: layer %1%")), std::to_string(precomputed.index + 1)));
-            if (m_wipe_tower && layer_tools.has_wipe_tower)
-                m_wipe_tower->next_layer();
-            //BBS
-            check_placeholder_parser_failed();
-            print.throw_if_canceled();
-            m_extrusion_quality_estimator.set_precomputed_layers(std::move(precomputed.overhang_layers));
-            return this->process_layer(print, layer.second, layer_tools, &layer == &layers_to_print.back(), &print_object_instances_ordering, tool_ordering.get_most_used_extruder(), size_t(-1));
+    const auto generator = tbb::make_filter<void, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
+        [this, &print, &tool_ordering, &print_object_instances_ordering, &layers_to_print, &layer_to_print_idx](tbb::flow_control& fc) -> LayerResult {
+            if (layer_to_print_idx >= layers_to_print.size()) {
+                if (layer_to_print_idx == layers_to_print.size() + (m_pressure_equalizer ? 1 : 0)) {
+                    fc.stop();
+                    return {};
+                } else {
+                    // Pressure equalizer need insert empty input. Because it returns one layer back.
+                    // Insert NOP (no operation) layer;
+                    ++layer_to_print_idx;
+                    return LayerResult::make_nop_layer_result();
+                }
+            } else {
+                const std::pair<coordf_t, std::vector<LayerToPrint>>& layer = layers_to_print[layer_to_print_idx++];
+                const LayerTools& layer_tools = tool_ordering.tools_for_layer(layer.first);
+                print.set_status(80, Slic3r::format(_(L("Generating G-code: layer %1%")), std::to_string(layer_to_print_idx)));
+                if (m_wipe_tower && layer_tools.has_wipe_tower)
+                    m_wipe_tower->next_layer();
+                //BBS
+                check_placeholder_parser_failed();
+                print.throw_if_canceled();
+                return this->process_layer(print, layer.second, layer_tools, &layer == &layers_to_print.back(), &print_object_instances_ordering, tool_ordering.get_most_used_extruder(), size_t(-1));
+            }
         });
     if (m_spiral_vase) {
         float nozzle_diameter  = EXTRUDER_CONFIG(nozzle_diameter);
@@ -4559,15 +4496,13 @@ void GCode::process_layers(
 
     // The pipeline elements are joined using const references, thus no copying is performed.
     if (m_spiral_vase && m_pressure_equalizer)
-        tbb::parallel_pipeline(12, source & generator & spiral_mode & pressure_equalizer & cooling & fan_mover & output);
+        tbb::parallel_pipeline(12, generator & spiral_mode & pressure_equalizer & cooling & fan_mover & output);
     else if (m_spiral_vase)
-    	tbb::parallel_pipeline(12, source & generator & spiral_mode & cooling & fan_mover & output);
+    	tbb::parallel_pipeline(12, generator & spiral_mode & cooling & fan_mover & output);
     else if	(m_pressure_equalizer)
-        tbb::parallel_pipeline(12, source & generator & pressure_equalizer & cooling & fan_mover & pa_processor_filter & output);
+        tbb::parallel_pipeline(12, generator & pressure_equalizer & cooling & fan_mover & pa_processor_filter & output);
     else
-    	tbb::parallel_pipeline(12, source & generator & cooling & fan_mover & pa_processor_filter & output);
-    // The estimator's precomputed data points into this print's layers.
-    m_extrusion_quality_estimator.set_precomputed_layers({});
+    	tbb::parallel_pipeline(12, generator & cooling & fan_mover & pa_processor_filter & output);
 
 }
 
@@ -4585,20 +4520,26 @@ void GCode::process_layers(
 {
     // The pipeline is variable: The vase mode filter is optional.
     size_t layer_to_print_idx = 0;
-    const auto source = precomputed_layers_source(layer_to_print_idx, layers_to_print.size(), m_pressure_equalizer != nullptr,
-        overhang_fan_enabled(print.config(), m_enable_cooling_markers),
-        [&layers_to_print](size_t index) { return std::vector<LayerToPrint>{layers_to_print[index]}; });
-    const auto generator = tbb::make_filter<PrecomputedLayer, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
-        [this, &print, &tool_ordering, &layers_to_print, single_object_idx, prime_extruder](PrecomputedLayer precomputed) -> LayerResult {
-            if (precomputed.index == size_t(-1))
-                return LayerResult::make_nop_layer_result();
-            LayerToPrint &layer = layers_to_print[precomputed.index];
-            print.set_status(80, Slic3r::format(_(L("Generating G-code: layer %1%")), std::to_string(precomputed.index + 1)));
-            //BBS
-            check_placeholder_parser_failed();
-            print.throw_if_canceled();
-            m_extrusion_quality_estimator.set_precomputed_layers(std::move(precomputed.overhang_layers));
-            return this->process_layer(print, { std::move(layer) }, tool_ordering.tools_for_layer(layer.print_z()), &layer == &layers_to_print.back(), nullptr, tool_ordering.get_most_used_extruder(), single_object_idx, prime_extruder);
+    const auto generator = tbb::make_filter<void, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
+        [this, &print, &tool_ordering, &layers_to_print, &layer_to_print_idx, single_object_idx, prime_extruder](tbb::flow_control& fc) -> LayerResult {
+            if (layer_to_print_idx >= layers_to_print.size()) {
+                if (layer_to_print_idx == layers_to_print.size() + (m_pressure_equalizer ? 1 : 0)) {
+                    fc.stop();
+                    return {};
+                } else {
+                    // Pressure equalizer need insert empty input. Because it returns one layer back.
+                    // Insert NOP (no operation) layer;
+                    ++layer_to_print_idx;
+                    return LayerResult::make_nop_layer_result();
+                }
+            } else {
+                LayerToPrint &layer = layers_to_print[layer_to_print_idx ++];
+                print.set_status(80, Slic3r::format(_(L("Generating G-code: layer %1%")), std::to_string(layer_to_print_idx)));
+                //BBS
+                check_placeholder_parser_failed();
+                print.throw_if_canceled();
+                return this->process_layer(print, { std::move(layer) }, tool_ordering.tools_for_layer(layer.print_z()), &layer == &layers_to_print.back(), nullptr, tool_ordering.get_most_used_extruder(), single_object_idx, prime_extruder);
+            }
         });
     if (m_spiral_vase) {
         float nozzle_diameter  = EXTRUDER_CONFIG(nozzle_diameter);
@@ -4653,15 +4594,13 @@ void GCode::process_layers(
 
     // The pipeline elements are joined using const references, thus no copying is performed.
     if (m_spiral_vase && m_pressure_equalizer)
-        tbb::parallel_pipeline(12, source & generator & spiral_mode & pressure_equalizer & cooling & fan_mover & output);
+        tbb::parallel_pipeline(12, generator & spiral_mode & pressure_equalizer & cooling & fan_mover & output);
     else if (m_spiral_vase)
-    	tbb::parallel_pipeline(12, source & generator & spiral_mode & cooling & fan_mover & output);
+    	tbb::parallel_pipeline(12, generator & spiral_mode & cooling & fan_mover & output);
     else if	(m_pressure_equalizer)
-        tbb::parallel_pipeline(12, source & generator & pressure_equalizer & cooling & fan_mover & pa_processor_filter & output);
+        tbb::parallel_pipeline(12, generator & pressure_equalizer & cooling & fan_mover & pa_processor_filter & output);
     else
-    	tbb::parallel_pipeline(12, source & generator & cooling & fan_mover & pa_processor_filter & output);
-    // The estimator's precomputed data points into this print's layers.
-    m_extrusion_quality_estimator.set_precomputed_layers({});
+    	tbb::parallel_pipeline(12, generator & cooling & fan_mover & pa_processor_filter & output);
 }
 
 std::string GCode::placeholder_parser_process(const std::string &name, const std::string &templ, unsigned int current_filament_id, const DynamicConfig *config_override)
@@ -6021,13 +5960,25 @@ LayerResult GCode::process_layer(
         return next_extruder;
     };
     
-    const bool overhang_fan   = overhang_fan_enabled(m_config, m_enable_cooling_markers);
-    auto       overhang_speed = [this](const LayerRegion &region) {
-        return bool(region.region().config().enable_overhang_speed.get_at(get_nozzle_config_index(m_writer.filament()->id())));
-    };
-    for (const auto &layer_to_print : layers)
-        if (layer_to_print.object_layer && prepares_overhang_estimator(*layer_to_print.object_layer, overhang_fan, overhang_speed))
-            m_extrusion_quality_estimator.prepare_for_new_layer(layer_to_print.original_object, layer_to_print.object_layer);
+    for (const auto &layer_to_print : layers) {
+        if (layer_to_print.object_layer) {
+            const auto& regions = layer_to_print.object_layer->regions();
+            const bool has_extrusions = std::any_of(regions.begin(), regions.end(), [](const LayerRegion* r) {
+                return r->has_extrusions();
+            });
+            const bool enable_overhang_speed = std::any_of(regions.begin(), regions.end(), [this](const LayerRegion* r) {
+                return r->has_extrusions() && r->region().config().enable_overhang_speed.get_at(get_nozzle_config_index(m_writer.filament()->id()));
+            });
+            const bool enable_overhang_fan = m_enable_cooling_markers && has_extrusions &&
+                std::any_of(m_config.enable_overhang_bridge_fan.values.begin(),
+                            m_config.enable_overhang_bridge_fan.values.end(),
+                            [](unsigned char value) { return value != 0; });
+            if (enable_overhang_speed || enable_overhang_fan) {
+                m_extrusion_quality_estimator.prepare_for_new_layer(layer_to_print.original_object,
+                                                                    layer_to_print.object_layer);
+            }
+        }
+    }
 
     // Group extrusions by an extruder, then by an object, an island and a region.
     std::map<unsigned int, std::vector<ObjectByExtruder>> by_extruder;

src/libslic3r/GCode.hpp

@@ -864,10 +864,6 @@ private:
 
 std::vector<const PrintInstance*> sort_object_instances_by_model_order(const Print& print, bool init_order = false);
 
-// The overhang data ExtrusionQualityEstimator needs for the object layers in `layers`, computed ahead of the generator;
-// `overhang_fan` says whether the overhang fan can switch on for any filament.
-std::vector<PrecomputedOverhangLayer> precompute_overhang_layers(const std::vector<GCode::LayerToPrint> &layers, bool overhang_fan);
-
 }
 
 #endif

src/libslic3r/GCode/AdaptivePAProcessor.cpp

@@ -41,9 +41,6 @@ AdaptivePAProcessor::AdaptivePAProcessor(GCode &gcodegen)
       m_pa_change_pattern(R"(; PA_CHANGE:T(\d+) MM3MM:([0-9]*\.[0-9]+) ACCEL:(\d+) BR:(\d+) RC:(\d+) OV:(\d+))"),
       m_g1_f_pattern(R"(G1 F([0-9]+))")
 {
-    const size_t indices = std::max(m_config.adaptive_pressure_advance.size(), m_config.enable_pressure_advance.size());
-    for (size_t i = 0; i < indices && !m_enabled; ++i)
-        m_enabled = m_config.adaptive_pressure_advance.get_at(i) && m_config.enable_pressure_advance.get_at(i);
 }
 
 // Method to get the interpolator for a specific filament config index.
@@ -69,12 +66,6 @@ AdaptivePAInterpolator* AdaptivePAProcessor::getInterpolator(unsigned int config
  * @return A string containing the processed G-code with adaptive pressure advance applied.
  */
 std::string AdaptivePAProcessor::process_layer(std::string &&gcode) {
-    // Without PA_CHANGE tags the loop below would only terminate the layer's last line.
-    if (!m_enabled && gcode.find("; PA_CHANGE") == std::string::npos) {
-        if (!gcode.empty() && gcode.back() != '\n')
-            gcode += '\n';
-        return std::move(gcode);
-    }
     std::istringstream stream(gcode);
     std::string line;
     std::ostringstream output;

src/libslic3r/GCode/AdaptivePAProcessor.hpp

@@ -78,7 +78,6 @@ private:
     double m_next_feedrate; ///< First feed rate (speed) for the upcomming island.
     double m_current_feedrate; ///< Current, latest feedrate.
     int m_last_config_index; ///< Filament config index of the last PA_CHANGE tag.
-    bool m_enabled{false}; ///< Whether any filament config index has both PA and adaptive PA on, the only ones that emit PA_CHANGE tags.
 
     std::regex m_pa_change_pattern; ///< Regular expression to detect PA_CHANGE pattern.
     std::regex m_g1_f_pattern; ///< Regular expression to detect G1 F pattern.

src/libslic3r/GCode/CoolingBuffer.cpp

@@ -1,5 +1,4 @@
 #include "../GCode.hpp"
-#include "../LocalesUtils.hpp"
 #include "libslic3r/Extruder.hpp"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/libslic3r.h"
@@ -409,13 +408,13 @@ std::vector<PerExtruderAdjustments> CoolingBuffer::parse_layer_gcode(const std::
                 if (*c == 0 || *c == ';')
                     break;
 
+                assert(is_decimal_separator_point()); // for atof
                 //BBS: Parse the axis.
                 size_t axis = (*c >= 'X' && *c <= 'Z') ? (*c - 'X') :
                               (*c == 'E') ? 3 : (*c == 'F') ? 4 :
                               (*c == 'I') ? 5 : (*c == 'J') ? 6 : size_t(-1);
                 if (axis != size_t(-1)) {
-                    ++ c;
-                    new_pos[axis] = float(atof_decimal_point(std::string_view(c, sline.data() + sline.size() - c)));
+                    new_pos[axis] = float(atof(++c));
                     if (axis == 4) {
                         // Convert mm/min to mm/sec.
                         new_pos[4] /= 60.f;
@@ -551,9 +550,10 @@ std::vector<PerExtruderAdjustments> CoolingBuffer::parse_layer_gcode(const std::
             line.type = CoolingLine::TYPE_G4;
             size_t pos_S = sline.find('S', 3);
             size_t pos_P = sline.find('P', 3);
+            assert(is_decimal_separator_point()); // for atof
             line.time = line.time_max = float(
-                (pos_S > 0) ? atof_decimal_point(sline.c_str() + pos_S + 1) :
-                (pos_P > 0) ? atof_decimal_point(sline.c_str() + pos_P + 1) * 0.001 : 0.);
+                (pos_S > 0) ? atof(sline.c_str() + pos_S + 1) :
+                (pos_P > 0) ? atof(sline.c_str() + pos_P + 1) * 0.001 : 0.);
         } else if (boost::starts_with(sline, ";_FORCE_RESUME_FAN_SPEED")) {
             line.type = CoolingLine::TYPE_FORCE_RESUME_FAN;
         }

src/libslic3r/GCode/ExtrusionProcessor.hpp

@@ -24,7 +24,6 @@
 #include <cstddef>
 #include <functional>
 #include <limits>
-#include <memory>
 #include <numeric>
 #include <unordered_map>
 #include <utility>
@@ -39,14 +38,7 @@ template<int Dim> struct ExtendedPoint
     float curvature;
 };
 
-// A KNOWN_DISTANCES functor that knows no distances, so every input point is queried.
-struct NoKnownDistances
-{
-    template<typename P> const double *operator()(const P &) const { return nullptr; }
-};
-
-template<bool SCALED_INPUT, bool ADD_INTERSECTIONS, bool PREV_LAYER_BOUNDARY_OFFSET, bool SIGNED_DISTANCE, bool CURVATURE = true,
-         typename POINTS, typename L, typename KNOWN_DISTANCES = NoKnownDistances>
+template<bool SCALED_INPUT, bool ADD_INTERSECTIONS, bool PREV_LAYER_BOUNDARY_OFFSET, bool SIGNED_DISTANCE, typename POINTS, typename L>
 std::vector<ExtendedPoint<L::Dim>> estimate_points_properties(const POINTS&                           input_points,
                                                               const AABBTreeLines::LinesDistancer<L>& unscaled_prev_layer,
                                                               float                                   flow_width,
@@ -57,9 +49,7 @@ std::vector<ExtendedPoint<L::Dim>> estimate_points_properties(const POINTS&
                                                               const std::function<float(float)>&      distance_to_speed = {},
                                                               // Overlap (1 - distance / flow_width) at or below which the overhang
                                                               // fan switches on; negative when the fan does not depend on overlap.
-                                                              float                                   fan_overlap_threshold = -1.0f,
-                                                              // Returns an input point's signed distance if already known, else nullptr.
-                                                              const KNOWN_DISTANCES&                  known_distance = KNOWN_DISTANCES{})
+                                                              float                                   fan_overlap_threshold = -1.0f)
 {
     bool   looped     = input_points.front() == input_points.back();
     std::function<size_t(size_t,size_t)> get_prev_index = [](size_t idx, size_t count) {
@@ -104,26 +94,21 @@ std::vector<ExtendedPoint<L::Dim>> estimate_points_properties(const POINTS&
     float boundary_offset = PREV_LAYER_BOUNDARY_OFFSET ? 0.5 * flow_width : 0.0f;
     auto  maybe_unscale   = [](const P& p) -> Vec { return SCALED_INPUT ? unscaled(p) : p.template cast<double>(); };
 
-    using Distance = typename AABBTreeLines::LinesDistancer<L>::Floating;
-    auto input_distance = [&unscaled_prev_layer, &known_distance](const P &input, const Vec &position) -> Distance {
-        if (const double *known = known_distance(input))
-            return Distance(*known);
-        auto [distance, nearest_line, x] = unscaled_prev_layer.template distance_from_lines_extra<SIGNED_DISTANCE>(
-            position.template cast<AABBScalar>());
-        return distance;
-    };
-
     std::vector<ExtendedPoint<L::Dim>> points;
     points.reserve(input_points.size() * (ADD_INTERSECTIONS ? 1.5 : 1));
 
     {
         ExtendedPoint<L::Dim> start_point{maybe_unscale(input_points.front())};
-        start_point.distance = input_distance(input_points.front(), start_point.position) + boundary_offset;
+        auto [distance, nearest_line, x] = unscaled_prev_layer.template distance_from_lines_extra<SIGNED_DISTANCE>(
+            start_point.position.template cast<AABBScalar>());
+        start_point.distance = distance + boundary_offset;
         points.push_back(start_point);
     }
     for (size_t i = 1; i < input_points.size(); i++) {
         ExtendedPoint<L::Dim> next_point{maybe_unscale(input_points[i])};
-        next_point.distance = input_distance(input_points[i], next_point.position) + boundary_offset;
+        auto [distance, nearest_line,
+              x] = unscaled_prev_layer.template distance_from_lines_extra<SIGNED_DISTANCE>(next_point.position.template cast<AABBScalar>());
+        next_point.distance = distance + boundary_offset;
 
         // Intersection handling
         if (ADD_INTERSECTIONS &&
@@ -364,9 +349,6 @@ std::vector<ExtendedPoint<L::Dim>> estimate_points_properties(const POINTS&
         points = std::move(new_points);
     }
 
-    if constexpr (!CURVATURE)
-        return points;
-
     // Curvature calculation
     float accumulated_distance = 0;
     std::vector<float> distances_for_curvature(points.size());
@@ -435,49 +417,6 @@ std::vector<ExtendedPoint<L::Dim>> estimate_points_properties(const POINTS&
     return points;
 }
 
-struct Point3Hash
-{
-    size_t operator()(const Vec3crd &pt) const noexcept { return size_t(((89 * 31 + int64_t(pt.x())) * 31 + pt.y()) * 31 + pt.z()); }
-};
-
-// The trees of the layer below an object layer, and the signed distances from the layer's perimeter and bridge
-// vertices to that layer's outline, computed for ExtrusionQualityEstimator ahead of the G-code generator.
-struct PrecomputedOverhangLayer
-{
-    const PrintObject                                               *object{nullptr};
-    const Layer                                                     *layer{nullptr};
-    std::shared_ptr<const AABBTreeLines::LinesDistancer<Linef3>>     lower_boundaries;
-    std::shared_ptr<const AABBTreeLines::LinesDistancer<CurledLine>> lower_curled_lines;
-    std::unordered_map<Point3, double, Point3Hash>                   distances;
-};
-
-// `layer` must have a layer below it; leave out `curled_lines` only when no region of `layer` slows down for curled
-// perimeters.
-inline PrecomputedOverhangLayer precompute_overhang_layer(const PrintObject *object, const Layer &layer, bool curled_lines = true)
-{
-    PrecomputedOverhangLayer out{object, &layer,
-                                 std::make_shared<const AABBTreeLines::LinesDistancer<Linef3>>(to_unscaled_linesf3(layer.lower_layer->lslices)),
-                                 curled_lines ? std::make_shared<const AABBTreeLines::LinesDistancer<CurledLine>>(layer.lower_layer->curled_lines) :
-                                                nullptr,
-                                 {}};
-    const AABBTreeLines::LinesDistancer<Linef3> &lower = *out.lower_boundaries;
-    auto add_path = [&out, &lower](const ExtrusionPath &path) {
-        if (!is_bridge(path.role()) && !is_perimeter(path.role()))
-            return;
-        for (const Point3 &point : path.polyline.points)
-            if (auto [it, inserted] = out.distances.try_emplace(point, 0.); inserted) {
-                const Eigen::Matrix<double, 3, 1, Eigen::DontAlign> position = unscaled(point);
-                auto [distance, nearest_line, x] = lower.distance_from_lines_extra<true>(position.cast<double>());
-                it->second = distance;
-            }
-    };
-    for (const LayerRegion *region : layer.regions()) {
-        for_each_extrusion_path(region->perimeters, add_path);
-        for_each_extrusion_path(region->fills, add_path);
-    }
-    return out;
-}
-
 struct ProcessedPoint
 {
     Point3 p;
@@ -487,53 +426,23 @@ struct ProcessedPoint
 
 class ExtrusionQualityEstimator
 {
-    using Boundaries   = AABBTreeLines::LinesDistancer<Linef3>;
-    using CurledLines  = AABBTreeLines::LinesDistancer<CurledLine>;
-    std::unordered_map<const PrintObject*, std::shared_ptr<const Boundaries>>  prev_layer_boundaries;
-    std::unordered_map<const PrintObject*, std::shared_ptr<const CurledLines>> prev_curled_extrusions;
-    // The layers the trees above are built from, and the layers prepared last.
-    std::unordered_map<const PrintObject*, const Layer*>                      prev_layer_sources;
-    std::unordered_map<const PrintObject*, const Layer*>                      last_prepared_layers;
-    std::vector<PrecomputedOverhangLayer>                                     precomputed_layers;
-    const PrintObject                                                        *current_object;
-
-    const PrecomputedOverhangLayer *precomputed_for(const PrintObject *object) const
-    {
-        auto it = std::find_if(precomputed_layers.begin(), precomputed_layers.end(),
-                               [object](const PrecomputedOverhangLayer &layer) { return layer.object == object; });
-        return it == precomputed_layers.end() ? nullptr : &*it;
-    }
-
-    template<typename T> static const T &or_empty(const std::shared_ptr<const T> &tree)
-    {
-        static const T empty;
-        return tree ? *tree : empty;
-    }
+    std::unordered_map<const PrintObject*, AABBTreeLines::LinesDistancer<Linef3>>      prev_layer_boundaries;
+    std::unordered_map<const PrintObject*, AABBTreeLines::LinesDistancer<Linef3>>      next_layer_boundaries;
+    std::unordered_map<const PrintObject *, AABBTreeLines::LinesDistancer<CurledLine>> prev_curled_extrusions;
+    std::unordered_map<const PrintObject *, AABBTreeLines::LinesDistancer<CurledLine>> next_curled_extrusions;
+    const PrintObject                                                            *current_object;
 
 public:
     void set_current_object(const PrintObject *object) { current_object = object; }
 
-    // Takes the data computed ahead for the layer about to be generated, replacing the previous layer's.
-    void set_precomputed_layers(std::vector<PrecomputedOverhangLayer> &&layers) { precomputed_layers = std::move(layers); }
-
-    // Measures the layer against the layer prepared before it.
     void prepare_for_new_layer(const PrintObject * obj, const Layer *layer)
     {
         if (layer == nullptr) return;
         const PrintObject *object = obj;
-        const Layer *prev = std::exchange(last_prepared_layers[object], layer);
-        prev_layer_sources[object] = prev;
-        const PrecomputedOverhangLayer *precomputed = precomputed_for(object);
-        if (prev == nullptr) {
-            prev_layer_boundaries[object]  = nullptr;
-            prev_curled_extrusions[object] = nullptr;
-        } else if (precomputed != nullptr && precomputed->layer == layer && layer->lower_layer == prev) {
-            prev_layer_boundaries[object]  = precomputed->lower_boundaries;
-            prev_curled_extrusions[object] = precomputed->lower_curled_lines;
-        } else {
-            prev_layer_boundaries[object]  = std::make_shared<const Boundaries>(to_unscaled_linesf3(prev->lslices));
-            prev_curled_extrusions[object] = std::make_shared<const CurledLines>(prev->curled_lines);
-        }
+        prev_layer_boundaries[object] = next_layer_boundaries[object];
+        next_layer_boundaries[object]  = AABBTreeLines::LinesDistancer<Linef3>{to_unscaled_linesf3(layer->lslices)};
+        prev_curled_extrusions[object] = next_curled_extrusions[object];
+        next_curled_extrusions[object] = AABBTreeLines::LinesDistancer<CurledLine>{layer->curled_lines};
     }
 
     std::vector<ProcessedPoint> estimate_extrusion_quality(const ExtrusionPath                &path,
@@ -617,24 +526,9 @@ public:
             return std::min(calculate_speed(distance), original_speed);
         };
 
-        // Precomputed distances hold only if they were measured against the layer prev_layer_boundaries is built from.
-        const std::unordered_map<Point3, double, Point3Hash> *known = nullptr;
-        if (const PrecomputedOverhangLayer *precomputed = precomputed_for(current_object);
-            precomputed != nullptr && precomputed->layer->lower_layer == prev_layer_sources[current_object])
-            known = &precomputed->distances;
-        const Boundaries  &prev_boundaries = or_empty(prev_layer_boundaries[current_object]);
-        const CurledLines &prev_curled     = or_empty(prev_curled_extrusions[current_object]);
-        auto known_distance = [known](const Point3 &point) -> const double * {
-            if (known == nullptr)
-                return nullptr;
-            auto it = known->find(point);
-            return it == known->end() ? nullptr : &it->second;
-        };
-
         std::vector<ExtendedPoint<3>> extended_points =
-            estimate_points_properties<true, true, true, true, false>(path.polyline.points, prev_boundaries, path.width, -1,
-                                                               smallest_distance_with_lower_speed, effective_speed, fan_overlap_threshold,
-                                                               known_distance);
+            estimate_points_properties<true, true, true, true>(path.polyline.points, prev_layer_boundaries[current_object], path.width, -1,
+                                                               smallest_distance_with_lower_speed, effective_speed, fan_overlap_threshold);
         const auto width_inv = 1.0f / path.width;
         std::vector<ProcessedPoint> processed_points;
         processed_points.reserve(extended_points.size());
@@ -648,7 +542,7 @@ public:
             	const double dist_limit = 10.0 * path.width;
 				{
                     Vec3d middle       = 0.5 * (curr.position + next.position);
-                    auto  line_indices = prev_curled.all_lines_in_radius(Point::new_scale(middle),
+                    auto  line_indices = prev_curled_extrusions[current_object].all_lines_in_radius(Point::new_scale(middle),
                                                                                                     scale_(dist_limit));
                     if (!line_indices.empty()) {
                         double len = (next.position - curr.position).norm();
@@ -669,7 +563,7 @@ public:
 
                             double projected_lengths_sum = 0;
                             for (size_t idx : line_indices) {
-                                const CurledLine& line   = prev_curled.get_line(idx);
+                                const CurledLine& line   = prev_curled_extrusions[current_object].get_line(idx);
                                 Lines             inside = intersection_ln({{line.a, line.b}}, {box_of_influence});
                             	if (inside.empty())
                                 	continue;
@@ -682,7 +576,7 @@ public:
                         }
                     
                     	for (size_t idx : line_indices) {
-                        	const CurledLine &line                 = prev_curled.get_line(idx);
+                        	const CurledLine &line                 = prev_curled_extrusions[current_object].get_line(idx);
                         	float             distance_from_curled = unscaled(line_alg::distance_to(line, Point::new_scale(middle)));
                         	float             dist                 = path.width * (1.0 - (distance_from_curled / dist_limit)) *
                                      (1.0 - (distance_from_curled / dist_limit)) *

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -909,8 +909,8 @@ public:
     {
         // Orca: find start pos by seaching G28/G29/PRINT_START/START_PRINT commands
         auto is_start_pos = [](const std::string& curr_cmd) {
-            return ascii_iequals(curr_cmd, "G28") || ascii_iequals(curr_cmd, "G29") || ascii_iequals(curr_cmd, "PRINT_START") ||
-                   ascii_iequals(curr_cmd, "START_PRINT");
+            return boost::iequals(curr_cmd, "G28") || boost::iequals(curr_cmd, "G29") || boost::iequals(curr_cmd, "PRINT_START") ||
+                   boost::iequals(curr_cmd, "START_PRINT");
         };
         assert(!m_lines.empty());
         const float time_step           = backtrace.time_step();
@@ -1265,9 +1265,6 @@ void GCodeProcessor::run_post_process()
     // Process inline placeholders (print_time_total_sec, print_time_day, print_time_hour, print_time_minute, print_time_sec and used_filament_length)
     auto process_inline_placeholders = [&](std::string& gcode_line) {
         bool processed = false;
-        // Every inline placeholder contains '@', so a line without one has nothing to replace.
-        if (gcode_line.find('@') == std::string::npos)
-            return processed;
 
         const std::string& print_time_total_placeholder = reserved_tag(ETags::Print_Time_Total_Sec_Placeholder);
         const std::string& print_time_day_placeholder = reserved_tag(ETags::Print_Time_Day_Placeholder);
@@ -4010,13 +4007,13 @@ void GCodeProcessor::process_gcode_line(const GCodeReader::GCodeLine& line, bool
     const std::string_view cmd = line.cmd();
     if (m_flavor == gcfKlipper)
     {
-        if (ascii_iequals(cmd, "SET_VELOCITY_LIMIT"))
+        if (boost::iequals(cmd, "SET_VELOCITY_LIMIT"))
         {
             process_SET_VELOCITY_LIMIT(line);
             return;
         }
 // ORCA: Add Pressure Advance visualization support
-        if (ascii_iequals(cmd, "SET_PRESSURE_ADVANCE"))
+        if (boost::iequals(cmd, "SET_PRESSURE_ADVANCE"))
         {
             process_SET_PRESSURE_ADVANCE(line);
             return;
@@ -7554,72 +7551,51 @@ void GCodeProcessor::calculate_time(GCodeProcessorResult& result, size_t keep_la
             actual_speed_moves = std::move(machine.actual_speed_moves);
     }
 
-    // actual_speed_moves holds, per block in move order, the moves to insert before the block's move and then an
-    // entry without a position for that move; positioned entries after the last such entry are dropped.
-    std::vector<GCodeProcessorResult::MoveVertex>& moves = result.moves;
-    size_t inserted_actual_speed_moves_count = 0;
-    size_t kept                              = 0;
-    size_t group_start                       = 0;
-    for (size_t i = 0; i < actual_speed_moves.size(); ++i) {
-        if (actual_speed_moves[i].position.has_value())
-            continue;
-        const unsigned int move_id = actual_speed_moves[i].move_id;
-        // A VG1 block has no move of its own, so its id can fall behind the previous block's or point past the list.
-        if (move_id < moves.size() && (kept == 0 || move_id > actual_speed_moves[kept - 1].move_id)) {
-            inserted_actual_speed_moves_count += i - group_start;
-            moves[move_id].actual_feedrate = actual_speed_moves[i].actual_feedrate;
-            // A seam vertex right after a block's move shares its actual speed.
-            if (move_id + 1 < moves.size() && moves[move_id + 1].type == EMoveType::Seam)
-                moves[move_id + 1].actual_feedrate = actual_speed_moves[i].actual_feedrate;
-            for (size_t j = group_start; j <= i; ++j, ++kept)
-                if (kept != j)
-                    actual_speed_moves[kept] = std::move(actual_speed_moves[j]);
-        }
-        group_start = i + 1;
-    }
-    actual_speed_moves.erase(actual_speed_moves.begin() + kept, actual_speed_moves.end());
-
-    // Walks the blocks back to front, so each shifted move is moved once, into its final slot.
-    size_t read  = moves.size(); // one past the last move not yet placed
-    moves.resize(moves.size() + inserted_actual_speed_moves_count);
-    size_t write = moves.size(); // one past the last free slot
-    m_actual_speed_id_map.clear();
-    size_t entry = actual_speed_moves.size();
-    while (entry > 0) {
-        const unsigned int block_id = actual_speed_moves[--entry].move_id;
-        assert(block_id < read);
-        while (read > block_id + 1)
-            moves[--write] = moves[--read];
-        const GCodeProcessorResult::MoveVertex block_move = moves[--read];
-        moves[--write] = block_move;
-        m_actual_speed_id_map.emplace_back(block_id, (unsigned int)write);
-        for (; entry > 0 && actual_speed_moves[entry - 1].position.has_value(); --entry) {
-            const TimeMachine::ActualSpeedMove& it = actual_speed_moves[entry - 1];
-            GCodeProcessorResult::MoveVertex new_move = block_move;
+    // insert actual speed moves into the move list
+    unsigned int inserted_actual_speed_moves_count = 0;
+    std::vector<GCodeProcessorResult::MoveVertex> new_moves;
+    std::map<unsigned int, unsigned int> id_map;
+    for (auto it = actual_speed_moves.begin(); it != actual_speed_moves.end(); ++it) {
+        const unsigned int base_id = it->move_id + inserted_actual_speed_moves_count;
+        if (it->position.has_value()) {
+            // insert actual speed move into the move list
+            // clone from existing move
+            GCodeProcessorResult::MoveVertex new_move = result.moves[base_id];
+            // override modified parameters
             new_move.time = { 0.0f, 0.0f };
-            new_move.position = *it.position;
-            new_move.actual_feedrate = it.actual_feedrate;
-            new_move.delta_extruder = *it.delta_extruder;
-            new_move.feedrate = *it.feedrate;
-            new_move.width = *it.width;
-            new_move.height = *it.height;
-            new_move.mm3_per_mm = *it.mm3_per_mm;
-            new_move.fan_speed = *it.fan_speed;
-            new_move.temperature = *it.temperature;
+            new_move.position = *it->position;
+            new_move.actual_feedrate = it->actual_feedrate;
+            new_move.delta_extruder = *it->delta_extruder;
+            new_move.feedrate = *it->feedrate;
+            new_move.width = *it->width;
+            new_move.height = *it->height;
+            new_move.mm3_per_mm = *it->mm3_per_mm;
+            new_move.fan_speed = *it->fan_speed;
+            new_move.temperature = *it->temperature;
             new_move.internal_only = true;
-            moves[--write] = new_move;
+            new_moves.push_back(new_move);
+        }
+        else {
+            result.moves.insert(result.moves.begin() + base_id, new_moves.begin(), new_moves.end());
+            id_map[it->move_id] = base_id + new_moves.size();
+            // update move actual speed
+            result.moves[base_id + new_moves.size()].actual_feedrate = it->actual_feedrate;
+            inserted_actual_speed_moves_count += new_moves.size();
+            // synchronize seams actual speed
+            if (base_id + new_moves.size() + 1 < result.moves.size()) {
+                GCodeProcessorResult::MoveVertex& move = result.moves[base_id + new_moves.size() + 1];
+                if (move.type == EMoveType::Seam)
+                    move.actual_feedrate = it->actual_feedrate;
+            }
+            new_moves.clear();
         }
     }
-    assert(read == write);
 
     // synchronize blocks' move_ids with after moves for actual speed insertion
-    std::reverse(m_actual_speed_id_map.begin(), m_actual_speed_id_map.end());
     for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
         for (GCodeProcessor::TimeBlock& block : m_time_processor.machines[i].blocks) {
-            auto it = std::lower_bound(m_actual_speed_id_map.begin(), m_actual_speed_id_map.end(), block.move_id,
-                                       [](const std::pair<unsigned int, unsigned int>& entry, unsigned int id) { return entry.first < id; });
-            block.move_id = (it != m_actual_speed_id_map.end() && it->first == block.move_id) ?
-                                it->second : block.move_id + (unsigned int)inserted_actual_speed_moves_count;
+            auto it = id_map.find(block.move_id);
+            block.move_id = (it != id_map.end()) ? it->second : block.move_id + inserted_actual_speed_moves_count;
         }
     }
 }

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -337,57 +337,54 @@ class Print;
 
         //BBS: add mutex for protection of gcode result
         mutable std::mutex result_mutex;
-        GCodeProcessorResult& operator=(const GCodeProcessorResult &other) { assign(other); return *this; }
-        // Declared because the user-declared copy assignment suppresses the implicit move.
-        GCodeProcessorResult& operator=(GCodeProcessorResult &&other) { assign(std::move(other)); return *this; }
-        // Add a new member here, or neither assignment transfers it.
-        template<class Other> void assign(Other &&other)
+        GCodeProcessorResult& operator=(const GCodeProcessorResult &other)
         {
-            filename = std::forward<Other>(other).filename;
-            id = std::forward<Other>(other).id;
-            moves = std::forward<Other>(other).moves;
-            lines_ends = std::forward<Other>(other).lines_ends;
-            printable_area = std::forward<Other>(other).printable_area;
-            bed_exclude_area = std::forward<Other>(other).bed_exclude_area;
-            wrapping_exclude_area = std::forward<Other>(other).wrapping_exclude_area;
-            toolpath_outside = std::forward<Other>(other).toolpath_outside;
-            label_object_enabled = std::forward<Other>(other).label_object_enabled;
-            long_retraction_when_cut = std::forward<Other>(other).long_retraction_when_cut;
-            timelapse_warning_code = std::forward<Other>(other).timelapse_warning_code;
-            printable_height = std::forward<Other>(other).printable_height;
-            settings_ids = std::forward<Other>(other).settings_ids;
-            filaments_count = std::forward<Other>(other).filaments_count;
-            extruder_colors = std::forward<Other>(other).extruder_colors;
-            filament_diameters = std::forward<Other>(other).filament_diameters;
-            filament_densities = std::forward<Other>(other).filament_densities;
-            filament_costs = std::forward<Other>(other).filament_costs;
-            print_statistics = std::forward<Other>(other).print_statistics;
-            custom_gcode_per_print_z = std::forward<Other>(other).custom_gcode_per_print_z;
-            spiral_vase_mode = std::forward<Other>(other).spiral_vase_mode;
-            warnings = std::forward<Other>(other).warnings;
-            bed_type = std::forward<Other>(other).bed_type;
-            gcode_check_result = std::forward<Other>(other).gcode_check_result;
-            limit_filament_maps = std::forward<Other>(other).limit_filament_maps;
-            filament_printable_reuslt = std::forward<Other>(other).filament_printable_reuslt;
+            filename = other.filename;
+            id = other.id;
+            moves = other.moves;
+            lines_ends = other.lines_ends;
+            printable_area = other.printable_area;
+            bed_exclude_area = other.bed_exclude_area;
+            wrapping_exclude_area = other.wrapping_exclude_area;
+            toolpath_outside = other.toolpath_outside;
+            label_object_enabled = other.label_object_enabled;
+            long_retraction_when_cut = other.long_retraction_when_cut;
+            timelapse_warning_code = other.timelapse_warning_code;
+            printable_height = other.printable_height;
+            settings_ids = other.settings_ids;
+            filaments_count = other.filaments_count;
+            extruder_colors = other.extruder_colors;
+            filament_diameters = other.filament_diameters;
+            filament_densities = other.filament_densities;
+            filament_costs = other.filament_costs;
+            print_statistics = other.print_statistics;
+            custom_gcode_per_print_z = other.custom_gcode_per_print_z;
+            spiral_vase_mode = other.spiral_vase_mode;
+            warnings = other.warnings;
+            bed_type = other.bed_type;
+            gcode_check_result = other.gcode_check_result;
+            limit_filament_maps = other.limit_filament_maps;
+            filament_printable_reuslt = other.filament_printable_reuslt;
             // Orca: copy the shared grouping result so a copied result keeps it (shared_ptr =>
             // memory-safe), rather than leaving a stale pointer on the target. No g-code effect either way.
-            nozzle_group_result = std::forward<Other>(other).nozzle_group_result;
+            nozzle_group_result = other.nozzle_group_result;
             // Keep the per-extruder hotend types on a copied result (injector input).
-            extruder_types = std::forward<Other>(other).extruder_types;
-            printer_extruder_variant = std::forward<Other>(other).printer_extruder_variant;
-            printer_extruder_id = std::forward<Other>(other).printer_extruder_id;
-            layer_filaments = std::forward<Other>(other).layer_filaments;
-            filament_change_sequence = std::forward<Other>(other).filament_change_sequence;
-            used_mixed_filaments = std::forward<Other>(other).used_mixed_filaments;
-            nozzle_change_sequence = std::forward<Other>(other).nozzle_change_sequence;
-            optimal_assignment = std::forward<Other>(other).optimal_assignment;
-            filament_change_count_map = std::forward<Other>(other).filament_change_count_map;
+            extruder_types = other.extruder_types;
+            printer_extruder_variant = other.printer_extruder_variant;
+            printer_extruder_id = other.printer_extruder_id;
+            layer_filaments = other.layer_filaments;
+            filament_change_sequence = other.filament_change_sequence;
+            used_mixed_filaments = other.used_mixed_filaments;
+            nozzle_change_sequence = other.nozzle_change_sequence;
+            optimal_assignment = other.optimal_assignment;
+            filament_change_count_map = other.filament_change_count_map;
             // Keep the SKIPPABLE per-type time on a copied result.
-            skippable_part_time = std::forward<Other>(other).skippable_part_time;
-            initial_layer_time = std::forward<Other>(other).initial_layer_time;
+            skippable_part_time = other.skippable_part_time;
+            initial_layer_time = other.initial_layer_time;
 #if ENABLE_GCODE_VIEWER_STATISTICS
-            time = std::forward<Other>(other).time;
+            time = other.time;
 #endif
+            return *this;
         }
         void  lock() const { result_mutex.lock(); }
         void  unlock() const { result_mutex.unlock(); }
@@ -1219,9 +1216,6 @@ class Print;
         EProducer m_producer;
 
         TimeProcessor m_time_processor;
-        // calculate_time()'s map from each block's move id to its index after the actual speed moves are inserted,
-        // a member to reuse its capacity.
-        std::vector<std::pair<unsigned int, unsigned int>> m_actual_speed_id_map;
         UsedFilaments m_used_filaments;
 
         Print* m_print{ nullptr };

src/libslic3r/GCodeWriter.cpp

@@ -465,31 +465,32 @@ std::string GCodeWriter::set_accel_and_jerk(unsigned int acceleration, double je
     if (EXTRUDER_LIMIT(m_max_acceleration) > 0 && acceleration > EXTRUDER_LIMIT(m_max_acceleration))
         acceleration = EXTRUDER_LIMIT(m_max_acceleration);
     
+    bool is_empty = true;
+    std::ostringstream gcode;
+    gcode << "SET_VELOCITY_LIMIT";
+    if (acceleration != 0 && acceleration != m_last_acceleration) {
+        gcode << " ACCEL=" << acceleration;
+        if (this->config.accel_to_decel_enable) {
+            gcode << " ACCEL_TO_DECEL=" << acceleration * this->config.accel_to_decel_factor / 100;
+        }
+        m_last_acceleration = acceleration;
+        is_empty = false;
+    }
     // Clamp the jerk to the allowed maximum.
     if (EXTRUDER_LIMIT(m_max_jerk_x) > 0 && jerk > EXTRUDER_LIMIT(m_max_jerk_x))
         jerk = EXTRUDER_LIMIT(m_max_jerk_x);
     if (EXTRUDER_LIMIT(m_max_jerk_y) > 0 && jerk > EXTRUDER_LIMIT(m_max_jerk_y))
         jerk = EXTRUDER_LIMIT(m_max_jerk_y);
 
-    const bool set_acceleration = acceleration != 0 && acceleration != m_last_acceleration;
-    const bool set_jerk         = jerk > 0.01 && !is_approx(jerk, m_last_jerk);
-    if (!set_acceleration && !set_jerk)
-        return std::string();
-
-    std::ostringstream gcode;
-    gcode << "SET_VELOCITY_LIMIT";
-    if (set_acceleration) {
-        gcode << " ACCEL=" << acceleration;
-        if (this->config.accel_to_decel_enable) {
-            gcode << " ACCEL_TO_DECEL=" << acceleration * this->config.accel_to_decel_factor / 100;
-        }
-        m_last_acceleration = acceleration;
-    }
-    if (set_jerk) {
+    if (jerk > 0.01 && !is_approx(jerk, m_last_jerk)) {
         gcode << " SQUARE_CORNER_VELOCITY=" << jerk;
         m_last_jerk = jerk;
+        is_empty = false;
     }
 
+    if(is_empty)
+        return std::string();
+
     if (GCodeWriter::full_gcode_comment)
         gcode << " ; adjust VELOCITY_LIMIT(accel/jerk)";
     gcode << "\n";

src/libslic3r/LocalesUtils.cpp

@@ -84,19 +84,6 @@ double string_to_double_decimal_point(const std::string_view str, size_t* pos /*
     return out;
 }
 
-double atof_decimal_point(std::string_view str)
-{
-    size_t i = 0;
-    while (i < str.size() && (str[i] == ' ' || (str[i] >= '\t' && str[i] <= '\r')))
-        ++i;
-    if (i < str.size() && str[i] == '+') {
-        ++i;
-        if (i < str.size() && str[i] == '-')
-            return 0.;
-    }
-    return string_to_double_decimal_point(str.substr(i));
-}
-
 std::string float_to_string_decimal_point(double value, int precision/* = -1*/)
 {
     // Our Windows build server fully supports C++17 std::to_chars. Let's use it.

src/libslic3r/LocalesUtils.hpp

@@ -48,9 +48,6 @@ bool is_decimal_separator_point();
 std::string float_to_string_decimal_point(double value, int precision = -1);
 //std::string float_to_string_decimal_point(float value,  int precision = -1);
 double string_to_double_decimal_point(const std::string_view str, size_t* pos = nullptr);
-// Parses like atof in the C locale, skipping leading whitespace and a '+',
-// without the C runtime's per-call locale lookup.
-double atof_decimal_point(std::string_view str);
 
 } // namespace Slic3r
 

src/libslic3r/PresetBundle.cpp

@@ -5310,7 +5310,7 @@ static void apply_receiver_mix_relocations(DynamicPrintConfig&
 
 
 //convert the old filament preset to new one after split
-void PresetBundle::convert_filament_preset_name(const std::string& machine_name, std::string& filament_name)
+static void convert_filament_preset_name(std::string& machine_name, std::string& filament_name)
 {
     auto machine_iter = filament_preset_convert.find(machine_name);
     if (machine_iter != filament_preset_convert.end())

src/libslic3r/PresetBundle.hpp

@@ -247,9 +247,6 @@ public:
     // 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<std::string> project_different_keys(const std::string &different_settings);
-    // A project filament saved under a name the current presets split per nozzle (e.g. H2D 0.6) is loaded from
-    // the preset that now holds its values.
-    static void convert_filament_preset_name(const std::string& machine_name, std::string& filament_name);
 
     PresetBundle();
     PresetBundle(const PresetBundle &rhs);

src/libslic3r/Utils.hpp

@@ -25,8 +25,6 @@
 #include <initializer_list>
 #include <string_view>
 #include <regex>
-#include <string_view>
-#include <algorithm>
 
 #include <boost/system/error_code.hpp>
 #include <boost/algorithm/string.hpp>
@@ -304,14 +302,6 @@ extern bool is_absolute_path_within_root(const boost::filesystem::path &path, co
 // Anything unknown is not safe.
 extern bool is_safe_to_open_file_name(const std::string &file_name);
 
-// Case-insensitive compare against a fixed ASCII keyword, without boost::iequals, whose
-// std::locale() takes a lock the whole process shares in the MSVC runtime.
-inline bool ascii_iequals(std::string_view a, std::string_view b)
-{
-    auto lower = [](char c) { return (c >= 'A' && c <= 'Z') ? char(c - 'A' + 'a') : c; };
-    return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin(), [&lower](char x, char y) { return lower(x) == lower(y); });
-}
-
 // Orca: custom protocal support utils
 inline bool is_orca_open(const std::string& url) { return boost::starts_with(url, "orcaslicer://open"); }
 inline bool is_prusaslicer_open(const std::string& url) { return boost::starts_with(url, "prusaslicer://open"); }

src/slic3r/GUI/MainFrame.hpp

@@ -184,8 +184,7 @@ class MainFrame : public DPIFrame
         std::string m_name{ "prepare_layout" };
         wxSize      m_laid_out_size;
     } m_prepare_layout_prebuild{ *this };
-    // Every built-in LazyPage, in and out of the book; prebuild_pages_when_idle() registers them.
-    // Plugin pages stay out: PluginPages destroys them at runtime.
+    // Every LazyPage, in and out of the book; prebuild_pages_when_idle() registers them.
     std::vector<LazyBase*> m_lazy_pages;
     // The latest EVT_LOAD_PRINTER_URL, applied when the web Device view is built.
     wxString              m_printer_url;

src/slic3r/GUI/PrinterWebView.cpp

@@ -119,13 +119,33 @@ PrinterWebView::PrinterWebView(wxWindow *parent)
     wxBoxSizer* topsizer = new wxBoxSizer(wxVERTICAL);
 
       // Create the webview
-    create_browser();
-    m_reset_on_show = WebView::NeedsRecreateOnShow();
+    m_browser = WebView::CreateWebView(this, "");
+    if (m_browser == nullptr) {
+        wxLogError("Could not init m_browser");
+        return;
+    }
+
+#ifdef __linux__
+    inject_vue_resize_workaround(m_browser);
+
+    auto cookiesPath = boost::filesystem::path(data_dir() + "/cache/cookies.db");
+    auto wv = static_cast<WebKitWebView*>(m_browser->GetNativeBackend());
+    auto wv_ctx = webkit_web_view_get_context(wv);
+    auto cookieManager = webkit_web_context_get_cookie_manager(wv_ctx);
+    webkit_cookie_manager_set_persistent_storage(cookieManager, cookiesPath.c_str(), WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE);
+#endif
+
+    m_browser->Bind(wxEVT_WEBVIEW_ERROR, &PrinterWebView::OnError, this);
+    m_browser->Bind(wxEVT_WEBVIEW_LOADED, &PrinterWebView::OnLoaded, this);
+    m_browser->Bind(wxEVT_WEBVIEW_NEWWINDOW, &PrinterWebView::OnNewWindow, this);
+    m_browser->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, &PrinterWebView::OnScriptMessage, this);
 
     SetSizer(topsizer);
 
     topsizer->Add(m_browser, wxSizerFlags().Expand().Proportion(1));
 
+    update_mode();
+
     // Log backend information
     /* m_browser->GetUserAgent() may lead crash
     if (wxGetApp().get_mode() == comDevelop) {
@@ -157,44 +177,12 @@ PrinterWebView::~PrinterWebView()
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " End";
 }
 
-void PrinterWebView::create_browser()
-{
-    m_browser = WebView::CreateWebView(this, "");
-
-#ifdef __linux__
-    inject_vue_resize_workaround(m_browser);
-
-    auto cookiesPath = boost::filesystem::path(data_dir() + "/cache/cookies.db");
-    auto wv = static_cast<WebKitWebView*>(m_browser->GetNativeBackend());
-    auto wv_ctx = webkit_web_view_get_context(wv);
-    auto cookieManager = webkit_web_context_get_cookie_manager(wv_ctx);
-    webkit_cookie_manager_set_persistent_storage(cookieManager, cookiesPath.c_str(), WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE);
-#endif
-
-    m_browser->Bind(wxEVT_WEBVIEW_ERROR, &PrinterWebView::OnError, this);
-    m_browser->Bind(wxEVT_WEBVIEW_LOADED, &PrinterWebView::OnLoaded, this);
-    m_browser->Bind(wxEVT_WEBVIEW_NEWWINDOW, &PrinterWebView::OnNewWindow, this);
-    m_browser->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, &PrinterWebView::OnScriptMessage, this);
-    update_mode();
-}
-
-void PrinterWebView::reset_browser()
-{
-    m_browser->Destroy(); // also removes it from the sizer
-    create_browser();
-    GetSizer()->Add(m_browser, wxSizerFlags().Expand().Proportion(1));
-    Layout();
-
-    // OnLoaded may have cleared m_url_deferred already, so requeue the last url for Show().
-    m_apikey_sent  = false;
-    m_url_deferred = m_url;
-}
-
 void PrinterWebView::load_url(wxString& url, wxString apikey)
 {
 //    this->Show();
 //    this->Raise();
-    m_url = url;
+    if (m_browser == nullptr)
+        return;
     m_apikey = apikey;
     m_apikey_sent = false;
     m_handler = create_printer_webview_handler(*this);
@@ -212,8 +200,6 @@ void PrinterWebView::load_url(wxString& url, wxString apikey)
 
 bool PrinterWebView::Show(bool show)
 {
-    if (show && std::exchange(m_reset_on_show, false))
-        reset_browser();
     if (show && !m_url_deferred.empty()) {
         m_browser->LoadURL(m_url_deferred);
         //ORCA: m_url_deferred will be cleared on load success

src/slic3r/GUI/PrinterWebView.hpp

@@ -58,18 +58,13 @@ private:
     friend class PrinterWebViewHandler;
 
     void SendAPIKey();
-    void create_browser();
-    void reset_browser();
 
     wxWebView* m_browser;
     long m_zoomFactor;
     wxString m_apikey;
     bool m_apikey_sent;
-    // Last url passed to load_url(), reloaded after reset_browser().
-    wxString m_url;
     wxString m_url_deferred;
     std::unique_ptr<PrinterWebViewHandler> m_handler;
-    bool m_reset_on_show{false};
 
     // DECLARE_EVENT_TABLE()
 };

src/slic3r/GUI/Project.cpp

@@ -80,10 +80,16 @@ ProjectPanel::ProjectPanel(wxWindow *parent, wxWindowID id, const wxPoint &pos,
 
     wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);
 
-    create_browser();
-    m_reset_on_show = WebView::NeedsRecreateOnShow();
+    m_browser = WebView::CreateWebView(this, m_project_home_url);
+    if (m_browser == nullptr) {
+        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("load web view of project page failed");
+        return;
+    }
     //m_browser->Hide();
     main_sizer->Add(m_browser, wxSizerFlags().Expand().Proportion(1));
+    m_browser->Bind(wxEVT_WEBVIEW_NAVIGATED, &ProjectPanel::on_navigated, this);
+    m_browser->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, &ProjectPanel::OnScriptMessage, this, m_browser->GetId());
+    Bind(wxEVT_WEBVIEW_NAVIGATING, &ProjectPanel::onWebNavigating, this, m_browser->GetId());
 
     Bind(EVT_PROJECT_RELOAD, &ProjectPanel::on_reload, this);
 
@@ -111,23 +117,6 @@ void ProjectPanel::shutdown()
     m_reload_task.reset();
 }
 
-void ProjectPanel::create_browser()
-{
-    m_browser = WebView::CreateWebView(this, m_project_home_url);
-    m_browser->Bind(wxEVT_WEBVIEW_NAVIGATED, &ProjectPanel::on_navigated, this);
-    m_browser->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, &ProjectPanel::OnScriptMessage, this, m_browser->GetId());
-    m_browser->Bind(wxEVT_WEBVIEW_NAVIGATING, &ProjectPanel::onWebNavigating, this);
-}
-
-void ProjectPanel::reset_browser()
-{
-    m_browser->Destroy(); // also removes it from the sizer
-    create_browser();
-    GetSizer()->Insert(0, m_browser, wxSizerFlags().Expand().Proportion(1));
-    Layout();
-    m_web_init_completed.store(false, std::memory_order_release);
-}
-
 // Helper to convert newlines to <br>
 static std::string convert_newlines_to_br(const std::string& text) {
     std::string result = text;
@@ -292,13 +281,12 @@ void ProjectPanel::on_reload(wxCommandEvent& evt)
 
         wxString strJS = wxString::Format("HandleStudio(%s)", m_Res.dump(-1, ' ', false, json::error_handler_t::ignore));
 
-        if (!cancel_token->load(std::memory_order_acquire) && wxTheApp != nullptr && !wxGetApp().is_closing()) {
+        if (m_web_init_completed.load(std::memory_order_acquire) &&
+            !cancel_token->load(std::memory_order_acquire) && wxTheApp != nullptr && !wxGetApp().is_closing()) {
             wxGetApp().CallAfter([this, cancel_token, strJS] {
                 if (cancel_token->load(std::memory_order_acquire) || wxTheApp == nullptr || wxGetApp().is_closing())
                     return;
-                m_info_script = strJS.ToStdString();
-                if (m_web_init_completed.load(std::memory_order_acquire))
-                    RunScript(m_info_script);
+                RunScript(strJS.ToStdString());
             });
         }
     });
@@ -339,11 +327,6 @@ void ProjectPanel::OnScriptMessage(wxWebViewEvent& evt)
         }
         else if (strCmd == "request_3mf_info") {
             m_web_init_completed.store(true, std::memory_order_release);
-            // Replay the stored info after each page load.
-            CallAfter([this] {
-                if (!m_info_script.empty())
-                    RunScript(m_info_script);
-            });
         }
         else if (strCmd == "edit_project_info") {
             show_info_editor(true);
@@ -400,8 +383,6 @@ void ProjectPanel::clear_model_info()
     wxGetApp().CallAfter([this, cancel_token, strJS] {
         if (cancel_token->load(std::memory_order_acquire) || wxTheApp == nullptr || wxGetApp().is_closing())
             return;
-        // Runs after any store queued by an earlier reload pass, so stale info is never replayed.
-        m_info_script.clear();
         RunScript(strJS.ToStdString());
     });
 }
@@ -544,8 +525,6 @@ void ProjectPanel::RunScript(std::string content)
 
 bool ProjectPanel::Show(bool show) 
 {
-    if (show && std::exchange(m_reset_on_show, false))
-        reset_browser();
     if (show) update_model_data();
     return wxPanel::Show(show); 
 }

src/slic3r/GUI/Project.hpp

@@ -80,14 +80,9 @@ private:
     AuxiliaryPanel*   m_auxiliary{nullptr};
     wxString   m_project_home_url;
     wxString   m_root_dir;
-    // Last show_3mf_info script, also sent whenever the page asks for it.
-    std::string m_info_script;
-    bool       m_reset_on_show{false};
     static inline std::atomic<int> m_sequence_id{8000};
 
     void show_info_editor(bool show);
-    void create_browser();
-    void reset_browser();
     
 
 public:

src/slic3r/GUI/WebViewDialog.cpp

@@ -62,10 +62,10 @@ namespace GUI {
 WebViewPanel::WebViewPanel(wxWindow *parent)
         : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
  {
-    m_home_url = file_url_from_path(boost::filesystem::path(resources_dir()) / "web/homepage/index.html");
+    wxString url = file_url_from_path(boost::filesystem::path(resources_dir()) / "web/homepage/index.html");
     wxString strlang = wxGetApp().current_language_code_safe();
     if (strlang != "")
-        m_home_url += "?lang=" + strlang;
+        url += "?lang=" + strlang;
 
     wxBoxSizer* topsizer = new wxBoxSizer(wxVERTICAL);
     
@@ -109,8 +109,12 @@ WebViewPanel::WebViewPanel(wxWindow *parent)
     m_info = new wxInfoBar(this);
     topsizer->Add(m_info, wxSizerFlags().Expand());
     // Create the webview
-    create_browser();
-    m_reset_on_show = WebView::NeedsRecreateOnShow();
+    m_browser = WebView::CreateWebView(this, url);
+    if (m_browser == nullptr) {
+        wxLogError("Could not init m_browser");
+        return;
+    }
+    m_browser->Hide();
     SetSizer(topsizer);
 
     topsizer->Add(m_browser, wxSizerFlags().Expand().Proportion(1));
@@ -260,27 +264,6 @@ WebViewPanel::~WebViewPanel()
 }
 
 
-void WebViewPanel::create_browser()
-{
-    m_browser = WebView::CreateWebView(this, m_home_url);
-    m_browser->Hide();
-}
-
-void WebViewPanel::reset_browser()
-{
-    m_browser->Destroy(); // also removes it from the sizer
-    create_browser();
-    GetSizer()->Add(m_browser, wxSizerFlags().Expand().Proportion(1));
-    Layout();
-}
-
-bool WebViewPanel::Show(bool show)
-{
-    if (show && std::exchange(m_reset_on_show, false))
-        reset_browser();
-    return wxPanel::Show(show);
-}
-
 void WebViewPanel::load_url(wxString& url)
 {
     this->Show();

src/slic3r/GUI/WebViewDialog.hpp

@@ -113,15 +113,9 @@ public:
     int  get_model_mall_detail_url(std::string *url, std::string id);
 
     void update_mode();
-
-    bool Show(bool show = true) override;
 private:
-    void create_browser();
-    void reset_browser();
 
     wxWebView* m_browser;
-    wxString m_home_url;
-    bool m_reset_on_show{false};
     wxButton *  m_button_stop;
     wxTextCtrl *m_url;
 #if !BBL_RELEASE_TO_PUBLIC

src/slic3r/GUI/Widgets/WebView.cpp

@@ -381,17 +381,6 @@ void WebView::MarkScriptMessageHandlerAdded(wxWebView * webView)
     if (WebViewRef *ref = webview_ref(webView))
         ref->m_script_handler_added = true;
 }
-
-bool WebView::NeedsRecreateOnShow()
-{
-    const bool recreating = Slic3r::GUI::wxGetApp().is_recreating_gui();
-    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": is_recreating_gui = " << recreating;
-#ifdef __WIN32__
-    return recreating;
-#else
-    return false;
-#endif
-}
 #if wxUSE_WEBVIEW_EDGE
 bool WebView::CheckWebViewRuntime()
 {

src/slic3r/GUI/Widgets/WebView.hpp

@@ -23,10 +23,6 @@ public:
     // Marks "wx" as registered so CreateWebView's deferred add skips the duplicate.
     static void MarkScriptMessageHandlerAdded(wxWebView * webView);
 
-    // On Windows, a WebView2 backend created during a GUI rebuild (language switch) can come up
-    // ignoring every navigation. A panel that gets true here recreates its view on first Show().
-    static bool NeedsRecreateOnShow();
-
     static void RecreateAll();
 };
 

src/slic3r/plugin/host/PluginPages.cpp

@@ -1,7 +1,6 @@
 #include "PluginPages.hpp"
 
 #include "libslic3r/AppConfig.hpp"
-#include "slic3r/GUI/GUI.hpp"
 #include "slic3r/GUI/Notebook.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/Widgets/Button.hpp"
@@ -184,10 +183,8 @@ void PluginPages::initialize(Notebook* parent)
 
 void PluginPages::shutdown()
 {
-    // Removing the selected tab selects the tab to its left. In tab order that is a built-in tab,
-    // never an unbuilt plugin page that is removed next and would be built only to be destroyed.
-    for (const PluginCapabilityId& id : std::vector<PluginCapabilityId>(m_order))
-        remove_page(id);
+    while (!m_pages.empty())
+        remove_page(m_pages.begin()->first);
     m_parent = nullptr;
 }
 
@@ -228,7 +225,8 @@ bool PluginPages::create_page(const PluginCapabilityId& id)
         BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " Failed to get icon for plugin " << id.plugin_key;
     }
 
-    wxBitmap bitmap;
+    auto* page = new PluginPage(m_parent, std::move(capability));
+
     if (!icon.empty()) {
         try {
             boost::filesystem::path icon_path(icon);
@@ -236,7 +234,7 @@ bool PluginPages::create_page(const PluginCapabilityId& id)
             if (extension == ".svg" || extension == ".png")
                 icon_path.replace_extension();
 
-            bitmap = create_scaled_bitmap(icon_path.string(), m_parent, 20);
+            page->set_icon(create_scaled_bitmap(icon_path.string(), m_parent, 20));
         } catch (const std::exception& error) {
             BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " Failed to load icon for plugin " << id.plugin_key << ": " << error.what();
         } catch (...) {
@@ -244,15 +242,7 @@ bool PluginPages::create_page(const PluginCapabilityId& id)
         }
     }
 
-    // Built the first time its tab is shown, so a language switch never creates the page's browser
-    // while the main window is being rebuilt. Never prebuilt: the idle queue cannot drop a page
-    // that remove_page() destroys.
-    auto* page = new GUI::LazyPage<PluginPage>(m_parent, GUI::into_u8(page_tab_id(id)), -1,
-                                               [capability = std::move(capability)](wxWindow* parent) {
-                                                   return new PluginPage(parent, capability);
-                                               });
-
-    m_pages.emplace(id, Page{page, bitmap});
+    m_pages.emplace(id, page);
     m_order.push_back(id);
     return true;
 }
@@ -281,10 +271,16 @@ void PluginPages::on_plugin_register(const std::string& plugin_key)
 
 void PluginPages::on_plugin_deregister(const std::string& plugin_key)
 {
-    // In tab order, as in shutdown().
-    for (const PluginCapabilityId& id : std::vector<PluginCapabilityId>(m_order))
-        if (id.plugin_key == plugin_key)
-            remove_page(id);
+    for (auto it = m_pages.begin(); it != m_pages.end();) {
+        if (it->first.plugin_key != plugin_key) {
+            ++it;
+            continue;
+        }
+
+        const PluginCapabilityId id = it->first;
+        ++it;
+        remove_page(id);
+    }
 }
 
 void PluginPages::remove_page(const PluginCapabilityId& id)
@@ -293,10 +289,8 @@ void PluginPages::remove_page(const PluginCapabilityId& id)
     if (it == m_pages.end())
         return;
 
-    GUI::LazyPage<PluginPage>* page = it->second.page;
-    // Only a built page has installed a message sender on the capability.
-    if (PluginPage* built = page->get())
-        built->detach_capability();
+    PluginPage* page = it->second;
+    page->detach_capability();
 
     m_pages.erase(it);
     m_order.erase(std::remove(m_order.begin(), m_order.end(), id), m_order.end());
@@ -354,27 +348,26 @@ void PluginPages::relayout()
     bool up_to_date = page_count >= tab_ids.size();
     for (size_t i = 0; up_to_date && i < tab_ids.size(); ++i)
         up_to_date = m_parent->GetPageName(page_count - tab_ids.size() + i) == page_tab_id(tab_ids[i]);
-    for (const auto& [id, entry] : m_pages) {
+    for (const auto& [id, page] : m_pages) {
         if (!up_to_date)
             break;
         const bool wanted = std::find(tab_ids.begin(), tab_ids.end(), id) != tab_ids.end();
-        up_to_date = entry.page->in_book() == wanted;
+        up_to_date = (m_parent->FindPage(page) != wxNOT_FOUND) == wanted;
     }
 
     if (!up_to_date) {
         const wxString id_to_reselect = m_parent->GetSelectedPageName();
 
-        // In tab order, as in shutdown().
-        for (const auto& id : m_order) {
-            const int idx = m_parent->FindPage(m_pages.at(id).page);
+        for (const auto& [id, page] : m_pages) {
+            const int idx = m_parent->FindPage(page);
             if (idx != wxNOT_FOUND)
                 m_parent->RemovePage(idx);
         }
 
         for (const auto& id : tab_ids) {
-            const Page& entry = m_pages.at(id);
-            m_parent->InsertPage(m_parent->GetPageCount(), page_tab_id(id), entry.page, wxString::FromUTF8(id.name), "",
-                                 false, entry.icon);
+            PluginPage* page = m_pages.at(id);
+            m_parent->InsertPage(m_parent->GetPageCount(), page_tab_id(id), page, wxString::FromUTF8(id.name), "",
+                                 false, page->icon());
         }
 
         if (!id_to_reselect.empty())

src/slic3r/plugin/host/PluginPages.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <slic3r/GUI/LazyPage.hpp>
 #include <slic3r/GUI/WebPanel.hpp>
 #include <slic3r/plugin/PythonPluginInterface.hpp>
 #include <slic3r/plugin/pluginTypes/pages/PagesPluginCapability.hpp>
@@ -30,6 +29,8 @@ public:
 
     void detach_capability();
     void push_message(const std::string& message);
+    void set_icon(const wxBitmap& icon) { m_icon = icon; }
+    const wxBitmap& icon() const { return m_icon; }
 
 protected:
     std::optional<std::string> page_html() override;
@@ -40,6 +41,7 @@ private:
 
     std::shared_ptr<PagesPluginCapability> m_cap;
     std::shared_ptr<std::atomic<PluginPage*>> m_lifetime;
+    wxBitmap m_icon;
 };
 
 class PluginPages
@@ -71,13 +73,7 @@ private:
     void show_overflow_menu();
     static wxString page_tab_id(const PluginCapabilityId& id);
 
-    struct Page
-    {
-        GUI::LazyPage<PluginPage>* page{nullptr};
-        wxBitmap                   icon;
-    };
-
-    std::map<PluginCapabilityId, Page> m_pages;
+    std::map<PluginCapabilityId, PluginPage*> m_pages;
     std::vector<PluginCapabilityId> m_order;
     Notebook* m_parent{nullptr};
 

tests/cli/CMakeLists.txt

@@ -23,10 +23,3 @@ set_tests_properties(cli_project_missing_keys PROPERTIES
     LABELS "CLI;RequiresApp"
     SKIP_RETURN_CODE 77
     TIMEOUT 900)
-
-add_test(NAME cli_malformed_input
-    COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_malformed_input.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON})
-set_tests_properties(cli_malformed_input PROPERTIES
-    LABELS "CLI;RequiresApp"
-    SKIP_RETURN_CODE 77
-    TIMEOUT 900)

tests/cli/test_cli_malformed_input.sh

@@ -1,207 +0,0 @@
-#!/usr/bin/env bash
-# End-to-end checks that malformed CLI input fails cleanly, or loads, instead of crashing the
-# orca-slicer binary. Each case lives inline in CLI::run(), so only the binary can reach it.
-#
-# - A project whose inherits_group does not have one entry per filament plus the process and
-#   printer entries still loads.
-# - --slice N --arrange 1 on a project without plate metadata slices plate N.
-# - An assemble list object with an empty filament list, or a negative filament id, is rejected
-#   as a config error.
-# - --assemble with no input model is rejected as invalid parameters.
-#
-# usage: test_cli_malformed_input.sh <orca-slicer binary> <python3>
-set -u
-
-BIN="${1:-}"
-PY="${2:-python3}"
-# 77 is the test's SKIP_RETURN_CODE.
-[ -x "$BIN" ] || { echo "SKIP: orca-slicer binary not found: $BIN"; exit 77; }
-
-# From src/libslic3r/Utils.hpp. main() returns them, so the shell sees them modulo 256.
-CLI_SUCCESS=0
-CLI_INVALID_PARAMS=-2
-CLI_CONFIG_FILE_ERROR=-5
-
-WORK="$(mktemp -d "${TMPDIR:-/tmp}/orca-cli-malformed.XXXXXX")"
-trap 'rm -rf "$WORK"' EXIT
-mkdir -p "$WORK/datadir"
-
-# Standalone presets: without "inherits" the CLI loads them as-is, with no preset bundle.
-cat > "$WORK/machine.json" <<'EOF'
-{
-    "type": "machine",
-    "from": "User",
-    "name": "CLI malformed input test printer",
-    "printable_area": ["0x0", "200x0", "200x200", "0x200"],
-    "printable_height": "100",
-    "layer_change_gcode": "G92 E0"
-}
-EOF
-cat > "$WORK/process.json" <<'EOF'
-{
-    "type": "process",
-    "from": "User",
-    "name": "CLI malformed input test process"
-}
-EOF
-cat > "$WORK/filament.json" <<'EOF'
-{
-    "type": "filament",
-    "from": "User",
-    "name": "CLI malformed input test filament"
-}
-EOF
-
-"$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")
-    # Faces wound counter-clockwise seen from outside: -z, +z, -y, +y, -x, +x.
-    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 ((a, b, c), (a, c, d)):
-            f.write("facet normal 0 0 0\nouter loop\n")
-            for i in tri:
-                f.write("vertex %g %g %g\n" % v[i])
-            f.write("endloop\nendfacet\n")
-    f.write("endsolid cube\n")
-EOF
-
-fails=0
-fail() { echo "FAIL: $*"; fails=$((fails + 1)); }
-
-# run <tag> [option...]: run into $WORK/<tag>, keeping the log and the shell status there.
-run() {
-    local out="$WORK/$1"; shift
-    mkdir -p "$out"
-    timeout 300 "$BIN" --datadir "$WORK/datadir" --outputdir "$out" "$@" > "$out/log" 2>&1
-    echo $? > "$out/status"
-}
-
-# run_presets <tag> [option...]: run with the standalone presets loaded.
-run_presets() {
-    local tag="$1"; shift
-    run "$tag" --load-settings "$WORK/machine.json;$WORK/process.json" --load-filaments "$WORK/filament.json" "$@"
-}
-
-# expect_status <tag> <cli code>
-expect_status() {
-    local got; got="$(cat "$WORK/$1/status")"
-    [ "$got" -eq $(( $2 & 255 )) ] || fail "$1: shell status $got, want $(( $2 & 255 )) (code $2)"
-}
-
-# expect_result <tag> <return_code>: a failing run must also carry an error_string.
-expect_result() {
-    "$PY" - "$WORK/$1/result.json" "$2" <<'EOF' || fail "$1: result.json"
-import json, sys
-
-try:
-    with open(sys.argv[1]) as f:
-        result = json.load(f)
-except (OSError, ValueError) as e:
-    sys.exit("cannot read %s: %s" % (sys.argv[1], e))
-want_rc = int(sys.argv[2])
-if result.get("return_code") != want_rc:
-    sys.exit("return_code %r, want %d" % (result.get("return_code"), want_rc))
-if want_rc != 0 and not result.get("error_string"):
-    sys.exit("no error_string")
-EOF
-}
-
-# expect_log <tag> <text>
-expect_log() {
-    grep -qF -- "$2" "$WORK/$1/log" || fail "$1: log does not mention \"$2\""
-}
-
-# expect_gcode <tag>
-expect_gcode() {
-    compgen -G "$WORK/$1/*.gcode" > /dev/null || fail "$1: no G-code was exported"
-}
-
-# rewrite_3mf <in> <out> inherits <json list> | no-plates
-rewrite_3mf() {
-    "$PY" - "$@" <<'EOF'
-import json, re, sys, zipfile
-
-src, dst, mode = sys.argv[1:4]
-with zipfile.ZipFile(src) as zin, zipfile.ZipFile(dst, "w", zipfile.ZIP_DEFLATED) as zout:
-    for info in zin.infolist():
-        data = zin.read(info.filename)
-        if mode == "inherits" and info.filename == "Metadata/project_settings.config":
-            config = json.loads(data)
-            config["inherits_group"] = json.loads(sys.argv[4])
-            data = json.dumps(config, indent=4).encode()
-        elif mode == "no-plates":
-            if re.match(r"Metadata/plate_\d+\.", info.filename):
-                continue
-            if info.filename == "Metadata/model_settings.config":
-                data = re.sub(rb"\s*<plate>.*?</plate>", b"", data, flags=re.S)
-        zout.writestr(info, data)
-EOF
-}
-
-# assemble_list <file> <filaments json>
-assemble_list() {
-    cat > "$1" <<EOF
-{"plates": [{"plate_name": "p", "need_arrange": false,
-             "objects": [{"path": "$WORK/cube.stl", "count": 1, "filaments": $2,
-                          "pos_x": [100], "pos_y": [100]}]}]}
-EOF
-}
-
-echo "== a one-filament project exported by the CLI is the base for the project cases"
-run_presets export --slice 0 --export-3mf project.3mf "$WORK/cube.stl"
-expect_status export $CLI_SUCCESS
-[ -f "$WORK/export/project.3mf" ] || { echo "FAIL: project export failed"; tail -n 40 "$WORK/export/log"; exit 1; }
-
-echo "== an inherits_group of the wrong length still loads"
-for group in '[]' '[""]' '["", "", "", "", ""]'; do
-    tag="inherits_$("$PY" -c 'import json, sys; print(len(json.loads(sys.argv[1])))' "$group")"
-    rewrite_3mf "$WORK/export/project.3mf" "$WORK/$tag.3mf" inherits "$group"
-    run "$tag" --info "$WORK/$tag.3mf"
-    expect_status "$tag" $CLI_SUCCESS
-    expect_log "$tag" "inherits_group"
-done
-
-echo "== --slice 1 --arrange 1 slices a project without plate metadata"
-rewrite_3mf "$WORK/export/project.3mf" "$WORK/no_plates.3mf" no-plates
-run_presets no_plates --slice 1 --arrange 1 "$WORK/no_plates.3mf"
-expect_status no_plates $CLI_SUCCESS
-expect_result no_plates $CLI_SUCCESS
-expect_gcode no_plates
-
-echo "== an assemble list with a valid filament id slices"
-assemble_list "$WORK/assemble_valid.json" '[1]'
-run_presets assemble_valid --slice 0 --load-assemble-list "$WORK/assemble_valid.json"
-expect_status assemble_valid $CLI_SUCCESS
-expect_gcode assemble_valid
-
-echo "== an assemble list with an empty filament list or a negative filament id is rejected"
-for filaments in '[]' '[-1]'; do
-    if [ "$filaments" = '[]' ]; then tag=assemble_empty; else tag=assemble_negative; fi
-    assemble_list "$WORK/$tag.json" "$filaments"
-    run_presets "$tag" --slice 0 --load-assemble-list "$WORK/$tag.json"
-    expect_status "$tag" $CLI_CONFIG_FILE_ERROR
-    expect_result "$tag" $CLI_CONFIG_FILE_ERROR
-done
-
-echo "== --assemble with no input model is rejected"
-for action in "--slice 0" "--export-3mf out.3mf"; do
-    tag="assemble_no_input_${action%% *}"
-    tag="${tag//-/}"
-    # shellcheck disable=SC2086
-    run_presets "$tag" --assemble $action
-    expect_status "$tag" $CLI_INVALID_PARAMS
-    expect_result "$tag" $CLI_INVALID_PARAMS
-    expect_log "$tag" "--assemble"
-done
-
-if [ "$fails" -ne 0 ]; then
-    for log in "$WORK"/*/log; do
-        echo "--- $log"
-        tail -n 40 "$log"
-    done
-    exit 1
-fi
-echo "PASS"

tests/cli/test_cli_project_missing_keys.sh

@@ -1,13 +1,11 @@
 #!/usr/bin/env bash
-# End-to-end check that the CLI loads a project's printer, process and filament settings as the GUI does.
+# 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 with two filaments; one printer key and one process key are removed, one printer
-# key, one process key and two filament keys (one per filament, one per extruder variant) are changed
-# without being listed, one process key and the first filament's density are changed and listed, and it
-# is sliced again: as is, with --uptodate, and with --load-filaments replacing only the second filament.
+# 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 <orca-slicer binary> <python3> <resources/profiles/BBL>
 set -u
@@ -47,7 +45,7 @@ slice() {
 
 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;$PROFILES/filament/Bambu PLA Basic @BBL P1S 0.4 nozzle.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.
@@ -69,47 +67,30 @@ with zipfile.ZipFile(src) as zin, zipfile.ZipFile(dst, "w", zipfile.ZIP_DEFLATED
             for key in ("top_shell_layers", "extruder_clearance_height_to_rod"):
                 expected[key] = config[key]
                 config[key] = str(int(float(config[key])) + 1)
-            for key in ("filament_cost", "filament_max_volumetric_speed"):
-                expected[key] = config[key]
-                config[key] = [str(float(v) + 1) for v in config[key]]
             expected["wall_loops"] = str(int(config["wall_loops"]) + 1)
             config["wall_loops"] = expected["wall_loops"]
-            expected["filament_density"] = [str(float(config["filament_density"][0]) + 1)] + config["filament_density"][1:]
-            config["filament_density"] = [expected["filament_density"][0]] + [str(float(v) + 1) for v in config["filament_density"][1:]]
-            # One entry for the process, one per filament, one for the printer.
             different = config["different_settings_to_system"]
             different[0] = ";".join([k for k in different[0].split(";") if k] + ["wall_loops"])
-            different[1] = ";".join([k for k in different[1].split(";") if k] + ["filament_density"])
             data = json.dumps(config, indent=4)
         zout.writestr(item, data)
 with open(dst + ".expected.json", "w") as f:
     json.dump(expected, f)
 EOF
 
-check() {
-    if ! "$PY" - "$WORK/$1/out.3mf" "$WORK/old.3mf.expected.json" "$1" <<'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: %s is %r, want %r" % (sys.argv[3], key, config.get(key), want) for key, want in expected.items() if config.get(key) != want]
+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
-    then
-        tail -n 40 "$WORK/$1/log"
-        exit 1
-    fi
-}
-
-slice project "$WORK/old.3mf"
-check project
-slice uptodate "$WORK/old.3mf" --uptodate
-check uptodate
-# The replaced second filament takes the system values the refresh would have given it.
-slice partial "$WORK/old.3mf" --load-filaments ";$PROFILES/filament/Bambu PLA Basic @BBL P1S 0.4 nozzle.json"
-check partial
+status=$?
+[ "$status" -eq 0 ] || { tail -n 40 "$WORK/project/log"; exit 1; }
 echo "PASS"

tests/fff_print/test_extrusion_processor.cpp

@@ -7,7 +7,6 @@
 #include <catch2/matchers/catch_matchers_floating_point.hpp>
 #include <catch2/benchmark/catch_benchmark.hpp>
 #include "libslic3r/AABBTreeLines.hpp"
-#include "libslic3r/GCode.hpp"
 #include "libslic3r/GCode/ExtrusionProcessor.hpp"
 #include "libslic3r/GCodeReader.hpp"
 #include "libslic3r/TriangleMesh.hpp"
@@ -16,8 +15,6 @@
 
 #include <algorithm>
 #include <cmath>
-#include <cstdint>
-#include <cstring>
 #include <functional>
 #include "libslic3r/Line.hpp"
 #include "libslic3r/Point.hpp"
@@ -541,187 +538,6 @@ TEST_CASE("A wall is left whole where neither its speed nor its cooling changes"
     REQUIRE(points.size() == 3);
 }
 
-namespace {
-
-// The caged overhang box, sliced, and a layer on its slope.
-struct SlicedCage
-{
-    Print              print;
-    Model              model;
-    const PrintObject *object{nullptr};
-    const Layer       *layer{nullptr};
-
-    explicit SlicedCage(const DynamicPrintConfig &config = caged_overhang_config("classic"))
-    {
-        init_print(std::vector<TriangleMesh>{caged_overhang_mesh()}, print, model, config, nullptr, false);
-        print.process();
-        object = print.objects().front();
-        layer  = object->get_layer(int(std::lround((caged_slope_z_min + caged_slope_z_max) / 2. / caged_layer_height)));
-    }
-};
-
-using Walls = std::vector<std::vector<ProcessedPoint>>;
-
-// Estimates every wall of `layer` against whatever layer `estimator` was last prepared with before it.
-Walls estimate_walls(ExtrusionQualityEstimator &estimator, const PrintObject *object, const Layer &layer)
-{
-    const ConfigOptionPercents         overlaps({90, 75, 50, 25, 13, 0});
-    const ConfigOptionFloatsOrPercents speeds({FloatOrPercent{100, true}, FloatOrPercent{50, true}, FloatOrPercent{30, true},
-                                               FloatOrPercent{20, true}, FloatOrPercent{10, true}, FloatOrPercent{5, true}});
-    Walls walls;
-    estimator.set_current_object(object);
-    for (const LayerRegion *region : layer.regions())
-        for_each_extrusion_path(region->perimeters, [&](const ExtrusionPath &path) {
-            if (is_perimeter(path.role()))
-                walls.push_back(estimator.estimate_extrusion_quality(path, overlaps, speeds, caged_outer_wall_speed, caged_outer_wall_speed,
-                                                                     true, 0.5f));
-        });
-    return walls;
-}
-
-uint32_t float_bits(float value)
-{
-    uint32_t bits;
-    std::memcpy(&bits, &value, sizeof(bits));
-    return bits;
-}
-
-bool same_point(const ProcessedPoint &a, const ProcessedPoint &b)
-{
-    return a.p == b.p && float_bits(a.speed) == float_bits(b.speed) && float_bits(a.overlap) == float_bits(b.overlap);
-}
-
-// Requires the walls to match point for point, bit for bit.
-void check_identical(const Walls &actual, const Walls &expected)
-{
-    REQUIRE(actual.size() == expected.size());
-    for (size_t wall = 0; wall < actual.size(); ++wall) {
-        INFO("wall " << wall);
-        REQUIRE(actual[wall].size() == expected[wall].size());
-        for (size_t i = 0; i < actual[wall].size(); ++i) {
-            const ProcessedPoint &a = actual[wall][i];
-            const ProcessedPoint &e = expected[wall][i];
-            INFO("point " << i << ": speed " << a.speed << " vs " << e.speed << ", overlap " << a.overlap << " vs " << e.overlap);
-            CHECK(a.p == e.p);
-            CHECK(float_bits(a.speed) == float_bits(e.speed));
-            CHECK(float_bits(a.overlap) == float_bits(e.overlap));
-        }
-    }
-}
-
-bool any_difference(const Walls &a, const Walls &b)
-{
-    return !std::equal(a.begin(), a.end(), b.begin(), b.end(), [](const std::vector<ProcessedPoint> &wa, const std::vector<ProcessedPoint> &wb) {
-        return std::equal(wa.begin(), wa.end(), wb.begin(), wb.end(), same_point);
-    });
-}
-
-bool any_slowed(const Walls &walls)
-{
-    return std::any_of(walls.begin(), walls.end(), [](const std::vector<ProcessedPoint> &wall) {
-        return std::any_of(wall.begin(), wall.end(), [](const ProcessedPoint &point) { return point.speed < caged_outer_wall_speed; });
-    });
-}
-
-} // namespace
-
-TEST_CASE("Overhang data computed ahead of the generator gives the same wall speeds", "[ExtrusionProcessor]")
-{
-    const SlicedCage cage;
-    REQUIRE(cage.layer->lower_layer != nullptr);
-
-    ExtrusionQualityEstimator queried;
-    queried.prepare_for_new_layer(cage.object, cage.layer->lower_layer);
-    queried.prepare_for_new_layer(cage.object, cage.layer);
-    const Walls expected = estimate_walls(queried, cage.object, *cage.layer);
-    REQUIRE(any_slowed(expected));
-
-    ExtrusionQualityEstimator precomputed;
-    precomputed.prepare_for_new_layer(cage.object, cage.layer->lower_layer);
-    precomputed.set_precomputed_layers({precompute_overhang_layer(cage.object, *cage.layer)});
-    precomputed.prepare_for_new_layer(cage.object, cage.layer);
-    check_identical(estimate_walls(precomputed, cage.object, *cage.layer), expected);
-}
-
-TEST_CASE("Overhang distances measured against another layer than the previous one are not used", "[ExtrusionProcessor]")
-{
-    const SlicedCage cage;
-    const Layer     *two_below = cage.layer->lower_layer->lower_layer;
-    REQUIRE(two_below != nullptr);
-
-    ExtrusionQualityEstimator queried;
-    queried.prepare_for_new_layer(cage.object, two_below);
-    queried.prepare_for_new_layer(cage.object, cage.layer);
-    const Walls expected = estimate_walls(queried, cage.object, *cage.layer);
-    ExtrusionQualityEstimator one_below;
-    one_below.prepare_for_new_layer(cage.object, cage.layer->lower_layer);
-    one_below.prepare_for_new_layer(cage.object, cage.layer);
-    REQUIRE(any_difference(estimate_walls(one_below, cage.object, *cage.layer), expected));
-
-    ExtrusionQualityEstimator precomputed;
-    precomputed.prepare_for_new_layer(cage.object, two_below);
-    precomputed.set_precomputed_layers({precompute_overhang_layer(cage.object, *cage.layer)});
-    precomputed.prepare_for_new_layer(cage.object, cage.layer);
-    check_identical(estimate_walls(precomputed, cage.object, *cage.layer), expected);
-}
-
-TEST_CASE("Overhang data computed for another layer is not used", "[ExtrusionProcessor]")
-{
-    const SlicedCage cage;
-    const Layer     *one_below = cage.layer->lower_layer;
-    REQUIRE(one_below != nullptr);
-    REQUIRE(one_below->lower_layer != nullptr);
-
-    ExtrusionQualityEstimator queried;
-    queried.prepare_for_new_layer(cage.object, one_below);
-    queried.prepare_for_new_layer(cage.object, cage.layer);
-    const Walls expected = estimate_walls(queried, cage.object, *cage.layer);
-    ExtrusionQualityEstimator two_below;
-    two_below.prepare_for_new_layer(cage.object, one_below->lower_layer);
-    two_below.prepare_for_new_layer(cage.object, cage.layer);
-    REQUIRE(any_difference(estimate_walls(two_below, cage.object, *cage.layer), expected));
-
-    ExtrusionQualityEstimator precomputed;
-    precomputed.set_precomputed_layers({precompute_overhang_layer(cage.object, *one_below)});
-    precomputed.prepare_for_new_layer(cage.object, one_below);
-    precomputed.prepare_for_new_layer(cage.object, cage.layer);
-    check_identical(estimate_walls(precomputed, cage.object, *cage.layer), expected);
-}
-
-TEST_CASE("Precomputed overhang data has the curled-line tree exactly when a region slows down for curled perimeters", "[ExtrusionProcessor]")
-{
-    const bool         slowdown = GENERATE(false, true);
-    DynamicPrintConfig config   = caged_overhang_config("classic");
-    config.set_deserialize_strict("slowdown_for_curled_perimeters", slowdown ? "1" : "0");
-    const SlicedCage cage(config);
-
-    GCode::LayerToPrint layer;
-    layer.object_layer    = cage.layer;
-    layer.original_object = cage.object;
-    const std::vector<PrecomputedOverhangLayer> precomputed = precompute_overhang_layers({layer}, false);
-    REQUIRE(precomputed.size() == 1);
-    CHECK((precomputed.front().lower_curled_lines != nullptr) == slowdown);
-}
-
-TEST_CASE("Caged external overhangs are slowed when printed by object or through the pressure equalizer", "[ExtrusionProcessor]")
-{
-    const auto [key, value] = GENERATE(table<const char *, const char *>({
-        {"print_sequence", "by object"},
-        {"max_volumetric_extrusion_rate_slope", "10"},
-    }));
-    INFO(key << " = " << value);
-    DynamicPrintConfig config = caged_overhang_config("classic");
-    config.set_deserialize_strict(key, value);
-    Print print;
-    Model model;
-    init_print(std::vector<TriangleMesh>{caged_overhang_mesh()}, print, model, config, nullptr, false);
-
-    const std::vector<double> feed_rates = caged_slope_feed_rates(gcode(print));
-    info_feed_rates("caged slope", feed_rates);
-    REQUIRE_FALSE(feed_rates.empty());
-    REQUIRE(*std::max_element(feed_rates.begin(), feed_rates.end()) < caged_slow_speed * MM_PER_MIN);
-}
-
 TEST_CASE("Benchmark caged overhang interior sampling", "[ExtrusionProcessor][!benchmark]"){
     const char* wall_generator = GENERATE("classic", "arachne");
 

tests/fff_print/test_gcodeprocessor.cpp

@@ -4,12 +4,7 @@
 #include <catch2/generators/catch_generators.hpp>
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/GCode/GCodeProcessor.hpp"
-#include "libslic3r/Utils.hpp"
 
-#include "test_utils.hpp"
-
-#include <fstream>
-#include <sstream>
 #include <string>
 #include <vector>
 
@@ -84,90 +79,3 @@ TEST_CASE("Reserved keyword detection reports every offending line", "[GCodeProc
         CHECK(tags.empty());
     }
 }
-
-namespace {
-
-// Closed outer-wall squares, each after a fast travel and before an inner-wall move, so the processor
-// records seams and inserts actual speed moves. virtual_moves adds a VG1 move after each square.
-void process_squares(int squares, GCodeProcessorResult &result, bool virtual_moves = false)
-{
-    std::ostringstream gcode;
-    gcode << "M83\nG90\n";
-    for (int i = 0; i < squares; ++i) {
-        gcode << "G1 X10 Y10 Z" << 0.2 * (i + 1) << " F12000\n"
-              << "; FEATURE: Outer wall\n"
-              << "G1 X50 Y10 E2 F3000\nG1 X50 Y50 E2\nG1 X10 Y50 E2\nG1 X10 Y10 E2\n"
-              << "; FEATURE: Inner wall\n"
-              << "G1 X12 Y12 E0.1\nG1 X30 Y12 E1\n";
-        if (virtual_moves)
-            gcode << "VG1 X20 Y30 F12000\n";
-    }
-    FullPrintConfig config;
-    config.gcode_flavor.value = gcfMarlinFirmware;
-    // s_IsBBLPrinter selects the "; FEATURE: " role tags this G-code uses.
-    const bool       was_bbl_printer = GCodeProcessor::s_IsBBLPrinter;
-    const ScopeGuard restore_bbl_printer([was_bbl_printer] { GCodeProcessor::s_IsBBLPrinter = was_bbl_printer; });
-    GCodeProcessor::s_IsBBLPrinter = true;
-    ScopedTemporaryFile temp(".gcode");
-    std::ofstream(temp.string()) << gcode.str();
-    GCodeProcessor processor;
-    processor.apply_config(config);
-    processor.process_file(temp.string());
-    result = std::move(processor.extract_result());
-}
-
-bool is_block_move(const GCodeProcessorResult::MoveVertex &move)
-{
-    return !move.internal_only && (move.type == EMoveType::Extrude || move.type == EMoveType::Travel);
-}
-
-} // namespace
-
-TEST_CASE("Actual speed moves are inserted on their block's segment just before its move", "[GCodeProcessor]")
-{
-    // 60 squares take several planner passes, which remap the blocks kept between passes.
-    const int                  squares       = GENERATE(10, 60);
-    const bool                 virtual_moves = GENERATE(false, true);
-    GCodeProcessorResult       result;
-    process_squares(squares, result, virtual_moves);
-    const auto                &moves   = result.moves;
-    constexpr size_t           normal  = size_t(PrintEstimatedStatistics::ETimeMode::Normal);
-
-    size_t inserted = 0;
-    for (size_t i = 1; i < moves.size(); ++i) {
-        if (!moves[i].internal_only)
-            continue;
-        ++inserted;
-        // Inserted moves have zero time, but a VG1 block's time is written to whatever move its move_id names.
-        if (!virtual_moves)
-            CHECK(moves[i].time[normal] == 0.f);
-        size_t block = i + 1;
-        while (block < moves.size() && moves[block].internal_only)
-            ++block;
-        size_t previous = i - 1;
-        while (previous > 0 && moves[previous].internal_only)
-            --previous;
-        REQUIRE(block < moves.size());
-        CHECK(moves[block].gcode_id == moves[i].gcode_id);
-        const Vec3f segment = moves[block].position - moves[previous].position;
-        const Vec3f offset  = moves[i].position - moves[previous].position;
-        CHECK(segment.cross(offset).norm() / segment.norm() < 1e-3f);
-    }
-    REQUIRE(inserted > 0);
-}
-
-TEST_CASE("A seam takes the actual speed of the move it follows", "[GCodeProcessor]")
-{
-    GCodeProcessorResult result;
-    // 10 squares fit in one planner pass, so the seam's move and the block after it are timed together.
-    process_squares(10, result);
-    const auto                &moves  = result.moves;
-
-    size_t seams = 0;
-    for (size_t i = 1; i < moves.size(); ++i)
-        if (moves[i].type == EMoveType::Seam && is_block_move(moves[i - 1])) {
-            ++seams;
-            CHECK_THAT(moves[i].actual_feedrate, Catch::Matchers::WithinAbs(moves[i - 1].actual_feedrate, 1e-4));
-        }
-    REQUIRE(seams > 0);
-}

tests/fff_print/test_multifilament.cpp

@@ -22,7 +22,6 @@
 #include "libslic3r/Print.hpp"
 #include <limits>
 #include <optional>
-#include <regex>
 #include <set>
 #include <sstream>
 #include <string>
@@ -843,47 +842,6 @@ TEST_CASE("Each filament sets the pressure advance of its extruder variant", "[M
     }
 }
 
-// A two-extruder printer, Standard nozzle on extruder 1 and High Flow on extruder 2, whose per-variant arrays
-// hold filament 1 Standard, filament 1 High Flow, filament 2 Standard and filament 2 High Flow.
-static DynamicPrintConfig two_extruder_pressure_advance_config(const std::string &filament_map, const std::string &adaptive_pressure_advance,
-                                                               int wall_filament, int infill_filament)
-{
-    DynamicPrintConfig config = multifilament_config(2, {
-        { "gcode_flavor",                   "klipper" },
-        { "single_extruder_multi_material", 0 },
-        { "nozzle_diameter",                "0.4,0.4" },
-        { "extruder_printable_height",      "0,0" },
-        { "printer_extruder_id",            "1,2" },
-        { "printer_extruder_variant",       "Direct Drive Standard;Direct Drive High Flow" },
-        { "extruder_variant_list",          "Direct Drive Standard;Direct Drive High Flow" },
-        { "filament_map",                   filament_map },
-        { "filament_extruder_variant",      "Direct Drive Standard;Direct Drive High Flow;Direct Drive Standard;Direct Drive High Flow" },
-        { "filament_self_index",            "1,1,2,2" },
-        { "enable_pressure_advance",        "1,1,1,1" },
-        { "pressure_advance",               "0.021,0.037,0.043,0.049" },
-        { "adaptive_pressure_advance",      adaptive_pressure_advance },
-        { "sparse_infill_filament_id",      infill_filament },
-        { "internal_solid_filament_id",     infill_filament },
-        { "top_surface_filament_id",        infill_filament },
-        { "bottom_surface_filament_id",     infill_filament },
-        { "outer_wall_filament_id",         wall_filament },
-        { "inner_wall_filament_id",         wall_filament },
-        { "enable_prime_tower",             0 },
-        { "skirt_loops",                    0 },
-        { "brim_type",                      "no_brim" },
-        // custom G-code indexes the per-filament arrays by filament
-        { "machine_start_gcode",            "; start pressure advance {pressure_advance[initial_extruder]}" },
-    });
-    config.option<ConfigOptionStrings>("adaptive_pressure_advance_model")->values = {
-        constant_pressure_advance_model("0.012"), constant_pressure_advance_model("0.034"),
-        constant_pressure_advance_model("0.056"), constant_pressure_advance_model("0.078") };
-    config.option<ConfigOptionEnumsGeneric>("extruder_type", true)->values = { etDirectDrive, etDirectDrive };
-    config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type", true)->values = { nvtStandard, nvtHighFlow };
-    // print each filament on the extruder filament_map gives it
-    config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode", true)->value = fmmManual;
-    return config;
-}
-
 // On a printer with two extruders, a filament takes the pressure advance of the variant of the extruder
 // it is mapped to, whichever filament and extruder that is.
 TEST_CASE("Each filament sets the pressure advance of its extruder variant on a two-extruder printer", "[MultiFilament]")
@@ -899,8 +857,42 @@ TEST_CASE("Each filament sets the pressure advance of its extruder variant on a
         // the other filament goes on the other extruder
         const std::string filament_map = filament == 1 ? std::to_string(extruder) + "," + std::to_string(3 - extruder) :
                                                          std::to_string(3 - extruder) + "," + std::to_string(extruder);
-        const std::string gcode = slice({ cube(20) },
-            two_extruder_pressure_advance_config(filament_map, adaptive ? "1,1,1,1" : "0,0,0,0", filament, filament));
+        DynamicPrintConfig config = multifilament_config(2, {
+            { "gcode_flavor",                   "klipper" },
+            { "single_extruder_multi_material", 0 },
+            { "nozzle_diameter",                "0.4,0.4" },
+            { "extruder_printable_height",      "0,0" },
+            // extruder 1 has a Standard nozzle, extruder 2 a High Flow one
+            { "printer_extruder_id",            "1,2" },
+            { "printer_extruder_variant",       "Direct Drive Standard;Direct Drive High Flow" },
+            { "extruder_variant_list",          "Direct Drive Standard;Direct Drive High Flow" },
+            { "filament_map",                   filament_map },
+            // both filaments define Standard and High Flow
+            { "filament_extruder_variant",      "Direct Drive Standard;Direct Drive High Flow;Direct Drive Standard;Direct Drive High Flow" },
+            { "filament_self_index",            "1,1,2,2" },
+            { "enable_pressure_advance",        "1,1,1,1" },
+            { "pressure_advance",               "0.021,0.037,0.043,0.049" },
+            { "adaptive_pressure_advance",      adaptive ? "1,1,1,1" : "0,0,0,0" },
+            { "sparse_infill_filament_id",      filament },
+            { "internal_solid_filament_id",     filament },
+            { "top_surface_filament_id",        filament },
+            { "bottom_surface_filament_id",     filament },
+            { "outer_wall_filament_id",         filament },
+            { "inner_wall_filament_id",         filament },
+            { "enable_prime_tower",             0 },
+            { "skirt_loops",                    0 },
+            { "brim_type",                      "no_brim" },
+            // custom G-code indexes the per-filament arrays by filament
+            { "machine_start_gcode",            "; start pressure advance {pressure_advance[initial_extruder]}" },
+        });
+        config.option<ConfigOptionStrings>("adaptive_pressure_advance_model")->values = {
+            constant_pressure_advance_model("0.012"), constant_pressure_advance_model("0.034"),
+            constant_pressure_advance_model("0.056"), constant_pressure_advance_model("0.078") };
+        config.option<ConfigOptionEnumsGeneric>("extruder_type", true)->values = { etDirectDrive, etDirectDrive };
+        config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type", true)->values = { nvtStandard, nvtHighFlow };
+        // keep the mapping above rather than grouping the filaments automatically
+        config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode", true)->value = fmmManual;
+        const std::string gcode = slice({ cube(20) }, config);
 
         std::set<std::string> expected{ pressure_advance };
         if (adaptive)
@@ -910,82 +902,6 @@ TEST_CASE("Each filament sets the pressure advance of its extruder variant on a
     }
 }
 
-// Filament 1 prints the walls on extruder 1 (variant index 0), filament 2 the infill on extruder 2 (variant index 3).
-TEST_CASE("Adaptive pressure advance on one extruder leaves the other extruder's pressure advance alone", "[MultiFilament]")
-{
-    auto [adaptive, expected] = GENERATE(table<std::string, std::set<std::string>>({
-        { "1,0,0,0", { "0.021", "0.049", "0.012" } },
-        { "0,0,0,1", { "0.021", "0.049", "0.078" } },
-    }));
-    DYNAMIC_SECTION("adaptive " << adaptive) {
-        const std::string gcode = slice({ cube(20) }, two_extruder_pressure_advance_config("1,2", adaptive, 1, 2));
-        CHECK(pressure_advance_values(gcode) == expected);
-    }
-}
-
-// The pressure advance values a Klipper G-code sets while `tool` is active, in order, without repeating the value already set.
-static std::vector<std::string> pressure_advance_sequence(const std::string &gcode, int tool)
-{
-    const std::string token = "SET_PRESSURE_ADVANCE ADVANCE=";
-    std::vector<std::string> values;
-    int current_tool = 0;
-    std::istringstream stream(gcode);
-    for (std::string line; std::getline(stream, line);) {
-        if (line.size() > 1 && line[0] == 'T' && std::isdigit((unsigned char) line[1]))
-            current_tool = std::stoi(line.substr(1));
-        else if (current_tool == tool && line.rfind(token, 0) == 0) {
-            std::string value = line.substr(token.size(), line.find(';') - token.size());
-            if (values.empty() || values.back() != value)
-                values.push_back(std::move(value));
-        }
-    }
-    return values;
-}
-
-TEST_CASE("Adaptive pressure advance predicts the same values after layers only a non-adaptive extruder prints", "[MultiFilament]")
-{
-    auto slice_with = [](const std::string &adaptive) {
-        DynamicPrintConfig config = two_extruder_pressure_advance_config("1,2", adaptive, 1, 1);
-        config.set_deserialize_strict({
-            { "print_sequence",                "by object" },
-            // extruder 2 moves at one speed on its first layer, so no G1 F follows its first PA_CHANGE tag
-            { "filament_max_volumetric_speed", "100" },
-            { "slow_down_for_layer_cooling",   "0" },
-            { "travel_speed",                  "120,40" },
-            { "retraction_speed",              "30,40" },
-            { "deretraction_speed",            "30,40" },
-            { "initial_layer_speed",           "30,40" },
-            { "initial_layer_infill_speed",    "60,40" },
-        });
-        auto &models = config.option<ConfigOptionStrings>("adaptive_pressure_advance_model")->values;
-        // with adaptive pressure advance on, filament 1 gets PA_CHANGE tags on every layer but keeps its pressure advance
-        models[0] = constant_pressure_advance_model("0.021");
-        // a prediction that rises with flow, so it depends on the print speed
-        models[3] = "0.01,1,1000\n0.09,40,1000\n0.01,1,100000\n0.09,40,100000";
-        return slice_with_object_overrides({ cube(20), cube(20) }, config,
-            { {}, { { "outer_wall_filament_id", 2 }, { "inner_wall_filament_id", 2 }, { "sparse_infill_filament_id", 2 },
-                    { "internal_solid_filament_id", 2 }, { "top_surface_filament_id", 2 }, { "bottom_surface_filament_id", 2 } } });
-    };
-    const std::vector<std::string> expected = pressure_advance_sequence(slice_with("1,0,0,1"), 1);
-    REQUIRE(expected.size() > 2);
-    CHECK(pressure_advance_sequence(slice_with("0,0,0,1"), 1) == expected);
-}
-
-TEST_CASE("Adaptive pressure advance on an unused extruder variant leaves the G-code unchanged", "[MultiFilament]")
-{
-    const std::string adaptive = GENERATE("0,1,0,0", "0,0,1,0");
-    DYNAMIC_SECTION("adaptive " << adaptive) {
-        // the time and object ids differ between any two slices, and the config block lists the setting itself
-        auto masked = [](const std::string &gcode) {
-            return std::regex_replace(gcode.substr(0, gcode.find("; CONFIG_BLOCK_START")), std::regex("; generated by .*| id:\\d+"), "");
-        };
-        const std::string reference = masked(slice({ cube(20) }, two_extruder_pressure_advance_config("1,2", "0,0,0,0", 1, 2)));
-        const std::string gcode     = masked(slice({ cube(20) }, two_extruder_pressure_advance_config("1,2", adaptive, 1, 2)));
-        REQUIRE(reference.find("SET_PRESSURE_ADVANCE") != std::string::npos);
-        CHECK(gcode == reference);
-    }
-}
-
 // The speeds, in percent, a G-code turns a fan on at: the part cooling fan for `M106 S`, the auxiliary
 // fan for `M106 P2 S`.
 static std::set<int> fan_speeds(const std::string &gcode, const std::string &command)

tests/libslic3r/CMakeLists.txt

@@ -9,7 +9,6 @@ add_executable(${_TEST_NAME}_tests
     test_appconfig.cpp
     test_arachne_walls.cpp
     test_arrange.cpp
-    test_assemble_list.cpp
     test_bambu_networking.cpp
     test_buildvolume.cpp
     test_calib.cpp

tests/libslic3r/test_assemble_list.cpp

@@ -1,266 +0,0 @@
-#include <catch2/catch_all.hpp>
-
-#include "libslic3r/Format/AssembleList.hpp"
-
-#include "test_utils.hpp"
-
-#include <boost/nowide/fstream.hpp>
-#include <nlohmann/json.hpp>
-
-#include <string>
-#include <vector>
-
-using namespace Slic3r;
-using Catch::Matchers::WithinAbs;
-using nlohmann::json;
-
-static constexpr int max_plates = 36;
-
-static AssembleListResult load_text(const std::string &text, std::vector<assemble_plate_info_t> &plates)
-{
-    ScopedTemporaryFile file(".json");
-    {
-        boost::nowide::ofstream out(file.string());
-        out << text;
-    }
-    return load_assemble_plate_list(file.string(), plates, max_plates);
-}
-
-static AssembleListResult load_json(const json &root)
-{
-    std::vector<assemble_plate_info_t> plates;
-    return load_text(root.dump(), plates);
-}
-
-// One plate with one object of three clones, which every optional field accepts.
-static json valid_list()
-{
-    return json::parse(R"({
-        "plates": [{
-            "plate_name": "plate",
-            "need_arrange": false,
-            "objects": [{
-                "path": "cube.stl",
-                "count": 3,
-                "filaments": [1],
-                "height_ranges": [{ "min_z": 0, "max_z": 5, "range_params": { "layer_height": "0.1" } }]
-            }],
-            "assembled_params": [{
-                "assemble_index": 1,
-                "height_ranges": [{ "min_z": 0, "max_z": 5, "range_params": { "layer_height": "0.1" } }]
-            }]
-        }]
-    })");
-}
-
-TEST_CASE("A valid assemble list parses into its plates and objects", "[AssembleList]")
-{
-    const std::string text = R"({
-        "plates": [
-            {
-                "plate_name": "first",
-                "need_arrange": true,
-                "plate_params": { "curr_bed_type": "Textured PEI Plate" },
-                "objects": [
-                    {
-                        "path": "a.stl",
-                        "count": 2,
-                        "filaments": [1, 3],
-                        "assemble_index": [1],
-                        "pos_x": [10.5, 20.5],
-                        "pos_y": [30],
-                        "pos_z": [0, 1],
-                        "print_params": { "sparse_infill_density": "30%" },
-                        "height_ranges": [{ "min_z": 1.5, "max_z": 4, "range_params": { "layer_height": "0.12" } }]
-                    },
-                    { "path": "b.stl", "count": 1, "filaments": [0] }
-                ],
-                "assembled_params": [{ "assemble_index": 1, "print_params": { "wall_loops": "4" } }]
-            },
-            {
-                "plate_name": "second",
-                "need_arrange": false,
-                "objects": [{ "path": "c.stl", "count": 1, "filaments": [2] }]
-            }
-        ]
-    })";
-    std::vector<assemble_plate_info_t> plates;
-    REQUIRE(load_text(text, plates) == AssembleListResult::Success);
-    REQUIRE(plates.size() == 2);
-
-    const assemble_plate_info_t &first = plates[0];
-    CHECK(first.plate_name == "first");
-    CHECK(first.need_arrange);
-    CHECK(first.plate_params.at("curr_bed_type") == "Textured PEI Plate");
-    REQUIRE(first.assemble_obj_list.size() == 2);
-
-    const assemble_object_info_t &a = first.assemble_obj_list[0];
-    CHECK(a.path == "a.stl");
-    CHECK(a.count == 2);
-    CHECK(a.filaments == std::vector<int>{1, 3});
-    CHECK(a.assemble_index == std::vector<int>{1});
-    REQUIRE(a.pos_x.size() == 2);
-    CHECK_THAT(a.pos_x[0], WithinAbs(10.5, 1e-6));
-    CHECK_THAT(a.pos_x[1], WithinAbs(20.5, 1e-6));
-    REQUIRE(a.pos_y.size() == 1);
-    CHECK_THAT(a.pos_y[0], WithinAbs(30., 1e-6));
-    REQUIRE(a.pos_z.size() == 2);
-    CHECK_THAT(a.pos_z[1], WithinAbs(1., 1e-6));
-    CHECK(a.print_params.at("sparse_infill_density") == "30%");
-    REQUIRE(a.height_ranges.size() == 1);
-    CHECK_THAT(a.height_ranges[0].min_z, WithinAbs(1.5, 1e-6));
-    CHECK_THAT(a.height_ranges[0].max_z, WithinAbs(4., 1e-6));
-    CHECK(a.height_ranges[0].range_params.at("layer_height") == "0.12");
-
-    const assemble_object_info_t &b = first.assemble_obj_list[1];
-    CHECK(b.path == "b.stl");
-    CHECK(b.count == 1);
-    CHECK(b.filaments == std::vector<int>{0});
-    CHECK(b.pos_x.empty());
-    CHECK(b.assemble_index.empty());
-
-    REQUIRE(first.assembled_param_list.count(1) == 1);
-    CHECK(first.assembled_param_list.at(1).print_params.at("wall_loops") == "4");
-
-    const assemble_plate_info_t &second = plates[1];
-    CHECK(second.plate_name == "second");
-    CHECK_FALSE(second.need_arrange);
-    REQUIRE(second.assemble_obj_list.size() == 1);
-    CHECK(second.assemble_obj_list[0].path == "c.stl");
-    CHECK(second.assemble_obj_list[0].filaments == std::vector<int>{2});
-}
-
-TEST_CASE("The unmodified fixture used by the rule tests is accepted", "[AssembleList]")
-{
-    CHECK(load_json(valid_list()) == AssembleListResult::Success);
-}
-
-TEST_CASE("An object with an empty filament list is rejected", "[AssembleList]")
-{
-    json root = valid_list();
-    root["plates"][0]["objects"][0]["filaments"] = json::array();
-    CHECK(load_json(root) == AssembleListResult::ConfigError);
-}
-
-TEST_CASE("An object with a negative filament id is rejected", "[AssembleList]")
-{
-    json root = valid_list();
-    root["plates"][0]["objects"][0]["filaments"] = GENERATE(json::array({-1}), json::array({1, -2, 1}));
-    CAPTURE(root["plates"][0]["objects"][0]["filaments"].dump());
-    CHECK(load_json(root) == AssembleListResult::ConfigError);
-}
-
-TEST_CASE("Filament id 0 is accepted", "[AssembleList]")
-{
-    json root = valid_list();
-    root["plates"][0]["objects"][0]["filaments"] = GENERATE(json::array({0}), json::array({0, 1, 0}));
-    CAPTURE(root["plates"][0]["objects"][0]["filaments"].dump());
-    CHECK(load_json(root) == AssembleListResult::Success);
-}
-
-TEST_CASE("Per-clone lists need one entry or one per clone", "[AssembleList]")
-{
-    // The fixture object has 3 clones.
-    const std::string key  = GENERATE("filaments", "assemble_index", "pos_x", "pos_y", "pos_z");
-    const size_t      size = GENERATE(1, 2, 3, 4);
-    CAPTURE(key, size);
-
-    json root = valid_list();
-    root["plates"][0]["objects"][0][key] = json(std::vector<int>(size, 1));
-    const AssembleListResult expected = (size == 1 || size == 3) ? AssembleListResult::Success : AssembleListResult::ConfigError;
-    CHECK(load_json(root) == expected);
-}
-
-TEST_CASE("An empty optional per-clone list is accepted", "[AssembleList]")
-{
-    const std::string key = GENERATE("assemble_index", "pos_x", "pos_y", "pos_z");
-    CAPTURE(key);
-
-    json root = valid_list();
-    root["plates"][0]["objects"][0][key] = json::array();
-    CHECK(load_json(root) == AssembleListResult::Success);
-}
-
-// Fields read through a const reference (plate_name, need_arrange, objects, path, count) are
-// looked up without a presence check, so only their wrong-type case is covered here.
-TEST_CASE("A missing required field is rejected", "[AssembleList]")
-{
-    const std::string pointer = GENERATE("/plates",
-                                         "/plates/0/objects/0/filaments",
-                                         "/plates/0/objects/0/height_ranges/0/min_z",
-                                         "/plates/0/objects/0/height_ranges/0/max_z",
-                                         "/plates/0/objects/0/height_ranges/0/range_params",
-                                         "/plates/0/assembled_params/0/assemble_index",
-                                         "/plates/0/assembled_params/0/height_ranges/0/min_z",
-                                         "/plates/0/assembled_params/0/height_ranges/0/max_z",
-                                         "/plates/0/assembled_params/0/height_ranges/0/range_params");
-    CAPTURE(pointer);
-
-    json root = valid_list();
-    const json::json_pointer ptr(pointer);
-    root[ptr.parent_pointer()].erase(ptr.back());
-    CHECK(load_json(root) == AssembleListResult::ConfigError);
-}
-
-TEST_CASE("A field of the wrong type is rejected", "[AssembleList]")
-{
-    const std::string pointer = GENERATE("/plates/0/plate_name",
-                                         "/plates/0/need_arrange",
-                                         "/plates/0/objects/0/path",
-                                         "/plates/0/objects/0/count",
-                                         "/plates/0/objects/0/filaments",
-                                         "/plates/0/objects/0/pos_x");
-    CAPTURE(pointer);
-
-    json root = valid_list();
-    root[json::json_pointer(pointer)] = json::object();
-    CHECK(load_json(root) == AssembleListResult::ConfigError);
-}
-
-TEST_CASE("A plate or clone count out of range is rejected", "[AssembleList]")
-{
-    SECTION("no plates")
-    {
-        json root = valid_list();
-        root["plates"] = json::array();
-        CHECK(load_json(root) == AssembleListResult::ConfigError);
-    }
-    SECTION("more plates than the limit")
-    {
-        json root = valid_list();
-        const json plate = root["plates"][0];
-        for (int i = 1; i < max_plates; ++i)
-            root["plates"].push_back(plate);
-        CHECK(load_json(root) == AssembleListResult::Success);
-        root["plates"].push_back(plate);
-        CHECK(load_json(root) == AssembleListResult::ConfigError);
-    }
-    SECTION("a plate with no objects")
-    {
-        json root = valid_list();
-        root["plates"][0]["objects"] = json::array();
-        CHECK(load_json(root) == AssembleListResult::ConfigError);
-    }
-    SECTION("a clone count below 1")
-    {
-        json root = valid_list();
-        root["plates"][0]["objects"][0]["count"] = GENERATE(0, -1);
-        CAPTURE(root["plates"][0]["objects"][0]["count"].dump());
-        CHECK(load_json(root) == AssembleListResult::ConfigError);
-    }
-}
-
-TEST_CASE("Malformed JSON is rejected", "[AssembleList]")
-{
-    const std::string text = GENERATE(std::string(), std::string("{\"plates\": ["), std::string("not json"));
-    CAPTURE(text);
-    std::vector<assemble_plate_info_t> plates;
-    CHECK(load_text(text, plates) == AssembleListResult::ConfigError);
-}
-
-TEST_CASE("A missing file is reported as not found", "[AssembleList]")
-{
-    ScopedTemporaryFile        file(".json");
-    std::vector<assemble_plate_info_t> plates;
-    CHECK(load_assemble_plate_list(file.string(), plates, max_plates) == AssembleListResult::FileNotFound);
-}

tests/libslic3r/test_locales_utils.cpp

@@ -69,22 +69,3 @@ TEST_CASE("a setter nested in another sets C again when the locale changed betwe
         CHECK_FALSE(is_decimal_separator_point());
     }
 }
-
-TEST_CASE("atof_decimal_point parses what atof parses in the C locale", "[LocalesUtils]")
-{
-    const auto [text, value] = GENERATE(table<const char*, double>({
-        { "5", 5. },
-        { "  12.5", 12.5 },
-        { "\t+3", 3. },
-        { "\r\n7", 7. },
-        { "-1.25", -1.25 },
-        { "1e2", 100. },
-        { ".5", 0.5 },
-        { "12.5;comment", 12.5 },
-        { "+-5", 0. },
-        { "", 0. },
-        { "abc", 0. },
-    }));
-    INFO(text);
-    CHECK_THAT(atof_decimal_point(text), Catch::Matchers::WithinAbs(value, 1e-12));
-}

tests/libslic3r/test_utils.cpp

@@ -509,15 +509,3 @@ TEST_CASE("is_safe_to_open_file_name rejects programs and anything it does not k
     INFO(unsafe);
     CHECK_FALSE(is_safe_to_open_file_name(unsafe));
 }
-
-TEST_CASE("ascii_iequals compares ASCII letters regardless of case", "[Utils]") {
-    CHECK(ascii_iequals("set_velocity_limit", "SET_VELOCITY_LIMIT"));
-    CHECK(ascii_iequals("G28", "g28"));
-    CHECK(ascii_iequals("", ""));
-    CHECK_FALSE(ascii_iequals("G28", "G29"));
-    CHECK_FALSE(ascii_iequals("G2", "G28"));
-    CHECK_FALSE(ascii_iequals("G28", "G2"));
-    // Non-letters 0x20 apart are not equal.
-    CHECK_FALSE(ascii_iequals("[", "{"));
-    CHECK_FALSE(ascii_iequals("@", "`"));
-}