Make the connected-net layout affordable on a dense patch

Laying a patch out as a connected net cost ~175 ms on a 42k-triangle patch,
against ~21 ms for the unwrap it works from, and the gizmo asks for it on every
preview, overlay and bake. Measured on a real project the grid behind it ran
~19 million triangle-pair tests per net, nearly all of them misses: a cell
holds every triangle whose box touches it, and a candidate really meets a
couple of them.

Keep a bounding box with each stored triangle and answer those misses with four
comparisons instead of a full intersection. The net drops to ~53 ms with
identical output - the seam metrics on the test project did not move by one.

Two further attempts were measured and dropped, and are recorded in the comment
so they are not tried again: a free-space pre-check per chart came out slower,
because a folded chart lands against the net by construction and the cells
under it are occupied anyway, and splitting the boxes into their own array for
locality lost more to growing two vectors per bucket than it gained.

Also pick a pair's fold line from the longest boundary they share rather than
whichever edge came first, and grow the net strongest-adjacency-first rather
than breadth-first by area. Only the fold a chart is reached by comes out
matching, so a chart claimed across a short boundary leaves the long one it
shared with its true neighbour torn.

texture_unwrap_dump reports an unwrap from a saved project - charts, their
topology, folded triangles, where the texture is discontinuous and how long
those seams are. All of the above was found with it, and it is what keeps a
claim about this code honest; reading the 3D view and guessing had produced
three wrong diagnoses in a row.

.clang-tidy

@@ -1,62 +0,0 @@
-# clang-tidy configuration. Only missing includes are reported for now: a file
-# should include the header for every symbol it uses, not rely on the
-# precompiled header or another header's includes. Run with --fix to add them.
-Checks: '-*,misc-include-cleaner'
-CheckOptions:
-  # Missing includes only. Builds without the precompiled header break on these.
-  misc-include-cleaner.UnusedIncludes: false
-  # Headers that declare a symbol but are not the one to include: per-platform
-  # implementations of wxWidgets and Boost.Thread (a Linux run would suggest the
-  # GTK or pthread one), library internals and forward declarations (MSVC's STL
-  # __msvc_* and the Windows UCRT's corecrt_* included), CPython's headers behind
-  # Python.h (python3.x/ on Linux and macOS, libpython/include/ on Windows),
-  # curl's behind curl.h, oneTBB's behind tbb/, and
-  # admesh's stl.h, which the include path also exposes without its directory.
-  # Clipper's own clipper.hpp is only included through libslic3r/clipper.hpp or
-  # clipper_z.hpp, which configure it first, and Boost.Polygon's headers only
-  # work through boost/polygon/polygon.hpp or voronoi.hpp. minilzo's config
-  # headers are internal to minilzo.h.
-  # FFmpeg's C headers are left alone because they are only included inside
-  # extern "C", which an inserted include would miss. OS-specific headers (GLib,
-  # GTK, D-Bus, POSIX, the Windows SDK) are only used inside platform #if blocks,
-  # and an include added at the top of the file would break the other platforms'
-  # builds. A symbol these provide is not reported missing.
-  # Write every / as [/\\] so the patterns also match Windows paths.
-  # No comments inside the block below, because a # there silently becomes part of a pattern.
-  misc-include-cleaner.IgnoreHeaders: >-
-    wx[/\\](gtk|gtk1|msw|osx|unix|x11|motif|univ|qt|dfb|generic|private)[/\\].*;
-    .*[/\\]detail[/\\].*;
-    .*[/\\]impl[/\\].*;
-    .*_fwd\.hpp;
-    python3\.[0-9]+[/\\].*;
-    libpython[/\\]include[/\\].*;
-    bits[/\\].*;
-    corecrt_.*\.h;
-    __msvc_.*\.hpp;
-    boost[/\\]multiprecision[/\\]fwd\.hpp;
-    imconfig\.h;
-    expat_external\.h;
-    admesh[/\\]stl\.h;
-    boost[/\\]thread[/\\](pthread|win32)[/\\].*;
-    boost[/\\]regex[/\\]v[0-9]+[/\\].*;
-    curl[/\\](easy|multi|system|urlapi|header|options|websockets|mprintf)\.h;
-    oneapi[/\\]tbb[/\\].*;
-    opencv2[/\\]core[/\\]hal[/\\].*;
-    openssl[/\\]ossl_typ\.h;
-    libav[a-z]+[/\\].*;
-    libsw[a-z]+[/\\].*;
-    glib-2\.0[/\\].*;
-    gtk-3\.0[/\\].*;
-    dbus-1\.0[/\\].*;
-    sys[/\\].*;
-    unistd\.h;
-    strings\.h;
-    fcntl\.h;
-    termios\.h;
-    [/\\](um|shared)[/\\].*;
-    sal\.h;
-    clipper[/\\]clipper\.hpp;
-    png(lib)?conf\.h;
-    mcut[/\\]platform\.h;
-    boost[/\\]polygon[/\\].*;
-    lzo(conf|defs)\.h

src/OrcaSlicer.cpp

@@ -20,49 +20,6 @@
     #endif /* SLIC3R_GUI */
 #endif /* WIN32 */
 
-#include <map>
-#include <vector>
-#include "libslic3r/PrintBase.hpp"
-#include "slic3r/Utils/json_diff.hpp"
-#include <boost/date_time/posix_time/posix_time_duration.hpp>
-#include <cerrno>
-#include <utility>
-#include <boost/filesystem/operations.hpp>
-#include <boost/filesystem/fstream.hpp>
-#include "libslic3r/LocalesUtils.hpp"
-#include <fstream>
-#include <exception>
-#include <set>
-#include "libslic3r/Color.hpp"
-#include "libslic3r/TriangleSelector.hpp"
-#include <algorithm>
-#include "libslic3r/Format/bbs_3mf.hpp"
-#include <cstdlib>
-#include <stdlib.h>
-#include <stdexcept>
-#include "libslic3r/Point.hpp"
-#include "libslic3r_version.h"
-#include "libslic3r/Semver.hpp"
-#include "libslic3r/PrintConfig.hpp"
-#include "libslic3r/BoundingBox.hpp"
-#include "libslic3r/CustomGCode.hpp"
-#include <memory>
-#include <sstream>
-#include <iomanip>
-#include <iterator>
-#include "libslic3r/ClipperUtils.hpp"
-#include "libslic3r/GCode/WipeTowerEstimate.hpp"
-#include "slic3r/GUI/Gizmos/GLGizmoBase.hpp"
-#include <functional>
-#include "libslic3r/Arrange.hpp"
-#include "libslic3r/Polygon.hpp"
-#include "libslic3r/GCode/ThumbnailData.hpp"
-#include "slic3r/GUI/3DScene.hpp"
-#include "slic3r/GUI/GLShader.hpp"
-#include <cassert>
-#include <boost/filesystem/exception.hpp>
-#include <signal.h>
-
 #include <cstdio>
 #include <string>
 #include <cstring>

src/OrcaSlicer.hpp

@@ -1,14 +1,7 @@
 #ifndef SLIC3R_HPP
 #define SLIC3R_HPP
 
-#include <map>
-#include "libslic3r/BoundingBox.hpp"
-#include "libslic3r/PrintConfig.hpp"
-#include "libslic3r/Format/bbs_3mf.hpp"
-#include "libslic3r/GCode/ThumbnailData.hpp"
 #include <set>
-#include <string>
-#include <vector>
 
 #include "libslic3r/Config.hpp"
 #include "libslic3r/Model.hpp"

src/dev-utils/CMakeLists.txt

@@ -28,6 +28,12 @@ if (ORCA_TOOLS)
     target_link_libraries(generate_system_cache libslic3r boost_headeronly)
     target_compile_definitions(generate_system_cache PRIVATE ${_DEV_DEFS})
 
+    # texture_unwrap_dump: reports the LSCM unwrap of a saved project's texture displacement layers,
+    # chart by chart, so a defect can be reproduced from the project file instead of from a screenshot.
+    add_executable(texture_unwrap_dump texture_unwrap_dump.cpp)
+    target_link_libraries(texture_unwrap_dump libslic3r boost_headeronly nanosvg)
+    target_compile_definitions(texture_unwrap_dump PRIVATE ${_DEV_DEFS})
+
     # profile_include_dump: prints what included templates contribute to a vendor's presets,
     # to diff against the same tool built in BambuStudio. Built only on request.
     add_executable(profile_include_dump EXCLUDE_FROM_ALL profile_include_dump.cpp)

src/dev-utils/OrcaSlicer_profile_validator.cpp

@@ -8,28 +8,6 @@
 #define NANOSVGRAST_IMPLEMENTATION
 #include "nanosvg/nanosvgrast.h"
 
-#include <vector>
-#include <boost/filesystem/path.hpp>
-#include <map>
-#include "libslic3r/Point.hpp"
-#include "libslic3r/libslic3r.h"
-#include "libslic3r/Polygon.hpp"
-#include "libslic3r/PrintConfig.hpp"
-#include <utility>
-#include "libslic3r/CustomGCode.hpp"
-#include <iterator>
-#include <boost/smart_ptr/make_shared_object.hpp>
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/log/core/record_view.hpp>
-#include <boost/log/expressions/message.hpp>
-#include <cstddef>
-#include <exception>
-#include "libslic3r/PlaceholderParser.hpp"
-#include <boost/program_options/options_description.hpp>
-#include <boost/program_options/value_semantic.hpp>
-#include <boost/program_options/variables_map.hpp>
-#include <boost/program_options/errors.hpp>
-
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/GCode.hpp"
 #include "libslic3r/GCode/WipeTower.hpp"

src/dev-utils/encoding-check.cpp

@@ -1,4 +1,3 @@
-#include <iosfwd>
 #include <vector>
 #include <iostream>
 #include <fstream>

src/dev-utils/generate_system_cache.cpp

@@ -4,19 +4,9 @@
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem.hpp>
-#include <boost/filesystem/operations.hpp>
-#include <boost/filesystem/directory.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/program_options.hpp>
-#include <boost/program_options/options_description.hpp>
-#include <boost/program_options/value_semantic.hpp>
-#include <boost/program_options/variables_map.hpp>
-#include <boost/program_options/errors.hpp>
-#include <exception>
-#include <cstddef>
 #include <iostream>
-#include <memory>
-#include "libslic3r/Config.hpp"
 
 using namespace Slic3r;
 namespace fs = boost::filesystem;

src/dev-utils/profile_include_dump.cpp

@@ -11,19 +11,13 @@
 #include "libslic3r/Utils.hpp"
 
 #include <boost/filesystem.hpp>
-#include <boost/filesystem/path.hpp>
-#include <boost/filesystem/operations.hpp>
 #include <boost/nowide/fstream.hpp>
 #include "nlohmann/json.hpp"
 
 #include <algorithm>
-#include <cstddef>
-#include <exception>
 #include <iostream>
-#include "libslic3r/Config.hpp"
 #include <map>
 #include <set>
-#include <stdexcept>
 #include <string>
 #include <vector>
 

src/dev-utils/texture_unwrap_dump.cpp

@@ -0,0 +1,292 @@
+// Diagnostic for the LSCM unwrap of a texture displacement layer.
+//
+// It exists because the defect it hunts only shows up on a real painted patch: the paint mask is built
+// by TriangleSelector splitting base triangles, so the patch topology cannot be written down by hand,
+// and reasoning about it from a screenshot of the 3D view had already produced three wrong diagnoses.
+// This loads a saved project, rebuilds exactly the patch the bake would act on, runs the same unwrap,
+// and reports what came out - per chart, so a bad one can be pointed at rather than guessed at.
+//
+//   texture_unwrap_dump <project.3mf>
+
+// nanosvg is header-only and libslic3r's 3mf import references it without carrying the implementation,
+// so every executable that links libslic3r has to supply it. Must precede any include that pulls the
+// header in, or its include guard suppresses the implementation. Same pattern as the other dev tools.
+#define NANOSVG_IMPLEMENTATION
+#include "nanosvg/nanosvg.h"
+#define NANOSVGRAST_IMPLEMENTATION
+#include "nanosvg/nanosvgrast.h"
+
+#include <chrono>
+#include <cstdio>
+#include <string>
+#include <functional>
+#include <unordered_map>
+#include <vector>
+
+#include "libslic3r/Model.hpp"
+#include "libslic3r/TextureDisplacement.hpp"
+#include "libslic3r/Format/bbs_3mf.hpp"
+#include "libslic3r/Utils.hpp"
+
+#include <boost/filesystem.hpp>
+
+using namespace Slic3r;
+
+namespace {
+
+uint64_t edge_key(int a, int b)
+{
+    if (a > b)
+        std::swap(a, b);
+    return (uint64_t(uint32_t(a)) << 32) | uint32_t(b);
+}
+
+// Boundary loops and the Euler characteristic of a face set, which together say whether a chart is the
+// topological disk LSCM needs (one loop, V - E + F == 1).
+void chart_topology(const indexed_triangle_set &mesh, const std::vector<int> &faces, int &loops, int &euler)
+{
+    std::unordered_map<uint64_t, int> edge_use;
+    std::unordered_map<int, int>      local;
+    for (const int f : faces) {
+        const stl_triangle_vertex_indices &t = mesh.indices[size_t(f)];
+        for (int i = 0; i < 3; ++i) {
+            ++edge_use[edge_key(t[i], t[(i + 1) % 3])];
+            local.emplace(t[i], int(local.size()));
+        }
+    }
+    euler = int(local.size()) - int(edge_use.size()) + int(faces.size());
+
+    std::unordered_map<int, int> parent;
+    const std::function<int(int)> find = [&](int x) {
+        while (parent[x] != x)
+            x = parent[x] = parent[parent[x]];
+        return x;
+    };
+    for (const auto &[key, uses] : edge_use)
+        if (uses == 1)
+            for (const int v : { int(key >> 32), int(uint32_t(key)) })
+                parent.emplace(v, v);
+    for (const auto &[key, uses] : edge_use)
+        if (uses == 1) {
+            const int a = find(int(key >> 32)), b = find(int(uint32_t(key)));
+            if (a != b)
+                parent[b] = a;
+        }
+    std::unordered_map<int, int> roots;
+    for (const auto &[v, p] : parent)
+        roots[find(v)] = 1;
+    loops = int(roots.size());
+}
+
+float signed_area_2d(const Vec2f &a, const Vec2f &b, const Vec2f &c)
+{
+    return 0.5f * ((b.x() - a.x()) * (c.y() - a.y()) - (c.x() - a.x()) * (b.y() - a.y()));
+}
+
+} // namespace
+
+int main(int argc, char **argv)
+{
+    if (argc < 2) {
+        std::printf("usage: texture_unwrap_dump <project.3mf>\n");
+        return 2;
+    }
+
+    Model                     model;
+    DynamicPrintConfig        config;
+    ConfigSubstitutionContext ctx(ForwardCompatibilitySubstitutionRule::Enable);
+    PlateDataPtrs             plate_data;
+    std::vector<Preset *>     project_presets;
+    bool                      is_bbl_3mf = false, is_orca_3mf = false;
+    Semver                    file_version;
+    // The importer writes a backup copy under the data dir and silently loses objects without one.
+    const boost::filesystem::path tmp = boost::filesystem::temp_directory_path() / "texture_unwrap_dump";
+    boost::filesystem::create_directories(tmp);
+    set_data_dir(tmp.string());
+
+    // LoadModel so the meshes come through; AddDefaultInstances because an object with no instance is
+    // dropped by the plate mapping, which is what "skip this object" in the log means.
+    if (!load_bbs_3mf(argv[1], &config, &ctx, &model, &plate_data, &project_presets, &is_bbl_3mf, &is_orca_3mf,
+                      &file_version, nullptr,
+                      LoadStrategy::LoadModel | LoadStrategy::LoadConfig | LoadStrategy::AddDefaultInstances |
+                          LoadStrategy::Silence)) {
+        std::printf("failed to load %s\n", argv[1]);
+        return 1;
+    }
+
+    std::printf("loaded: %zu object(s)\n", model.objects.size());
+
+    for (const ModelObject *object : model.objects)
+        for (const ModelVolume *volume : object->volumes) {
+            if (volume->texture_displacement_layers.empty()) {
+                std::printf("volume \"%s\": no texture displacement layers; paint masks per slot:",
+                            volume->name.c_str());
+                for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i)
+                    std::printf(" %zu", volume->texture_displacement_facet(i).get_data().triangles_to_split.size());
+                std::printf("\n");
+                continue;
+            }
+            std::printf("volume \"%s\": %zu base triangles, %zu layer(s)\n", volume->name.c_str(),
+                        volume->mesh().its.indices.size(), volume->texture_displacement_layers.size());
+
+            for (const TextureDisplacementLayer &layer : volume->texture_displacement_layers) {
+                std::printf("\n  layer %d \"%s\"  mapping=%d  seam_angle=%.1f  connect=%d  islands_stored=%zu\n",
+                            layer.slot, layer.name.c_str(), int(layer.projection_method),
+                            layer.lscm_seam_angle_deg, int(layer.auto_connect_islands), layer.islands.size());
+                if (layer.projection_method != TextureProjectionMethod::LSCM)
+                    continue;
+
+                const indexed_triangle_set patch =
+                    extract_painted_patch(volume->mesh().its, volume->texture_displacement_facet(layer.slot).get_data());
+                std::printf("  patch: %zu vertices, %zu triangles\n", patch.vertices.size(), patch.indices.size());
+                if (patch.indices.empty())
+                    continue;
+
+                const auto t0 = std::chrono::steady_clock::now();
+                const PatchUnwrap unwrap = compute_patch_unwrap(patch, layer.lscm_seam_angle_deg, 0.f,
+                                                                layer.lscm_seam_edges);
+                const auto t1 = std::chrono::steady_clock::now();
+                std::printf("  TIMING compute_patch_unwrap: %.0f ms\n",
+                            std::chrono::duration<double, std::milli>(t1 - t0).count());
+                std::printf("  unwrap: %d charts, %zu unwrapped triangles\n", unwrap.chart_count,
+                            unwrap.indices.size());
+
+                // Group the patch's faces by chart so each can be examined on its own.
+                std::vector<std::vector<int>> chart_faces(size_t(std::max(unwrap.chart_count, 0)));
+                for (size_t i = 0; i < unwrap.indices.size(); ++i) {
+                    const int chart = unwrap.vertex_chart[size_t(unwrap.indices[i][0])];
+                    if (chart >= 0 && size_t(chart) < chart_faces.size())
+                        chart_faces[size_t(chart)].push_back(unwrap.source_face[i]);
+                }
+
+                int bad_charts = 0;
+                for (size_t c = 0; c < chart_faces.size(); ++c) {
+                    int loops = 0, euler = 0;
+                    chart_topology(patch, chart_faces[c], loops, euler);
+
+                    // Flipped triangles: the unwrap folded over itself, which is what a planar fallback
+                    // does to a chart that is not flat. Measured on the unwrap's own triangles.
+                    int pos = 0, neg = 0;
+                    for (size_t i = 0; i < unwrap.indices.size(); ++i) {
+                        const stl_triangle_vertex_indices &t = unwrap.indices[i];
+                        if (unwrap.vertex_chart[size_t(t[0])] != int(c))
+                            continue;
+                        const float a = signed_area_2d(unwrap.uvs[size_t(t[0])], unwrap.uvs[size_t(t[1])],
+                                                       unwrap.uvs[size_t(t[2])]);
+                        if (a > 0.f) ++pos; else if (a < 0.f) ++neg;
+                    }
+                    const int flipped = std::min(pos, neg);
+                    const bool disk   = loops == 1 && euler == 1;
+                    if (!disk || flipped > 0) {
+                        ++bad_charts;
+                        std::printf("    chart %2zu: %4zu faces  loops=%d euler=%d%s  flipped=%d/%d%s\n", c,
+                                    chart_faces[c].size(), loops, euler, disk ? "" : "  NOT A DISK", flipped,
+                                    pos + neg, flipped ? "  FOLDED" : "");
+                    }
+                }
+                std::printf("  charts with a defect: %d / %d\n", bad_charts, unwrap.chart_count);
+
+                // What the eye actually sees. Every patch edge shared by two charts should carry the same
+                // UV on both sides once the islands are laid out as a connected net; where it does not,
+                // the texture jumps across that seam. Measured through compute_lscm_uvs(), i.e. the exact
+                // coordinates the bake and the checker overlay sample.
+                {
+                    const auto n0 = std::chrono::steady_clock::now();
+                    const std::vector<TextureIsland> net = compute_connected_net(unwrap);
+                    const auto n1 = std::chrono::steady_clock::now();
+                    std::printf("  TIMING compute_connected_net: %.0f ms (%zu islands)\n",
+                                std::chrono::duration<double, std::milli>(n1 - n0).count(), net.size());
+                }
+                const auto t2 = std::chrono::steady_clock::now();
+                const std::vector<Vec2f> uv = compute_lscm_uvs(patch, layer);
+                const auto t3 = std::chrono::steady_clock::now();
+                std::printf("  TIMING compute_lscm_uvs:     %.0f ms  (called on every preview, overlay and bake)\n",
+                            std::chrono::duration<double, std::milli>(t3 - t2).count());
+                if (uv.size() != patch.vertices.size()) {
+                    std::printf("  compute_lscm_uvs returned %zu uvs for %zu vertices\n", uv.size(),
+                                patch.vertices.size());
+                    continue;
+                }
+                // Per-corner UVs carry each chart's own placement, so an edge shared by two charts shows
+                // the jump directly: the same mesh vertex lands at two different UVs. That is exactly what
+                // the eye reads as the texture breaking.
+                const auto t4 = std::chrono::steady_clock::now();
+                const std::vector<Vec2f> corner = compute_lscm_corner_uvs(patch, layer);
+                const auto t5 = std::chrono::steady_clock::now();
+                std::printf("  TIMING compute_lscm_corner_uvs: %.0f ms\n",
+                            std::chrono::duration<double, std::milli>(t5 - t4).count());
+                // Keyed by edge, holding the UV each incident face gives to the edge's *lower-numbered*
+                // endpoint. Comparing that same vertex on both sides is the point: indexing by corner
+                // position instead compares opposite ends of the edge, because the two faces wind it in
+                // opposite directions.
+                std::unordered_map<uint64_t, std::vector<Vec2f>> edge_seen;
+                if (corner.size() == patch.indices.size() * 3)
+                    for (size_t f = 0; f < patch.indices.size(); ++f) {
+                        const stl_triangle_vertex_indices &t = patch.indices[f];
+                        for (int k = 0; k < 3; ++k) {
+                            const int a = t[k], b = t[(k + 1) % 3];
+                            const int probe = std::min(a, b);
+                            const int local = (a == probe) ? k : (k + 1) % 3;
+                            edge_seen[edge_key(a, b)].push_back(corner[f * 3 + size_t(local)]);
+                        }
+                    }
+                // Which chart each patch face belongs to, so a broken edge can be attributed to a pair.
+                std::vector<int> chart_of_face(patch.indices.size(), -1);
+                for (size_t i = 0; i < unwrap.indices.size(); ++i)
+                    chart_of_face[size_t(unwrap.source_face[i])] = unwrap.vertex_chart[size_t(unwrap.indices[i][0])];
+
+                std::unordered_map<uint64_t, std::vector<int>> edge_faces;
+                for (size_t f = 0; f < patch.indices.size(); ++f) {
+                    const stl_triangle_vertex_indices &t = patch.indices[f];
+                    for (int k = 0; k < 3; ++k)
+                        edge_faces[edge_key(t[k], t[(k + 1) % 3])].push_back(int(f));
+                }
+
+                int adjacent = 0, broken = 0, broken_same_chart = 0;
+                float worst = 0.f;
+                std::map<std::pair<int, int>, std::pair<int, float>> by_pair;
+                for (const auto &[key, seen] : edge_seen) {
+                    if (seen.size() != 2)
+                        continue;
+                    ++adjacent;
+                    const float d = (seen[0] - seen[1]).norm();
+                    if (d <= 1e-4f)
+                        continue;
+                    ++broken;
+                    worst = std::max(worst, d);
+                    const auto &faces_here = edge_faces[key];
+                    int c1 = -1, c2 = -1;
+                    if (faces_here.size() == 2) {
+                        c1 = chart_of_face[size_t(faces_here[0])];
+                        c2 = chart_of_face[size_t(faces_here[1])];
+                    }
+                    if (c1 == c2)
+                        ++broken_same_chart;
+                    auto &slot = by_pair[{ std::min(c1, c2), std::max(c1, c2) }];
+                    ++slot.first;
+                    slot.second = std::max(slot.second, d);
+                }
+                std::printf("  broken edges inside a single chart: %d\n", broken_same_chart);
+                std::printf("  broken by chart pair:");
+                for (const auto &[pk, v] : by_pair)
+                    std::printf(" (%d,%d)x%d/%.1f", pk.first, pk.second, v.first, v.second);
+                std::printf("\n");
+                // Total length of the seams left broken, in mm: how much visibly torn edge the layout has,
+                // which is what the eye adds up. A count alone hides whether the breaks are hairlines or
+                // whole sides of an island.
+                float seam_mm = 0.f;
+                for (const auto &[key, seen] : edge_seen) {
+                    if (seen.size() != 2 || (seen[0] - seen[1]).norm() <= 1e-4f)
+                        continue;
+                    seam_mm += (patch.vertices[size_t(key >> 32)] - patch.vertices[size_t(uint32_t(key))]).norm();
+                }
+                std::printf("  interior edges: %d, discontinuous: %d, total torn seam: %.2f mm (worst jump %.3f)\n",
+                            adjacent, broken, seam_mm, worst);
+                std::printf("  stored islands %zu vs charts %d -> %s\n", layer.islands.size(),
+                            unwrap.chart_count,
+                            layer.islands.size() == size_t(unwrap.chart_count) ? "stored placements used"
+                                                                              : "net rebuilt");
+            }
+        }
+    return 0;
+}

src/libslic3r/TextureDisplacement.cpp

@@ -1236,52 +1236,81 @@ bool triangles_overlap(const Tri2 &a, const Tri2 &b, float eps)
 struct NetGrid
 {
     static constexpr int BIG_SPAN = 16;
-    float                cell;
-    float                eps;
-    std::unordered_map<uint64_t, std::vector<Tri2>> cells;
-    std::vector<Tri2>    big;
+    // Each stored triangle keeps its own bounding box. Overlap testing is dominated by rejects - a cell
+    // holds every triangle whose box touches it, and a candidate meets only a couple of them for real -
+    // so paying six floats per entry to answer most of those rejects with four comparisons, instead of a
+    // full triangle intersection, is what makes the net affordable. Measured on a 42k-triangle patch the
+    // grid ran ~19 million candidate pairs per net, nearly all of them misses, and rejecting them this
+    // way took the net from ~175 ms to ~53 ms.
+    //
+    // The box rides inside the entry rather than in a parallel array: splitting them to scan boxes back
+    // to back was tried and came out slower, because each bucket then grows two vectors instead of one.
+    struct Entry
+    {
+        Tri2  tri;
+        Vec2f lo, hi;
+    };
+    float                                           cell;
+    float                                           eps;
+    std::unordered_map<uint64_t, std::vector<Entry>> cells;
+    std::vector<Entry>                              big;
 
     static uint64_t key(int x, int y) { return (uint64_t(uint32_t(x)) << 32) | uint32_t(y); }
-    bool range(const Tri2 &t, int &x0, int &y0, int &x1, int &y1) const
+    static Entry    entry(const Tri2 &t)
+    {
+        return Entry{ t, t[0].cwiseMin(t[1]).cwiseMin(t[2]), t[0].cwiseMax(t[1]).cwiseMax(t[2]) };
+    }
+    bool range(const Vec2f &lo, const Vec2f &hi, int &x0, int &y0, int &x1, int &y1) const
     {
-        const Vec2f lo = t[0].cwiseMin(t[1]).cwiseMin(t[2]), hi = t[0].cwiseMax(t[1]).cwiseMax(t[2]);
         x0 = int(std::floor(lo.x() / cell));
         y0 = int(std::floor(lo.y() / cell));
         x1 = int(std::floor(hi.x() / cell));
         y1 = int(std::floor(hi.y() / cell));
         return x1 - x0 <= BIG_SPAN && y1 - y0 <= BIG_SPAN;
     }
+    // Boxes grown by eps on both sides, to match the tolerance triangles_overlap() itself works to: a
+    // reject here must never discard a pair that test would have called touching.
+    bool boxes_apart(const Entry &a, const Entry &b) const
+    {
+        return a.hi.x() + eps < b.lo.x() || b.hi.x() + eps < a.lo.x() || a.hi.y() + eps < b.lo.y() ||
+               b.hi.y() + eps < a.lo.y();
+    }
+    bool hits(const Entry &q, const std::vector<Entry> &bucket) const
+    {
+        for (const Entry &b : bucket)
+            if (!boxes_apart(q, b) && triangles_overlap(q.tri, b.tri, eps))
+                return true;
+        return false;
+    }
     bool overlaps(const Tri2 &t) const
     {
-        for (const Tri2 &b : big)
-            if (triangles_overlap(t, b, eps))
-                return true;
+        const Entry q = entry(t);
+        if (hits(q, big))
+            return true;
         int x0, y0, x1, y1;
-        if (!range(t, x0, y0, x1, y1)) {
-            for (const auto &[k, tris] : cells)
-                for (const Tri2 &b : tris)
-                    if (triangles_overlap(t, b, eps))
-                        return true;
+        if (!range(q.lo, q.hi, x0, y0, x1, y1)) {
+            for (const auto &[k, bucket] : cells)
+                if (hits(q, bucket))
+                    return true;
             return false;
         }
         for (int x = x0; x <= x1; ++x)
             for (int y = y0; y <= y1; ++y)
-                if (const auto it = cells.find(key(x, y)); it != cells.end())
-                    for (const Tri2 &b : it->second)
-                        if (triangles_overlap(t, b, eps))
-                            return true;
+                if (const auto it = cells.find(key(x, y)); it != cells.end() && hits(q, it->second))
+                    return true;
         return false;
     }
     void insert(const Tri2 &t)
     {
-        int x0, y0, x1, y1;
-        if (!range(t, x0, y0, x1, y1)) {
-            big.push_back(t);
+        const Entry e = entry(t);
+        int         x0, y0, x1, y1;
+        if (!range(e.lo, e.hi, x0, y0, x1, y1)) {
+            big.push_back(e);
             return;
         }
         for (int x = x0; x <= x1; ++x)
             for (int y = y0; y <= y1; ++y)
-                cells[key(x, y)].push_back(t);
+                cells[key(x, y)].push_back(e);
     }
 };
 } // namespace
@@ -1293,11 +1322,20 @@ std::vector<TextureIsland> compute_connected_net(const PatchUnwrap &unwrap)
     if (n <= 1)
         return islands;
 
-    // Chart adjacency, with one representative shared edge per adjacent pair.
+    // Chart adjacency, with one representative shared edge per adjacent pair: the fold line the pair is
+    // unfolded about.
+    //
+    // Which edge that is matters, because two charts can touch along more than one run. A chart cut open
+    // to flatten it - a ring opened by segment_into_charts(), say - touches its other half along *both*
+    // sides of the cut. Folding is rigid, so only the run the fold line belongs to comes out matching;
+    // every other run is left mismatched, and a mismatched run is exactly where the texture visibly
+    // jumps. Taking whichever edge the map happened to yield first therefore left the long side broken
+    // about as often as the short one. The fold line is picked from the longest run instead, so what is
+    // left discontinuous is the shortest boundary the pair has.
     const auto edges = build_shared_edges(unwrap);
     struct PairEdge { ChartEdge a, b; };
-    std::map<std::pair<int, int>, PairEdge> pair_edge;
-    std::vector<std::vector<int>>            adj(static_cast<size_t>(n));
+    struct SharedEdge { PairEdge fold; int base_lo = -1, base_hi = -1; float length = 0.f; };
+    std::map<std::pair<int, int>, std::vector<SharedEdge>> pair_shared;
     for (const auto &[base_edge, list] : edges) {
         for (size_t i = 0; i < list.size(); ++i)
             for (size_t j = i + 1; j < list.size(); ++j) {
@@ -1305,14 +1343,50 @@ std::vector<TextureIsland> compute_connected_net(const PatchUnwrap &unwrap)
                 if (c1 == c2 || c1 < 0 || c2 < 0 || c1 >= n || c2 >= n)
                     continue;
                 const std::pair<int, int> pk{ std::min(c1, c2), std::max(c1, c2) };
-                if (pair_edge.count(pk))
-                    continue; // keep the first shared edge as the fold line for this pair
-                pair_edge[pk] = (c1 < c2) ? PairEdge{ list[i], list[j] } : PairEdge{ list[j], list[i] };
-                adj[size_t(pk.first)].push_back(pk.second);
-                adj[size_t(pk.second)].push_back(pk.first);
+                SharedEdge se;
+                se.fold    = (c1 < c2) ? PairEdge{ list[i], list[j] } : PairEdge{ list[j], list[i] };
+                se.base_lo = base_edge.first;
+                se.base_hi = base_edge.second;
+                // The unwrap is scaled to true surface area, so a uv distance is a length in mm.
+                se.length = (unwrap.uvs[size_t(se.fold.a.uv_lo)] - unwrap.uvs[size_t(se.fold.a.uv_hi)]).norm();
+                pair_shared[pk].push_back(se);
             }
     }
 
+    std::map<std::pair<int, int>, PairEdge> pair_edge;
+    std::map<std::pair<int, int>, float>    pair_weight; // length of the run each pair folds across
+    std::vector<std::vector<int>>           adj(static_cast<size_t>(n));
+    for (const auto &[pk, shared] : pair_shared) {
+        // Group the pair's shared edges into runs - edges joined end to end through a base vertex - and
+        // total each run's length.
+        std::unordered_map<int, int> local;
+        for (const SharedEdge &se : shared)
+            for (const int v : { se.base_lo, se.base_hi })
+                local.emplace(v, int(local.size()));
+        UnionFind runs(local.size());
+        for (const SharedEdge &se : shared)
+            runs.unite(local[se.base_lo], local[se.base_hi]);
+
+        std::unordered_map<int, float>  run_length;
+        std::unordered_map<int, size_t> run_first;
+        for (size_t i = 0; i < shared.size(); ++i) {
+            const int root = runs.find(local[shared[i].base_lo]);
+            run_length[root] += shared[i].length;
+            run_first.emplace(root, i);
+        }
+        int   best_root = -1;
+        float best_len  = -1.f;
+        for (const auto &[root, len] : run_length)
+            if (len > best_len) { best_len = len; best_root = root; }
+        if (best_root < 0)
+            continue;
+
+        pair_edge[pk] = shared[run_first[best_root]].fold;
+        pair_weight[pk] = best_len;
+        adj[size_t(pk.first)].push_back(pk.second);
+        adj[size_t(pk.second)].push_back(pk.first);
+    }
+
     // Per chart: its vertices, its triangles and its flattened area.
     std::vector<std::vector<int>> chart_verts(static_cast<size_t>(n)), chart_tris(static_cast<size_t>(n));
     std::vector<float>            chart_area(static_cast<size_t>(n), 0.f);
@@ -1366,15 +1440,29 @@ std::vector<TextureIsland> compute_connected_net(const PatchUnwrap &unwrap)
             for (const int t : chart_tris[size_t(root)])
                 grid.insert(placed(m, t));
         }
-        std::queue<int> q;
-        q.push(root);
+        // Grown strongest-adjacency-first (Prim, not breadth-first): a chart is folded onto whichever
+        // neighbour it shares the longest boundary with, among everything reachable so far. Order matters
+        // because only the fold a chart is actually reached by comes out matching - every other boundary
+        // it has is left to chance. Taking neighbours in breadth-first order, biggest-area first, let a
+        // far-off branch claim a chart across a short boundary before its true neighbour was reached, and
+        // the long boundary they shared then stayed broken. That is the visible seam next to a hole: a
+        // ring is cut into two halves that share a long boundary, and whichever half was reached first
+        // took the other one along some unrelated edge.
+        using Candidate = std::pair<float, std::pair<int, int>>; // weight, (from, to)
+        std::priority_queue<Candidate>                              q;
+        const auto push_neighbours = [&](int p) {
+            for (const int c : adj[size_t(p)])
+                if (net_of[size_t(c)] < 0 && !chart_tris[size_t(c)].empty()) {
+                    const auto w = pair_weight.find({ std::min(p, c), std::max(p, c) });
+                    q.push({ w == pair_weight.end() ? 0.f : w->second, { p, c } });
+                }
+        };
+        push_neighbours(root);
         while (!q.empty()) {
-            const int p = q.front();
+            const auto [weight, link] = q.top();
             q.pop();
-            std::vector<int> neighbours = adj[size_t(p)];
-            std::stable_sort(neighbours.begin(), neighbours.end(),
-                             [&chart_area](int a, int b) { return chart_area[size_t(a)] > chart_area[size_t(b)]; });
-            for (const int c : neighbours) {
+            const int p = link.first, c = link.second;
+            {
                 if (net_of[size_t(c)] >= 0 || chart_tris[size_t(c)].empty())
                     continue;
                 const auto it = pair_edge.find({ std::min(p, c), std::max(p, c) });
@@ -1405,7 +1493,7 @@ std::vector<TextureIsland> compute_connected_net(const PatchUnwrap &unwrap)
                 for (const Tri2 &t : tris)
                     grid.insert(t);
                 net_of[size_t(c)] = net;
-                q.push(c);
+                push_neighbours(c);
             }
         }
     }
@@ -5041,4 +5129,5 @@ indexed_triangle_set cut_mesh_at_steps(const indexed_triangle_set &mesh, const s
     return out;
 }
 
+
 } // namespace Slic3r

src/libvgcode/include/ColorPrint.hpp

@@ -6,8 +6,6 @@
 #define VGCODE_COLORPRINT_HPP
 
 #include "../include/Types.hpp"
-#include <cstdint>
-#include <array>
 
 namespace libvgcode {
 

src/libvgcode/include/ColorRange.hpp

@@ -7,10 +7,7 @@
 
 #include "../include/Types.hpp"
 
-#include <array>
 #include <cfloat>
-#include <vector>
-#include <cstddef>
 
 namespace libvgcode {
 

src/libvgcode/include/GCodeInputData.hpp

@@ -6,8 +6,6 @@
 #define VGCODE_GCODEINPUTDATA_HPP
 
 #include "PathVertex.hpp"
-#include <vector>
-#include "Types.hpp"
 
 namespace libvgcode {
 

src/libvgcode/include/PathVertex.hpp

@@ -7,9 +7,7 @@
 
 #include "Types.hpp"
 
-#include <array>
 #include <cfloat>
-#include <cstdint>
 
 namespace libvgcode {
 

src/libvgcode/include/Types.hpp

@@ -5,7 +5,6 @@
 #ifndef VGCODE_TYPES_HPP
 #define VGCODE_TYPES_HPP
 
-#include <cstddef>
 #define VGCODE_ENABLE_COG_AND_TOOL_MARKERS 0
 
 #include <array>

src/libvgcode/include/Viewer.hpp

@@ -7,10 +7,7 @@
 
 #include "Types.hpp"
 
-#include <cstddef>
-#include <cstdint>
 #include <string>
-#include <vector>
 
 namespace libvgcode {
 

src/libvgcode/src/Bitset.hpp

@@ -6,9 +6,6 @@
 #define VGCODE_BITSET_HPP
 
 #include <atomic>
-#include <cstddef>
-#include <type_traits>
-#include <utility>
 #include <vector>
 
 namespace libvgcode {

src/libvgcode/src/ColorRange.cpp

@@ -7,13 +7,8 @@
 #include "Utils.hpp"
 
 #include <algorithm>
-#include <array>
 #include <assert.h>
-#include <cfloat>
 #include <cmath>
-#include "../include/Types.hpp"
-#include <cstddef>
-#include <vector>
 
 namespace libvgcode {
 

src/libvgcode/src/ExtrusionRoles.cpp

@@ -3,11 +3,6 @@
 ///|/ libvgcode is released under the terms of the AGPLv3 or higher
 ///|/
 #include "ExtrusionRoles.hpp"
-#include "../include/Types.hpp"
-#include <array>
-#include <utility>
-#include <cstddef>
-#include <vector>
 
 namespace libvgcode {
 

src/libvgcode/src/ExtrusionRoles.hpp

@@ -7,10 +7,7 @@
 
 #include "../include/Types.hpp"
 
-#include <array>
-#include <cstddef>
 #include <map>
-#include <vector>
 
 namespace libvgcode {
 

src/libvgcode/src/Layers.cpp

@@ -9,11 +9,6 @@
 
 #include <assert.h>
 #include <algorithm>
-#include "../include/Types.hpp"
-#include <cstdint>
-#include <cstddef>
-#include <vector>
-#include <iterator>
 
 namespace libvgcode {
 

src/libvgcode/src/Layers.hpp

@@ -6,11 +6,6 @@
 #define VGCODE_LAYERS_HPP
 
 #include "Range.hpp"
-#include <cstdint>
-#include <cstddef>
-#include "../include/Types.hpp"
-#include <array>
-#include <vector>
 
 namespace libvgcode {
 

src/libvgcode/src/OpenGLUtils.cpp

@@ -10,7 +10,6 @@
 #include <cctype>
 #include <stdio.h>
 #include <cstring>
-#include <string>
 
 namespace libvgcode {
 

src/libvgcode/src/OptionTemplate.cpp

@@ -6,9 +6,6 @@
 #include "OpenGLUtils.hpp"
 #include "Utils.hpp"
 
-#include <cstdint>
-#include "../include/Types.hpp"
-#include <cstddef>
 #include <vector>
 #include <algorithm>
 #include <cmath>

src/libvgcode/src/PathVertex.cpp

@@ -3,7 +3,6 @@
 ///|/ libvgcode is released under the terms of the AGPLv3 or higher
 ///|/
 #include "../include/PathVertex.hpp"
-#include "../include/Types.hpp"
 
 namespace libvgcode {
 

src/libvgcode/src/Range.cpp

@@ -5,7 +5,6 @@
 #include "Range.hpp"
 
 #include <algorithm>
-#include "../include/Types.hpp"
 
 namespace libvgcode {
 

src/libvgcode/src/SegmentTemplate.cpp

@@ -5,7 +5,6 @@
 #include "SegmentTemplate.hpp"
 #include "OpenGLUtils.hpp"
 
-#include <cstddef>
 #include <cstdint>
 #include <array>
 

src/libvgcode/src/Settings.hpp

@@ -7,8 +7,6 @@
 
 #include "../include/Types.hpp"
 
-#include <array>
-#include <cstddef>
 #include <map>
 
 namespace libvgcode {

src/libvgcode/src/ToolMarker.cpp

@@ -7,7 +7,6 @@
 #include "Utils.hpp"
 
 #include <cmath>
-#include "../include/Types.hpp"
 
 #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
 

src/libvgcode/src/Types.cpp

@@ -5,7 +5,6 @@
 #include "../include/Types.hpp"
 
 #include <algorithm>
-#include <cstdint>
 
 namespace libvgcode {
 

src/libvgcode/src/Utils.cpp

@@ -6,9 +6,6 @@
 
 #include <assert.h>
 #include <cmath>
-#include "../include/Types.hpp"
-#include <vector>
-#include <cstdint>
 
 namespace libvgcode {
 

src/libvgcode/src/Utils.hpp

@@ -6,8 +6,6 @@
 #define VGCODE_UTILS_HPP
 
 #include "../include/Types.hpp"
-#include <vector>
-#include <cstdint>
 
 #ifdef _WIN32
 #define STDVEC_MEMSIZE(NAME, TYPE) NAME.capacity() * ((sizeof(TYPE) + __alignof(TYPE) - 1) / __alignof(TYPE)) * __alignof(TYPE)

src/libvgcode/src/ViewRange.cpp

@@ -3,7 +3,6 @@
 ///|/ libvgcode is released under the terms of the AGPLv3 or higher
 ///|/
 #include "ViewRange.hpp"
-#include "../include/Types.hpp"
 
 namespace libvgcode {
 

src/libvgcode/src/ViewRange.hpp

@@ -6,7 +6,6 @@
 #define VGCODE_VIEWRANGE_HPP
 
 #include "Range.hpp"
-#include "../include/Types.hpp"
 
 namespace libvgcode {
 

src/libvgcode/src/Viewer.cpp

@@ -4,12 +4,6 @@
 ///|/
 #include "../include/Viewer.hpp"
 #include "ViewerImpl.hpp"
-#include <string>
-#include <utility>
-#include "../include/Types.hpp"
-#include <cstddef>
-#include <vector>
-#include <cstdint>
 
 namespace libvgcode {
 

src/libvgcode/src/ViewerImpl.cpp

@@ -9,26 +9,14 @@
 #include "OpenGLUtils.hpp"
 #include "Utils.hpp"
 
-#include <cstdint>
-#include "../include/Types.hpp"
-#include <array>
-#include "../include/PathVertex.hpp"
-#include "Bitset.hpp"
-#include "../include/ColorPrint.hpp"
-#include <cfloat>
-#include <iterator>
 #include <map>
 #include <assert.h>
-#include <optional>
 #include <stdexcept>
 #include <cstdio>
 #include <string>
 #include <algorithm>
 #include <cmath>
 #include <numeric>
-#include <type_traits>
-#include <vector>
-#include <utility>
 
 namespace libvgcode {
 

src/libvgcode/src/ViewerImpl.hpp

@@ -8,12 +8,6 @@
 #include "Settings.hpp"
 #include "SegmentTemplate.hpp"
 #include "OptionTemplate.hpp"
-#include "../include/Types.hpp"
-#include <vector>
-#include <cstddef>
-#include <cstdint>
-#include <map>
-#include <array>
 #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
 #include "CogMarker.hpp"
 #include "ToolMarker.hpp"

src/slic3r/Config/Snapshot.cpp

@@ -1,21 +1,5 @@
 #include "Snapshot.hpp"
 
-#include <fstream>
-#include <stdexcept>
-#include <cstdio>
-#include <algorithm>
-#include <ios>
-#include <ostream>
-#include <string>
-#include <cassert>
-#include <map>
-#include <set>
-#include <boost/filesystem/directory.hpp>
-#include <cstring>
-#include <boost/filesystem/file_status.hpp>
-#include "libslic3r/Exception.hpp"
-#include "slic3r/Config/Version.hpp"
-#include <exception>
 #include <time.h>
 
 #include <boost/algorithm/string/predicate.hpp>
@@ -42,10 +26,7 @@
 #include "../GUI/MainFrame.hpp"
 #include "../GUI/MsgDialog.hpp"
 
-#include <vector>
-#include <utility>
 #include <wx/richmsgdlg.h>
-#include <wx/string.h>
 
 #define SLIC3R_SNAPSHOTS_DIR "snapshots"
 #define SLIC3R_SNAPSHOT_FILE "snapshot.ini"

src/slic3r/Config/Snapshot.hpp

@@ -1,8 +1,6 @@
 #ifndef slic3r_GUI_Snapshot_
 #define slic3r_GUI_Snapshot_
 
-#include <ctime>
-#include <cstddef>
 #include <map>
 #include <set>
 #include <string>

src/slic3r/Config/Version.cpp

@@ -1,21 +1,9 @@
 #include "Version.hpp"
 
-#include <boost/filesystem/path.hpp>
-#include <boost/optional/optional.hpp>
-#include <algorithm>
-#include <boost/filesystem/directory.hpp>
 #include <cctype>
 
 #include <boost/filesystem/operations.hpp>
 #include <boost/nowide/fstream.hpp>
-#include "libslic3r/Semver.hpp"
-#include <cstring>
-#include <string>
-#include <cstddef>
-#include <vector>
-#include <stdexcept>
-#include <utility>
-#include "libslic3r/Exception.hpp"
 
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Config.hpp"

src/slic3r/Config/Version.hpp

@@ -1,7 +1,6 @@
 #ifndef slic3r_GUI_ConfigIndex_
 #define slic3r_GUI_ConfigIndex_
 
-#include <cstddef>
 #include <string>
 #include <vector>
 

src/slic3r/GUI/2DBed.cpp

@@ -4,26 +4,7 @@
 #include "3DBed.hpp"
 #include "PartPlate.hpp"
 
-#include <vector>
-#include "libslic3r/Polyline.hpp"
-#include "libslic3r/ExPolygon.hpp"
-#include "libslic3r/Point.hpp"
-#include "libslic3r/libslic3r.h"
-#include <wx/colour.h>
-#include <wx/brush.h>
-#include <algorithm>
-#include "libslic3r/Color.hpp"
-#include <string>
-#include <cstddef>
-#include "slic3r/GUI/Gizmos/GLGizmoBase.hpp"
-#include "slic3r/GUI/Widgets/StateColor.hpp"
 #include <wx/dcbuffer.h>
-#include <wx/event.h>
-#include <wx/panel.h>
-#include <wx/wx.h>
-#include <wx/gdicmn.h>
-#include <wx/peninfobase.h>
-#include <wx/font.h>
 
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/Geometry.hpp"

src/slic3r/GUI/2DBed.hpp

@@ -1,10 +1,6 @@
 #ifndef slic3r_2DBed_hpp_
 #define slic3r_2DBed_hpp_
 
-#include <wx/panel.h>
-#include "libslic3r/Point.hpp"
-#include "libslic3r/Line.hpp"
-#include <vector>
 #include <wx/wx.h>
 #include "libslic3r/Config.hpp"
 #include "libslic3r/ExPolygon.hpp"

src/slic3r/GUI/3DBed.cpp

@@ -15,27 +15,11 @@
 #include "Plater.hpp"
 #include "Camera.hpp"
 
-#include <boost/version.hpp>
-#include <cstddef>
-#include <array>
 #include <glad/gl.h>
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem/operations.hpp>
 #include <boost/log/trivial.hpp>
-#include "slic3r/GUI/GLModel.hpp"
-#include <vector>
-#include "libslic3r/Point.hpp"
-#include <utility>
-#include "libslic3r/Color.hpp"
-#include "slic3r/GUI/ImGuiWrapper.hpp"
-#include "slic3r/GUI/GLShader.hpp"
-#include "slic3r/GUI/3DScene.hpp"
-#include "libslic3r/Geometry.hpp"
-#include <math.h>
-#include <tuple>
-#include "libslic3r/Preset.hpp"
-#include "libslic3r/Config.hpp"
 
 #if BOOST_VERSION >= 107800
 #include <boost/timer/timer.hpp>

src/slic3r/GUI/3DBed.hpp

@@ -8,13 +8,8 @@
 #include "libslic3r/BuildVolume.hpp"
 #include "libslic3r/ExPolygon.hpp"
 
-#include "libslic3r/Color.hpp"
-#include "libslic3r/Point.hpp"
-#include <string>
-#include "libslic3r/BoundingBox.hpp"
 #include <tuple>
 #include <array>
-#include <vector>
 
 namespace Slic3r {
 namespace GUI {

src/slic3r/GUI/3DScene.cpp

@@ -1,7 +1,3 @@
-#include <array>
-#include <algorithm>
-#include <functional>
-#include <cmath>
 #include <glad/gl.h>
 
 #include "3DScene.hpp"
@@ -29,30 +25,6 @@
 #include "libslic3r/Tesselate.hpp"
 #include "libslic3r/PrintConfig.hpp"
 
-#include "libslic3r/BoundingBox.hpp"
-#include "libslic3r/TriangleMeshSlicer.hpp"
-#include "libslic3r/Polygon.hpp"
-#include "libslic3r/Point.hpp"
-#include "slic3r/GUI/ImGuiWrapper.hpp"
-#include "libslic3r/Model.hpp"
-#include "libslic3r/Technologies.hpp"
-#include <optional>
-#include "slic3r/GUI/OpenGLManager.hpp"
-#include "libslic3r/Config.hpp"
-#include <memory>
-#include "slic3r/GUI/MeshUtils.hpp"
-#include "libslic3r/TriangleMesh.hpp"
-#include <math.h>
-#include "libslic3r/ObjectID.hpp"
-#include "libslic3r/libslic3r.h"
-#include <map>
-#include <set>
-#include <iterator>
-#include "libslic3r/Color.hpp"
-#include "slic3r/GUI/GUI_ObjectList.hpp"
-#include "libslic3r/Line.hpp"
-#include "libslic3r/Polyline.hpp"
-#include "libslic3r/Exception.hpp"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -64,9 +36,6 @@
 #include <boost/algorithm/string/predicate.hpp>
 
 #include <Eigen/Dense>
-#include <vector>
-#include <utility>
-#include <string>
 
 #ifdef HAS_GLSAFE
 void glAssertRecentCallImpl(const char* file_name, unsigned int line, const char* function_name)

src/slic3r/GUI/3DScene.hpp

@@ -16,17 +16,8 @@
 #include "GLShader.hpp"
 #include "MeshUtils.hpp"
 
-#include <array>
-#include <cstddef>
-#include <cmath>
 #include <functional>
-#include <map>
-#include "libslic3r/BoundingBox.hpp"
-#include <memory>
 #include <optional>
-#include <vector>
-#include <string>
-#include <utility>
 
 #ifndef NDEBUG
 #define HAS_GLSAFE

src/slic3r/GUI/AMSDryControl.cpp

@@ -19,38 +19,7 @@
 #include "libslic3r/PresetBundle.hpp"
 #include "libslic3r/Preset.hpp"
 
-#include <algorithm>
 #include <boost/log/trivial.hpp>
-#include <string>
-#include "slic3r/GUI/DeviceCore/DevDefs.h"
-#include <wx/string.h>
-#include <wx/event.h>
-#include <wx/panel.h>
-#include <wx/colour.h>
-#include "slic3r/GUI/Widgets/StateColor.hpp"
-#include <wx/gdicmn.h>
-#include "libslic3r/Exception.hpp"
-#include <wx/dcclient.h>
-#include "slic3r/GUI/GUI_Utils.hpp"
-#include <wx/toplevel.h>
-#include <wx/scrolwin.h>
-#include "slic3r/GUI/Widgets/AMSItem.hpp"
-#include <wx/chartype.h>
-#include "slic3r/GUI/Widgets/Button.hpp"
-#include <utility>
-#include <chrono>
-#include <optional>
-#include <wx/timer.h>
-#include "libslic3r/Utils.hpp"
-#include <unordered_set>
-#include <vector>
-#include <set>
-#include <sstream>
-#include <ios>
-#include <iomanip>
-#include "slic3r/GUI/DeviceCore/DevConfigUtil.h"
-#include <limits>
-#include <memory>
 
 namespace Slic3r { namespace GUI {
 

src/slic3r/GUI/AMSDryControl.hpp

@@ -9,25 +9,7 @@
 #include "slic3r/GUI/I18N.hpp" // Orca: explicit _L() catalog include
 
 #include <chrono>
-#include <memory>
-#include "libslic3r/PresetBundle.hpp"
-#include <map>
 #include <optional>
-#include <wx/panel.h>
-#include <wx/string.h>
-#include <string>
-#include <wx/event.h>
-#include <vector>
-#include "slic3r/GUI/GUI_Utils.hpp"
-#include <wx/gdicmn.h>
-#include <wx/simplebook.h>
-#include "slic3r/GUI/Widgets/ComboBox.hpp"
-#include "slic3r/GUI/Widgets/Button.hpp"
-#include <wx/timer.h>
-#include "slic3r/GUI/DeviceCore/DevDefs.h"
-#include <unordered_map>
-#include <wx/colour.h>
-#include <wx/scrolwin.h>
 
 
 //Previous defintions

src/slic3r/GUI/AMSMaterialsSetting.cpp

@@ -8,49 +8,8 @@
 #include "I18N.hpp"
 #include <algorithm>
 #include <boost/log/trivial.hpp>
-#include <string>
-#include <sstream>
-#include <ios>
-#include <iomanip>
-#include <wx/anybutton.h>
-#include <wx/checklst.h>
-#include "slic3r/GUI/GUI_Utils.hpp"
-#include "slic3r/GUI/Widgets/Button.hpp"
-#include "slic3r/GUI/Widgets/Label.hpp"
-#include <utility>
-#include "slic3r/GUI/wxExtensions.hpp"
-#include "slic3r/GUI/Widgets/HyperLink.hpp"
-#include <cstdlib>
-#include <cstdio>
-#include "slic3r/GUI/DeviceCore/DevDefs.h"
-#include "libslic3r/calib.hpp"
-#include "libslic3r/Config.hpp"
-#include <vector>
-#include <unordered_map>
-#include <wx/arrstr.h>
-#include <set>
-#include "slic3r/GUI/DeviceCore/DevConfigUtil.h"
-#include <cstddef>
-#include <climits>
-#include "libslic3r/PrintConfig.hpp"
-#include <cmath>
-#include "slic3r/GUI/Widgets/PopupWindow.hpp"
-#include "slic3r/GUI/Widgets/StaticBox.hpp"
 #include <wx/colordlg.h>
-#include <wx/dcclient.h>
-#include <wx/dc.h>
-#include <wx/colour.h>
-#include <wx/colourdata.h>
 #include <wx/dcgraph.h>
-#include <wx/event.h>
-#include <wx/gdicmn.h>
-#include <wx/toplevel.h>
-#include <wx/panel.h>
-#include <wx/textctrl.h>
-#include <wx/string.h>
-#include <wx/valtext.h>
-#include <wx/sizer.h>
-#include <wx/peninfobase.h>
 #include "CalibUtils.hpp"
 #include "../Utils/ColorSpaceConvert.hpp"
 #include "EncodedFilament.hpp"

src/slic3r/GUI/AMSMaterialsSetting.hpp

@@ -16,22 +16,6 @@
 #include "Widgets/TextInput.hpp"
 #include "Widgets/HyperLink.hpp"
 #include "slic3r/Utils/CalibUtils.hpp"
-#include <wx/anybutton.h>
-#include <wx/colour.h>
-#include <vector>
-#include <wx/checklst.h>
-#include <wx/gdicmn.h>
-#include <wx/event.h>
-#include <wx/dc.h>
-#include "slic3r/GUI/Widgets/PopupWindow.hpp"
-#include "slic3r/GUI/Widgets/StaticBox.hpp"
-#include <wx/sizer.h>
-#include <wx/string.h>
-#include <string>
-#include "libslic3r/calib.hpp"
-#include "slic3r/GUI/Widgets/StateColor.hpp"
-#include <wx/panel.h>
-#include <map>
 
 #define AMS_MATERIALS_SETTING_DEF_COLOUR wxColour(255, 255, 255)
 #define AMS_MATERIALS_SETTING_GREY900 wxColour(38, 46, 48)

src/slic3r/GUI/AMSSetting.cpp

@@ -2,7 +2,6 @@
 #include "GUI_App.hpp"
 #include "I18N.hpp"
 
-#include "libslic3r_version.h"
 #include "slic3r/GUI/DeviceCore/DevExtruderSystem.h"
 #include "slic3r/GUI/DeviceCore/DevFilaSystem.h"
 #include "slic3r/GUI/DeviceCore/DevManager.h"
@@ -12,19 +11,6 @@
 #include "slic3r/GUI/Widgets/AnimaController.hpp"
 #include "slic3r/GUI/Widgets/Label.hpp"
 #include "slic3r/GUI/Widgets/ComboBox.hpp"
-#include <wx/anybutton.h>
-#include <wx/checklst.h>
-#include <wx/gdicmn.h>
-#include "slic3r/GUI/GUI_Utils.hpp"
-#include <wx/string.h>
-#include <wx/panel.h>
-#include "slic3r/GUI/Widgets/CheckBox.hpp"
-#include <wx/tglbtn.h>
-#include "slic3r/GUI/wxExtensions.hpp"
-#include "slic3r/GUI/DeviceCore/DevFilaAmsSetting.h"
-#include "slic3r/GUI/DeviceCore/DevConfigUtil.h"
-#include <wx/event.h>
-#include <vector>
 
 namespace Slic3r { namespace GUI {
 

src/slic3r/GUI/AMSSetting.hpp

@@ -12,16 +12,6 @@
 #include "Widgets/CheckBox.hpp"
 
 #include "slic3r/GUI/DeviceCore/DevFilaAmsSetting.h"
-#include <wx/anybutton.h>
-#include <wx/checklst.h>
-#include <wx/gdicmn.h>
-#include <wx/dialog.h>
-#include <string>
-#include <wx/event.h>
-#include <wx/panel.h>
-#include <wx/sizer.h>
-#include <memory>
-#include <unordered_map>
 
 #define AMS_SETTING_DEF_COLOUR wxColour(255, 255, 255)
 #define AMS_SETTING_GREY800 wxColour(50, 58, 61)

src/slic3r/GUI/AVVideoDecoder.cpp

@@ -1,14 +1,6 @@
 #include "AVVideoDecoder.hpp"
 
-#include <algorithm>
 #include <assert.h>
-#include "slic3r/GUI/Printer/BambuTunnel.h"
-#include <cstdio>
-#include <cstring>
-#include <cstddef>
-#include <wx/image.h>
-#include <wx/gdicmn.h>
-#include <cstdint>
 
 extern "C"
 {

src/slic3r/GUI/AVVideoDecoder.hpp

@@ -2,7 +2,6 @@
 #define AVVIDEODECODER_HPP
 
 #include "Printer/BambuTunnel.h"
-#include <cstdint>
 
 extern "C" {
     #include <libavcodec/avcodec.h>

src/slic3r/GUI/AboutDialog.cpp

@@ -9,26 +9,8 @@
 #include "MainFrame.hpp"
 #include "format.hpp"
 #include "Widgets/Button.hpp"
-#include "libslic3r_version.h"
 
-#include "slic3r/GUI/GUI_Utils.hpp"
-#include "libslic3r/libslic3r.h"
-#include "slic3r/GUI/wxExtensions.hpp"
-#include "slic3r/GUI/Widgets/Label.hpp"
-#include <vector>
 #include <wx/clipbrd.h>
-#include <wx/panel.h>
-#include <wx/wx.h>
-#include <wx/gdicmn.h>
-#include <wx/event.h>
-#include <wx/dcclient.h>
-#include <wx/dialog.h>
-#include <wx/toplevel.h>
-#include <wx/sizer.h>
-#include <wx/html/htmlwin.h>
-#include <wx/string.h>
-#include <wx/colour.h>
-#include <wx/dataobj.h>
 
 namespace Slic3r {
 namespace GUI {

src/slic3r/GUI/AboutDialog.hpp

@@ -1,11 +1,6 @@
 #ifndef slic3r_GUI_AboutDialog_hpp_
 #define slic3r_GUI_AboutDialog_hpp_
 
-#include <wx/panel.h>
-#include <wx/event.h>
-#include <string>
-#include <vector>
-#include <wx/string.h>
 #include <wx/wx.h>
 #include <wx/intl.h>
 #include <wx/html/htmlwin.h>

src/slic3r/GUI/ActionRegistry.cpp

@@ -12,19 +12,10 @@
 #include "Tab.hpp"
 #include "slic3r/plugin/PluginManager.hpp"
 
-#include <cassert>
-#include <boost/filesystem/operations.hpp>
 #include <libslic3r/AppConfig.hpp>
 #include <libslic3r/Config.hpp>
-#include "slic3r/plugin/PluginDescriptor.hpp"
-#include <memory>
-#include "libslic3r/Preset.hpp"
-#include "slic3r/GUI/PartPlate.hpp"
 #include <slic3r/plugin/PythonPluginInterface.hpp>
 
-#include <vector>
-#include <utility>
-#include <wx/app.h>
 #include <wx/thread.h>
 
 #include <boost/filesystem.hpp>

src/slic3r/GUI/AmsMappingPopup.cpp

@@ -11,36 +11,6 @@
 #include "MainFrame.hpp"
 #include "format.hpp"
 #include "Widgets/ProgressDialog.hpp"
-#include <wx/event.h>
-#include <wx/colour.h>
-#include <string>
-#include <wx/panel.h>
-#include <wx/gdicmn.h>
-#include <vector>
-#include <boost/log/trivial.hpp>
-#include <wx/dcclient.h>
-#include <cstddef>
-#include <wx/arrstr.h>
-#include "slic3r/GUI/DeviceManager.hpp"
-#include <math.h>
-#include <cmath>
-#include "slic3r/GUI/Widgets/StateColor.hpp"
-#include <wx/peninfobase.h>
-#include <wx/string.h>
-#include "slic3r/GUI/Widgets/PopupWindow.hpp"
-#include <wx/popupwin.h>
-#include <wx/anybutton.h>
-#include <wx/sizer.h>
-#include <map>
-#include "slic3r/GUI/DeviceCore/DevUtil.h"
-#include <cstdlib>
-#include "slic3r/GUI/DeviceCore/DevDefs.h"
-#include "slic3r/GUI/wxExtensions.hpp"
-#include "slic3r/GUI/GUI_Utils.hpp"
-#include "slic3r/GUI/Widgets/SwitchButton.hpp"
-#include <utility>
-#include "slic3r/GUI/Widgets/AMSItem.hpp"
-#include <unordered_map>
 #include <wx/tooltip.h>
 #include "Widgets/RoundedRectangle.hpp"
 #include "Widgets/StaticBox.hpp"
@@ -53,9 +23,6 @@
 #include <miniz.h>
 #include <algorithm>
 #include <optional>
-#include <wx/wx.h>
-#include <wx/toplevel.h>
-#include <wx/wrapsizer.h>
 #include "Plater.hpp"
 #include "BitmapCache.hpp"
 #include "BindDialog.hpp"

src/slic3r/GUI/AmsMappingPopup.hpp

@@ -1,16 +1,6 @@
 #ifndef slic3r_GUI_AmsMappingPopup_hpp_
 #define slic3r_GUI_AmsMappingPopup_hpp_
 
-#include <string>
-#include <vector>
-#include <wx/event.h>
-#include <wx/dc.h>
-#include <optional>
-#include "libslic3r/ProjectTask.hpp"
-#include "slic3r/GUI/DeviceCore/DevDefs.h"
-#include <map>
-#include <functional>
-#include <memory>
 #include <wx/wx.h>
 #include <wx/intl.h>
 #include <wx/collpane.h>

src/slic3r/GUI/AmsMappingPopupUpdate.cpp

@@ -21,17 +21,6 @@
 #include "Widgets/RoundedRectangle.hpp"
 #include "Widgets/StaticBox.hpp"
 
-#include <list>
-#include <vector>
-#include "slic3r/GUI/DeviceCore/DevDefs.h"
-#include <boost/log/trivial.hpp>
-#include <cstddef>
-#include <string>
-#include <cstdlib>
-#include <exception>
-#include <map>
-#include "libslic3r/Config.hpp"
-#include <wx/event.h>
 #include <wx/progdlg.h>
 #include <wx/clipbrd.h>
 #include <wx/dcgraph.h>
@@ -39,7 +28,6 @@
 #include <miniz.h>
 #include <algorithm>
 #include <optional>
-#include <wx/wx.h>
 #include "Plater.hpp"
 #include "BitmapCache.hpp"
 

src/slic3r/GUI/AmsWidgets.cpp

@@ -1,10 +1,7 @@
 #include "AmsWidgets.hpp"
-#include <map>
-#include <string>
 #include <wx/button.h>
 #include <wx/sizer.h>
 #include <wx/dataview.h>
-#include <wx/variant.h>
 
 #include "GUI_App.hpp"
 #include "GUI_ObjectList.hpp"

src/slic3r/GUI/AmsWidgets.hpp

@@ -2,7 +2,6 @@
 #define slic3r_AmsWidgets_hpp_
 
 
-#include <wx/arrstr.h>
 #include <wx/notebook.h>
 #include <wx/scrolwin.h>
 #include <wx/sizer.h>
@@ -11,7 +10,6 @@
 #include <wx/treectrl.h>
 #include <wx/imaglist.h>
 #include <wx/artprov.h>
-#include <wx/variant.h>
 #include <wx/xrc/xmlres.h>
 #include <wx/string.h>
 #include <wx/stattext.h>

src/slic3r/GUI/AuiPaneLayout.cpp

@@ -1,6 +1,4 @@
 #include "AuiPaneLayout.hpp"
-#include <string>
-#include <cstddef>
 
 namespace Slic3r { namespace GUI {
 

src/slic3r/GUI/Auxiliary.cpp

@@ -4,53 +4,17 @@
 #include "libslic3r/Model.hpp"
 #include "libslic3r/Format/bbs_3mf.hpp"
 
-#include <vector>
-#include <string>
-#include <memory>
-#include <boost/filesystem/path.hpp>
-#include "slic3r/GUI/Project.hpp"
-#include "slic3r/GUI/Widgets/StateColor.hpp"
-#include "slic3r/GUI/Field.hpp"
-#include "slic3r/GUI/Widgets/TextInput.hpp"
-#include "libslic3r/Preset.hpp"
-#include <cstddef>
-#include <cstring>
-#include "slic3r/GUI/GUI.hpp"
-#include <boost/filesystem/operations.hpp>
-#include "slic3r/GUI/GUI_Utils.hpp"
-#include <utility>
-#include "slic3r/GUI/Widgets/AMSItem.hpp"
-#include <iterator>
-#include "slic3r/GUI/Widgets/Button.hpp"
-#include <wx/anybutton.h>
-#include "slic3r/GUI/Tabbook.hpp"
-#include <ctime>
-#include <map>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
-#include "slic3r/GUI/Widgets/ComboBox.hpp"
 #include <wx/app.h>
-#include <wx/bookctrl.h>
 #include <wx/button.h>
-#include <wx/event.h>
-#include <wx/gdicmn.h>
-#include <wx/panel.h>
-#include <wx/image.h>
-#include <wx/dcclient.h>
-#include <wx/notebook.h>
-#include <wx/chartype.h>
 #include <wx/scrolwin.h>
 #include <wx/sizer.h>
 
 #include <wx/bmpcbox.h>
 #include <wx/bmpbuttn.h>
-#include <wx/string.h>
-#include <wx/stattext.h>
-#include <wx/textctrl.h>
 #include <wx/treectrl.h>
 #include <wx/imaglist.h>
 #include <wx/settings.h>
 #include <wx/filedlg.h>
-#include <wx/wrapsizer.h>
 #include <wx/wupdlock.h>
 #include <wx/dataview.h>
 #include <wx/tokenzr.h>

src/slic3r/GUI/Auxiliary.hpp

@@ -2,16 +2,6 @@
 #define slic3r_Auxiliary_hpp_
 
 #include "Tabbook.hpp"
-#include <array>
-#include "slic3r/GUI/Widgets/TextInput.hpp"
-#include <boost/filesystem/path.hpp>
-#include <wx/bookctrl.h>
-#include <wx/event.h>
-#include <wx/dynarray.h>
-#include "slic3r/GUI/Widgets/Button.hpp"
-#include "slic3r/GUI/Widgets/ComboBox.hpp"
-#include <string>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
 #include <wx/notebook.h>
 #include <wx/scrolwin.h>
 #include <wx/sizer.h>
@@ -20,7 +10,6 @@
 #include <wx/treectrl.h>
 #include <wx/imaglist.h>
 #include <wx/artprov.h>
-#include <wx/wrapsizer.h>
 #include <wx/xrc/xmlres.h>
 #include <wx/string.h>
 #include <wx/stattext.h>

src/slic3r/GUI/AuxiliaryDataViewModel.cpp

@@ -4,22 +4,9 @@
 #include "libslic3r/Format/bbs_3mf.hpp"
 
 
-#include <array>
-#include <boost/filesystem/path.hpp>
-#include <boost/filesystem/operations.hpp>
-#include <boost/filesystem/directory.hpp>
 #include <boost/log/trivial.hpp>
 
-#include <wx/filefn.h>
-#include <wx/dataview.h>
-#include <map>
-#include <wx/debug.h>
-#include <cstddef>
-#include <wx/arrstr.h>
 #include <wx/log.h>
-#include <wx/string.h>
-#include <wx/variant.h>
-#include <wx/types.h>
 
 const static std::array<wxString, 4> s_default_folders = {
     _L("Model Pictures"),

src/slic3r/GUI/AuxiliaryDataViewModel.hpp

@@ -9,12 +9,6 @@
 #include "I18N.hpp"
 
 #include <boost/filesystem.hpp>
-#include <wx/dynarray.h>
-#include <boost/filesystem/path.hpp>
-#include <cstddef>
-#include <wx/string.h>
-#include <wx/arrstr.h>
-#include <wx/variant.h>
 
 class AuxiliaryModelNode;
 WX_DEFINE_ARRAY_PTR(AuxiliaryModelNode*, AuxiliaryModelNodePtrArray);

src/slic3r/GUI/AuxiliaryDialog.cpp

@@ -5,11 +5,6 @@
 #include "libslic3r/Utils.hpp"
 
 #include <boost/property_tree/ptree.hpp>
-#include "slic3r/GUI/GUI_Utils.hpp"
-#include <wx/wx.h>
-#include <wx/gdicmn.h>
-#include <wx/dialog.h>
-#include <wx/toplevel.h>
 
 namespace pt = boost::property_tree;
 typedef pt::ptree JSON;

src/slic3r/GUI/BBLStatusBar.cpp

@@ -1,11 +1,5 @@
 #include "BBLStatusBar.hpp"
 
-#include <wx/panel.h>
-#include <wx/event.h>
-#include <wx/gdicmn.h>
-#include <wx/sizer.h>
-#include <wx/stattext.h>
-#include <string>
 #include <wx/timer.h>
 #include <wx/gauge.h>
 #include <wx/button.h>

src/slic3r/GUI/BBLStatusBarBind.cpp

@@ -1,10 +1,5 @@
 #include "BBLStatusBarBind.hpp"
 
-#include <wx/panel.h>
-#include <wx/event.h>
-#include <wx/sizer.h>
-#include "slic3r/GUI/Widgets/Label.hpp"
-#include <string>
 #include <wx/timer.h>
 #include <wx/gauge.h>
 #include <wx/button.h>

src/slic3r/GUI/BBLStatusBarBind.hpp

@@ -2,7 +2,6 @@
 #define BBLStatusBarBind_HPP
 
 #include <wx/panel.h>
-#include <wx/sizer.h>
 #include <wx/stattext.h>
 #include <wx/simplebook.h>
 

src/slic3r/GUI/BBLStatusBarPrint.cpp

@@ -1,15 +1,5 @@
 #include "BBLStatusBarPrint.hpp"
 
-#include <wx/event.h>
-#include <wx/panel.h>
-#include <wx/sizer.h>
-#include <wx/string.h>
-#include "slic3r/GUI/Widgets/Label.hpp"
-#include "slic3r/GUI/Widgets/StateColor.hpp"
-#include <utility>
-#include "slic3r/GUI/Widgets/Button.hpp"
-#include "slic3r/GUI/wxExtensions.hpp"
-#include <cstddef>
 #include <wx/timer.h>
 #include <wx/gauge.h>
 #include <wx/button.h>

src/slic3r/GUI/BBLStatusBarPrint.hpp

@@ -1,9 +1,7 @@
 #ifndef BBLStatusBarPrint_HPP
 #define BBLStatusBarPrint_HPP
 
-#include <wx/event.h>
 #include <wx/panel.h>
-#include <wx/sizer.h>
 #include <wx/stattext.h>
 
 #include <memory>

src/slic3r/GUI/BBLStatusBarSend.cpp

@@ -1,13 +1,5 @@
 #include "BBLStatusBarSend.hpp"
 
-#include <wx/event.h>
-#include <wx/panel.h>
-#include <wx/sizer.h>
-#include <wx/string.h>
-#include "slic3r/GUI/Widgets/Label.hpp"
-#include "slic3r/GUI/Widgets/Button.hpp"
-#include "slic3r/GUI/wxExtensions.hpp"
-#include <cstddef>
 #include <wx/timer.h>
 #include <wx/gauge.h>
 #include <wx/button.h>

src/slic3r/GUI/BBLStatusBarSend.hpp

@@ -1,9 +1,7 @@
 #ifndef BBLSTATUSBARSEND_HPP
 #define BBLSTATUSBARSEND_HPP
 
-#include <wx/event.h>
 #include <wx/panel.h>
-#include <wx/sizer.h>
 #include <wx/stattext.h>
 
 #include <memory>

src/slic3r/GUI/BBLTopbar.cpp

@@ -2,19 +2,7 @@
 #include "wx/artprov.h"
 #include "wx/aui/framemanager.h"
 #include "wx/display.h"
-#include <wx/gdicmn.h>
-#include <wx/event.h>
-#include <wx/dcbuffer.h>
-#include <wx/dc.h>
-#include <wx/aui/auibar.h>
-#include "slic3r/GUI/Widgets/StateColor.hpp"
-#include <wx/settings.h>
-#include "slic3r/GUI/Widgets/Label.hpp"
-#include <wx/image.h>
-#include <wx/string.h>
-#include <cstddef>
 #include <wx/utils.h>
-#include <wx/window.h>
 #include "I18N.hpp"
 #include "GUI_App.hpp"
 #include "GUI.hpp"

src/slic3r/GUI/BBLTopbar.hpp

@@ -7,9 +7,6 @@
 #include "DeviceManager.hpp"
 
 #include <wx/control.h>
-#include <wx/string.h>
-#include <wx/gdicmn.h>
-#include <wx/event.h>
 
 using namespace Slic3r::GUI;
 

src/slic3r/GUI/BackgroundSlicingProcess.cpp

@@ -4,26 +4,8 @@
 #include "MainFrame.hpp"
 #include "format.hpp"
 
-#include <cstddef>
-#include <exception>
-#include "libslic3r/Config.hpp"
-#include <cstdint>
-#include <functional>
 #include <libslic3r/Exception.hpp>
-#include <utility>
-#include <string>
-#include <vector>
-#include <new>
-#include "libslic3r/GCode/ThumbnailData.hpp"
-#include "libslic3r/PrintConfig.hpp"
-#include "libslic3r/Zipper.hpp"
-#include <mutex>
-#include "libslic3r/PrintBase.hpp"
-#include <ostream>
-#include <memory>
-#include "libslic3r/Polygon.hpp"
 #include <wx/app.h>
-#include <wx/event.h>
 #include <wx/panel.h>
 #include <wx/stdpaths.h>
 
@@ -54,7 +36,6 @@
 #include "I18N.hpp"
 // #include "RemovableDriveManager.hpp"
 
-#include "libslic3r_version.h"
 #include "slic3r/GUI/Plater.hpp"
 
 namespace Slic3r {

src/slic3r/GUI/BackgroundSlicingProcess.hpp

@@ -1,21 +1,12 @@
 #ifndef slic3r_GUI_BackgroundSlicingProcess_hpp_
 #define slic3r_GUI_BackgroundSlicingProcess_hpp_
 
-#include <exception>
-#include <cassert>
-#include <cstddef>
-#include "libslic3r/Config.hpp"
-#include "libslic3r/Polygon.hpp"
-#include <memory>
-#include <functional>
 #include <string>
 #include <condition_variable>
 #include <mutex>
 
 #include <boost/thread.hpp>
 
-#include <utility>
-#include <vector>
 #include <wx/event.h>
 
 #include "libslic3r/PrintBase.hpp"

src/slic3r/GUI/BaseTransparentDPIFrame.cpp

@@ -1,14 +1,7 @@
 #include "BaseTransparentDPIFrame.hpp"
 
-#include "slic3r/GUI/GUI_Utils.hpp"
-#include "slic3r/GUI/Widgets/StateColor.hpp"
-#include "slic3r/GUI/wxExtensions.hpp"
-#include "slic3r/GUI/Widgets/Label.hpp"
-#include "slic3r/GUI/Event.hpp"
 #include <thread>
-#include <wx/dcclient.h>
 #include <wx/event.h>
-#include <wx/gdicmn.h>
 #include <wx/sizer.h>
 #include <wx/slider.h>
 #include <wx/dcmemory.h>
@@ -21,9 +14,6 @@
 #include "Widgets/TextInput.hpp"
 #include "Notebook.hpp"
 #include <chrono>
-#include <wx/string.h>
-#include <wx/toplevel.h>
-#include <wx/timer.h>
 #include "Widgets/Button.hpp"
 #include "Widgets/CheckBox.hpp"
 #include "CapsuleButton.hpp"

src/slic3r/GUI/BaseTransparentDPIFrame.hpp

@@ -2,13 +2,9 @@
 #define _BaseTransparentDPIFrame_H_
 
 #include <future>
-#include "slic3r/GUI/Event.hpp"
 #include <thread>
 #include "GUI_App.hpp"
 #include "GUI_Utils.hpp"
-#include <wx/gdicmn.h>
-#include <wx/string.h>
-#include <wx/sizer.h>
 #include <wx/timer.h>
 
 class Button;

src/slic3r/GUI/BedShapeDialog.cpp

@@ -2,30 +2,6 @@
 #include "GUI_App.hpp"
 #include "OptionsGroup.hpp"
 
-#include "libslic3r/Point.hpp"
-#include <string>
-#include <cassert>
-#include "libslic3r/Config.hpp"
-#include <utility>
-#include <wx/string.h>
-#include "libslic3r/BuildVolume.hpp"
-#include "slic3r/GUI/Field.hpp"
-#include <wx/event.h>
-#include <wx/gdicmn.h>
-#include "slic3r/GUI/Widgets/Button.hpp"
-#include <wx/panel.h>
-#include <wx/bookctrl.h>
-#include "slic3r/GUI/2DBed.hpp"
-#include <memory>
-#include <boost/filesystem/operations.hpp>
-#include <boost/any.hpp>
-#include <exception>
-#include "libslic3r/libslic3r.h"
-#include <vector>
-#include <cmath>
-#include <wx/filedlg.h>
-#include "slic3r/GUI/GUI.hpp"
-#include <wx/busycursor.h>
 #include <wx/wx.h>
 #include <wx/numformatter.h>
 #include <wx/sizer.h>

src/slic3r/GUI/BedShapeDialog.hpp

@@ -11,17 +11,8 @@
 
 #include "Widgets/ComboBox.hpp"
 
-#include <memory>
-#include "libslic3r/Point.hpp"
-#include <string>
-#include <vector>
-#include "libslic3r/Config.hpp"
 #include <wx/dialog.h>
-#include <wx/panel.h>
-#include <wx/event.h>
-#include <wx/gdicmn.h>
 #include <wx/simplebook.h> // ORCA
-#include <wx/string.h>
 
 namespace Slic3r {
 namespace GUI {

src/slic3r/GUI/BindDialog.cpp

@@ -1,44 +1,10 @@
 #include "BindDialog.hpp"
 #include "GUI_App.hpp"
 
-#include "slic3r/GUI/GUI_Utils.hpp"
-#include <wx/intl.h>
-#include <wx/gdicmn.h>
-#include <wx/toplevel.h>
-#include <wx/panel.h>
-#include <wx/simplebook.h>
-#include "slic3r/GUI/Widgets/Label.hpp"
-#include "slic3r/GUI/Widgets/HyperLink.hpp"
-#include "slic3r/GUI/Widgets/TextInput.hpp"
-#include <wx/string.h>
-#include <wx/textctrl.h>
-#include <wx/event.h>
-#include "slic3r/GUI/Widgets/Button.hpp"
-#include <cstddef>
-#include <wx/utils.h>
-#include "slic3r/GUI/MsgDialog.hpp"
-#include "slic3r/GUI/Widgets/StaticBox.hpp"
-#include "slic3r/GUI/wxExtensions.hpp"
-#include <wx/wrapsizer.h>
-#include "slic3r/GUI/Widgets/CheckBox.hpp"
-#include "slic3r/GUI/ReleaseNote.hpp"
-#include <wx/tglbtn.h>
-#include <memory>
-#include "slic3r/GUI/BBLStatusBarBind.hpp"
-#include "slic3r/GUI/Jobs/BindJob.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
-#include "slic3r/GUI/DeviceCore/DevDefs.h"
-#include "slic3r/GUI/Jobs/Worker.hpp"
-#include <utility>
-#include "slic3r/GUI/GUI.hpp"
-#include <wx/image.h>
-#include <wx/stattext.h>
 #include <wx/wx.h>
 #include <wx/mstream.h>
 #include <wx/sizer.h>
 #include <wx/statbox.h>
-#include "bambu_networking.hpp"
-#include "Http.hpp"
 #include "wx/evtloop.h"
 #include <wx/tokenzr.h>
 #include <wx/richmsgdlg.h>

src/slic3r/GUI/BindDialog.hpp

@@ -3,16 +3,9 @@
 
 #include "I18N.hpp"
 
-#include <cstddef>
-#include "slic3r/GUI/Widgets/Label.hpp"
-#include <memory>
-#include <wx/event.h>
-#include "slic3r/GUI/Widgets/StaticBox.hpp"
 #include <wx/font.h>
 #include <wx/colour.h>
-#include <wx/panel.h>
 #include <wx/settings.h>
-#include <wx/simplebook.h>
 #include <wx/string.h>
 #include <wx/sizer.h>
 #include <wx/stattext.h>

src/slic3r/GUI/BitmapCache.cpp

@@ -5,24 +5,8 @@
 #include "GUI.hpp"
 #include "GUI_Utils.hpp"
 
-#include <algorithm>
-#include <boost/algorithm/string/replace.hpp>
 #include <boost/nowide/cstdio.hpp>
 #include <boost/filesystem.hpp>
-#include <utility>
-#include <string>
-#include <wx/image.h>
-#include <cstddef>
-#include <wx/dcmemory.h>
-#include <wx/gdicmn.h>
-#include <map>
-#include <cstdio>
-#include <cstdlib>
-#include "libslic3r/LocalesUtils.hpp"
-#include <cstring>
-#include <vector>
-#include <cstdint>
-#include <imgui.h>
 
 #ifdef __WXGTK2__
     // Broken alpha workaround

src/slic3r/GUI/BitmapCache.hpp

@@ -1,12 +1,9 @@
 #ifndef SLIC3R_GUI_BITMAP_CACHE_HPP
 #define SLIC3R_GUI_BITMAP_CACHE_HPP
 
-#include <cstddef>
 #include <map>
-#include <string>
 #include <vector>
 
-#include <wx/colour.h>
 #include <wx/wxprec.h>
 #ifndef WX_PRECOMP
     #include <wx/wx.h>

src/slic3r/GUI/BitmapComboBox.cpp

@@ -5,8 +5,6 @@
 #include <string>
 #include <boost/algorithm/string.hpp>
 
-#include <wx/bmpcbox.h>
-#include <wx/gdicmn.h>
 #include <wx/sizer.h>
 #include <wx/stattext.h>
 #include <wx/textctrl.h>

src/slic3r/GUI/BitmapComboBox.hpp

@@ -1,10 +1,8 @@
 #ifndef slic3r_BitmapComboBox_hpp_
 #define slic3r_BitmapComboBox_hpp_
 
-#include <cstddef>
 #include <wx/bmpcbox.h>
 #include <wx/gdicmn.h>
-#include <wx/string.h>
 
 #include "GUI_Utils.hpp"
 

src/slic3r/GUI/BonjourDialog.cpp

@@ -2,27 +2,15 @@
 
 #include "BonjourDialog.hpp"
 
-#include "libslic3r/Config.hpp"
-#include <memory>
-#include <boost/asio/ip/address.hpp>
-#include <cstddef>
 #include <set>
 #include <mutex>
 
 #include <boost/nowide/convert.hpp>
 
-#include <wx/event.h>
-#include <utility>
-#include <wx/gdicmn.h>
-#include <wx/dialog.h>
-#include "slic3r/GUI/Widgets/Label.hpp"
-#include <wx/listbase.h>
-#include <vector>
 #include <wx/sizer.h>
 #include <wx/listctrl.h>
 #include <wx/stattext.h>
 #include <wx/timer.h>
-#include <wx/toplevel.h>
 #include <wx/wupdlock.h>
 
 #include "slic3r/GUI/GUI.hpp"

src/slic3r/GUI/BonjourDialog.hpp

@@ -2,14 +2,11 @@
 #define slic3r_BonjourDialog_hpp_
 
 #include <cstddef>
-#include "libslic3r/Config.hpp"
 #include <memory>
 
 #include <boost/asio/ip/address.hpp>
 
-#include <vector>
 #include <wx/dialog.h>
-#include <wx/event.h>
 #include <wx/string.h>
 
 #include "libslic3r/PrintConfig.hpp"

src/slic3r/GUI/CAD/DesignCanvas.cpp

@@ -15,33 +15,14 @@
 #include "libslic3r/Config.hpp"
 #include <boost/algorithm/string/predicate.hpp>
 #include <algorithm>
-#include <cstdio>
 #include <cstdlib>
 
-#include <wx/colour.h>
-#include <wx/event.h>
-#include <wx/gdicmn.h>
-#include "libslic3r/CAD/SketchEngine.hpp"
-#include <vector>
-#include <memory>
-#include <string>
-#include <functional>
-#include "libslic3r/Color.hpp"
-#include "slic3r/GUI/CAD/DesignSketchTool.hpp"
-#include "libslic3r/Point.hpp"
-#include <utility>
-#include "libslic3r/CAD/CadDocument.hpp"
-#include "libslic3r/BoundingBox.hpp"
 #include <wx/glcanvas.h>
-#include <wx/panel.h>
 #include <wx/stopwatch.h>   // wxGetLocalTimeMillis: the right-click vs right-hold budget
 #include <wx/sizer.h>
 #include <wx/frame.h>
 #include <wx/stattext.h>
-#include <wx/string.h>
-#include <wx/time.h>
 #include <wx/toplevel.h>
-#include <wx/window.h>
 
 namespace Slic3r {
 namespace GUI {

src/slic3r/GUI/CAD/DesignCanvas.hpp

@@ -1,20 +1,12 @@
 #ifndef slic3r_DesignCanvas_hpp_
 #define slic3r_DesignCanvas_hpp_
 
-#include <vector>
-#include "libslic3r/Point.hpp"
-#include "libslic3r/CAD/CadDocument.hpp"
-#include "libslic3r/Color.hpp"
-#include <utility>
-#include <wx/colour.h>
-#include <wx/event.h>
 #include <wx/panel.h>
 #include <wx/popupwin.h>
 
 #include <functional>
 #include <memory>
 #include <string>
-#include <wx/string.h>
 
 #include "slic3r/GUI/3DBed.hpp"
 #include "slic3r/GUI/Camera.hpp"

src/slic3r/GUI/CAD/DesignPanel.cpp

@@ -1,5 +1,4 @@
 #include "slic3r/GUI/CAD/DesignPanel.hpp"
-#include "libslic3r_version.h"
 #include "slic3r/GUI/CAD/DesignCanvas.hpp"
 #include "slic3r/GUI/CAD/DesignSketchTool.hpp"
 #include "slic3r/GUI/CAD/DesignOffer.hpp"                // generated offer table — see scripts/CAD/tool_atlas.json
@@ -8,11 +7,6 @@
 #include "libslic3r/Format/OBJ.hpp"
 #include "libslic3r/Format/bbs_3mf.hpp"   // put_other_changes: mark the project dirty outside the undo stack
 
-#include <TopoDS_Face.hxx>
-#include <TopoDS_Edge.hxx>
-#include <TopoDS_Shape.hxx>
-#include <Eigen/Geometry>
-#include <TopAbs_Orientation.hxx>
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/log/trivial.hpp>          // the offer/atlas join check reports on the log
@@ -20,46 +14,15 @@
 
 #include <cassert>
 #include <cstdarg>                        // offer_trace: diagnostic row dump for the offer ladder
-#include <cstddef>
-#include <cstdint>
-#include <cstdio>
-#include "libslic3r/CAD/SketchEngine.hpp"
-#include "libslic3r/CAD/CadDocument.hpp"
-#include "libslic3r/Point.hpp"
-#include <cstdlib>
-#include <exception>
-#include "libslic3r/BoundingBox.hpp"
-#include "libslic3r/Color.hpp"
-#include "libslic3r/CAD/SketchSolver.hpp"
 #include <map>
-#include <math.h>
 #include <set>
-#include <wx/accel.h>
-#include <wx/event.h>
-#include <wx/gdicmn.h>
-#include <wx/chartype.h>
-#include <vector>
-#include <wx/scrolwin.h>
-#include <wx/anybutton.h>
-#include "slic3r/GUI/Widgets/StateColor.hpp"
-#include <utility>
-#include <wx/listbase.h>
-#include <wx/busycursor.h>
-#include <wx/colourdata.h>
-#include "slic3r/GUI/CAD/DesignInteraction.hpp"
 #include <wx/sizer.h>
 #include <wx/button.h>
-#include <wx/spinbutt.h>
 #include <wx/stattext.h>
 #include <wx/checkbox.h>
 #include <wx/checklst.h>
 #include <wx/spinctrl.h>
 #include <wx/listctrl.h>
-#include <wx/string.h>
-#include <wx/treebase.h>
-#include <wx/tglbtn.h>
-#include <wx/textctrl.h>
-#include <wx/translation.h>
 #include <wx/treectrl.h>
 #include <wx/imaglist.h>
 #include <wx/statline.h>
@@ -72,7 +35,6 @@
 #include <wx/colordlg.h>
 #include <wx/menu.h>
 #include <wx/progdlg.h>
-#include <wx/unichar.h>
 #include <wx/utils.h>    // wxWindowDisabler, wxMilliSleep
 #include <wx/msgdlg.h>   // wxMessageBox
 
@@ -83,7 +45,6 @@
 #include <algorithm>
 #include <thread>
 #include <atomic>
-#include <wx/window.h>
 
 #include "slic3r/GUI/wxExtensions.hpp"   // ScalableButton, create_scaled_bitmap
 #include "slic3r/GUI/Widgets/Label.hpp"             // HarmonyOS Sans fonts (Head_*/Body_*) shared with the rest of Orca

src/slic3r/GUI/CAD/DesignPanel.hpp

@@ -1,17 +1,8 @@
 #ifndef slic3r_DesignPanel_hpp_
 #define slic3r_DesignPanel_hpp_
 
-#include <string>
-#include "libslic3r/Point.hpp"
-#include "libslic3r/CAD/SketchEngine.hpp"
-#include "libslic3r/TriangleMesh.hpp"
-#include <wx/accel.h>
-#include <wx/event.h>
-#include <wx/gdicmn.h>
-#include <wx/colour.h>
 #include <wx/panel.h>
 #include <wx/scrolwin.h>
-#include <wx/string.h>
 #include <wx/treebase.h>   // wxTreeItemId
 
 #include <vector>

src/slic3r/GUI/CAD/DesignSketchTool.cpp

@@ -5,11 +5,6 @@
 #include "slic3r/GUI/CAD/SketchInlineEditor.hpp"
 #include "slic3r/GUI/Plater.hpp"
 
-#include <Eigen/Core>
-#include <TopoDS_Shape.hxx>
-#include <TopoDS_Face.hxx>
-#include <TopoDS_Edge.hxx>
-#include <Eigen/Geometry>
 #include <imgui/imgui.h>
 #include <imgui/imgui_internal.h>
 #include "libslic3r/BuildVolume.hpp"
@@ -20,19 +15,6 @@
 #include "libslic3r/TriangleMesh.hpp"
 
 #include <GL/glew.h>
-#include "libslic3r/CAD/SketchEngine.hpp"
-#include "libslic3r/Point.hpp"
-#include <vector>
-#include <math.h>
-#include "libslic3r/CAD/SketchSolver.hpp"
-#include "libslic3r/Line.hpp"
-#include <string>
-#include "libslic3r/CAD/SketchInference.hpp"
-#include <utility>
-#include "libslic3r/CAD/CadDocument.hpp"
-#include "slic3r/GUI/GLModel.hpp"
-#include "libslic3r/BoundingBox.hpp"
-#include <initializer_list>
 #include <wx/gdicmn.h>
 #include <algorithm>
 #include <climits>

src/slic3r/GUI/CAD/DesignSketchTool.hpp

@@ -8,10 +8,7 @@
 #include "libslic3r/CAD/SketchSolver.hpp"
 #include "slic3r/GUI/GLModel.hpp"
 #include "slic3r/GUI/GLSelectionRectangle.hpp"   // left-drag rubber band over the committed bodies
-#include <Eigen/Core>
 #include <functional>
-#include "libslic3r/Color.hpp"
-#include <math.h>
 #include <vector>
 #include <string>
 #include <utility>

src/slic3r/GUI/CAD/McpControl.cpp

@@ -1,11 +1,4 @@
 #include "slic3r/GUI/CAD/McpControl.hpp"
-#include "libslic3r/Point.hpp"
-#include <stdexcept>
-#include <math.h>
-#include <TopAbs_ShapeEnum.hxx>
-#include <Standard_TypeDef.hxx>
-#include <exception>
-#include <cstdint>
 
 #ifndef _WIN32  // POSIX Unix-domain-socket transport only (slice 1)
 

src/slic3r/GUI/CAD/SketchInlineEditor.cpp

@@ -5,7 +5,6 @@
 #include "slic3r/GUI/I18N.hpp"
 #include "libslic3r/Color.hpp"
 
-#include <functional>
 #include <imgui/imgui.h>
 #include <imgui/imgui_internal.h>   // BringWindowToDisplayFront / GetCurrentWindow
 
@@ -13,8 +12,6 @@
 #include <cstdlib>
 #include <cstring>
 #include <string>
-#include <wx/gdicmn.h>
-#include <utility>
 
 namespace Slic3r {
 namespace GUI {