Stop Exporting Names Through Usings in the Remaining Headers

The last headers with a using or namespace alias at namespace scope: - TCPConsole.hpp imported boost::asio::ip::tcp into Slic3r::Utils for two member declarations. The alias is now a private member of the class. - WebSocketClient.hpp declared four namespace aliases and a tcp alias at global scope, each used only by the header. The names are spelled out. - Repair.hpp aliased CGAL::Polygon_mesh_processing as PMP in Slic3r::tex2color. The three functions that use it declare the alias themselves. - PreciseSeam.hpp, Thumbnails.hpp and MarchingSquares.hpp used a using-declaration or directive for one or two spots each; those spots are qualified. Thumbnails.hpp's "PNG"sv default argument becomes "PNG", which converts to the std::string_view parameter the same way. - tests/sla_print/sla_test_utils.hpp had "using namespace Slic3r;" and tests/filament_group/fg_test_serialization.hpp "using json = nlohmann::json;" at global scope. The headers qualify their own names; the two SLA test sources get the directive themselves. Also removed: twelve type aliases in headers that nothing references (ConflictObjName, CircleSqf, CircleSqd, TRawBuffer, DistanceFunction, SamePair, ExtruderNozzleInfos, Vec2dEvent, Vec2dsEvent, Vec3dEvent, t_option, t_optgroups, Plater::fs_path) and a duplicate fn_ft_job_msg_destroy alias in FileTransferUtils.hpp.
2026-10-07 15:51:08 +00:00 · 2026-10-07 18:31:22 +08:00
24 changed files with 120 additions and 157 deletions
@@ -311,7 +311,7 @@ function CreatePrinterBlock(OneModel)

 	return	'<div class="PrinterBlock" onClick="ChooseModel(\''+vendor+'\',\''+OneModel['model']+'\')">'+
 			'	<div class="PImg">'+
-			'		<img class="ModelThumbnail" src="' + OneModel['cover'] + '" onerror="this.onerror=null;this.src=\'../img/printer-dummy.png\';"/>'+
+			'		<img class="ModelThumbnail" src="' + OneModel['cover'] + '" />'+
 			'	</div>'+
 			'	<div class="PrinterInfoMark">?</div>'+
 			'	<div class="PrinterInfo">'+
@@ -148,8 +148,6 @@ struct ConflictComputeResult

 using ConflictComputeOpt = std::optional<ConflictComputeResult>;

-using ConflictObjName = std::optional<std::pair<std::string, std::string>>;
-
 struct ConflictChecker
 {
    static ConflictResultOpt  find_inter_of_lines_in_diff_objs(PrintObjectPtrs objs, std::optional<const FakeWipeTower *> wtdptr);
@@ -22,9 +22,6 @@
 namespace Slic3r {
 namespace PreciseSeam {

-// Import EnforcedBlockedSeamPoint from SeamPlacerImpl namespace for convenience
-using SeamPlacerImpl::EnforcedBlockedSeamPoint;
-
 // Geometry and its exterior bounds are prepared together, then treated as read-only.
 struct ModifierRegion {
    ExPolygon polygon;
@@ -137,7 +134,7 @@ SegmentExtraction extract_perimeter_segments(const PreparedPerimeter &prepared,

 // Result of weak modifier segment processing
 struct WeakModifierSegment {
-    EnforcedBlockedSeamPoint type;  // Enforced/Blocked/Neutral
+    SeamPlacerImpl::EnforcedBlockedSeamPoint type;  // Enforced/Blocked/Neutral
    Point left_point;               // Coordinates of left (first) point of segment
    PerimeterPosition left_position; // Position on the source perimeter before insertion/refinement.
    Point right_point;              // Coordinates of right (last) point of segment
@@ -40,8 +40,7 @@ std::string get_error_string(const ThumbnailErrors& errors);


 typedef std::vector<std::pair<GCodeThumbnailsFormat, Vec2d>> GCodeThumbnailDefinitionsList;
-using namespace std::literals;
-std::pair<GCodeThumbnailDefinitionsList, ThumbnailErrors> make_and_check_thumbnail_list(const std::string& thumbnails_string, const std::string_view def_ext = "PNG"sv);
+std::pair<GCodeThumbnailDefinitionsList, ThumbnailErrors> make_and_check_thumbnail_list(const std::string& thumbnails_string, const std::string_view def_ext = "PNG");
 std::pair<GCodeThumbnailDefinitionsList, ThumbnailErrors> make_and_check_thumbnail_list(const ConfigBase &config);


@@ -94,8 +94,6 @@ struct Circle {

 using Circlef = Circle<Vec2f>;
 using Circled = Circle<Vec2d>;
-using CircleSqf = CircleSq<Vec2f>;
-using CircleSqd = CircleSq<Vec2d>;

 /// Find the center of the circle corresponding to the vector of Points as an arc.
 Point circle_center_taubin_newton(const Points::const_iterator& input_start, const Points::const_iterator& input_end, size_t cycles = 20);
@@ -154,13 +154,12 @@ template<class ExecutionPolicy, class Enable = void> struct _Loop
 };

 // Add Specialization for using ExecutionTBB for parallel loops.
-using namespace Slic3r;
-template<> struct _Loop<ExecutionTBB>
+template<> struct _Loop<Slic3r::ExecutionTBB>
 {
    template<class It, class Fn> static void for_each_idx(It from, It to, Fn&& fn)
    {
-        execution::for_each(
-            ex_tbb, size_t(0), size_t(to - from), [&from, &fn](size_t i) { fn(from[i], i); }, execution::max_concurrency(ex_tbb));
+        Slic3r::execution::for_each(
+            Slic3r::ex_tbb, size_t(0), size_t(to - from), [&from, &fn](size_t i) { fn(from[i], i); }, Slic3r::execution::max_concurrency(Slic3r::ex_tbb));
    }
 };

@@ -49,7 +49,6 @@ public:
    using TColor = typename PixelRenderer::color_type;
    using TValue = typename TColor::value_type;
    using TPixel = typename PixelRenderer::pixel_type;
-    using TRawBuffer = agg::rendering_buffer;

 protected:
    
@@ -17,9 +17,6 @@ typedef std::vector<Color> ColorList;
 typedef std::array<double, 3> ColorDouble;
 typedef std::array<std::size_t, 3> RGB;

-// Function pointer type that points to a specific color-difference function based on the chosen method.
-using DistanceFunction = double (*)(const Color&, const Color&);
-
 // Color space used for computing color differences.
 enum struct ColorDifferenceMethod : std::size_t {
    RGB = 0,  // Simplest and fastest
@@ -23,8 +23,6 @@

 namespace Slic3r { namespace tex2color {

-namespace PMP = CGAL::Polygon_mesh_processing;
-
 // Default upper bound on the number of half-edges in any single boundary cycle
 // that CloseBoundariesAndRepairManifoldness will attempt to triangulate. The
 // cost of triangulate_hole grows non-linearly with cycle length, so this caps
@@ -60,6 +58,7 @@ struct BoundaryEdgeStats
 // any pre-processing (e.g. stitch_borders) needed for the count to be meaningful.
 inline BoundaryEdgeStats ComputeBoundaryEdgeStats(const cgalutils::CGALMesh& cgal_mesh)
 {
+    namespace PMP = CGAL::Polygon_mesh_processing;
    using CGALMesh = cgalutils::CGALMesh;
    using HalfedgeDescriptor = boost::graph_traits<CGALMesh>::halfedge_descriptor;

@@ -86,6 +85,7 @@ inline BoundaryEdgeStats ComputeBoundaryEdgeStats(const cgalutils::CGALMesh& cga
 // boundary statistics; entering this function always triggers triangulation.
 inline void CloseBoundariesAndRepairManifoldness(cgalutils::CGALMesh& cgal_mesh)
 {
+    namespace PMP = CGAL::Polygon_mesh_processing;
    using CGALMesh = cgalutils::CGALMesh;
    using HalfedgeDescriptor = boost::graph_traits<CGALMesh>::halfedge_descriptor;
    using FaceDescriptor = boost::graph_traits<CGALMesh>::face_descriptor;
@@ -111,6 +111,7 @@ inline bool RepairMesh(const TriMesh& mesh,
                       AlgoCancelCallback cancel_callback = nullptr,
                       const RepairSetting& setting = RepairSetting{})
 {
+    namespace PMP = CGAL::Polygon_mesh_processing;
    using Clock = std::chrono::steady_clock;
    auto elapsed_ms = [](Clock::time_point t0) {
        return std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() - t0).count();
@@ -432,8 +432,6 @@ inline IntegerOnly<I, I> fast_round_up(double a)
    return a == 0.49999999999999994 ? I(0) : I(floor(a + 0.5));
 }

-template<class T> using SamePair = std::pair<T, T>;
-
 } // namespace Slic3r

 #endif
@@ -198,6 +198,3 @@ template<> struct std::hash<NozzleDef>
        return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
    };
 };
-
-// key(extruder_id) -> { key1(nozzle type info), val1( number of the nozzle type)}
-using ExtruderNozzleInfos = std::unordered_map<int, std::unordered_map<NozzleDef, int>>;
@@ -183,13 +183,10 @@ wxDECLARE_EVENT(EVT_GLCANVAS_PLATE_NAME_CHANGE, SimpleEvent);
 //BBS: declare EVT_GLCANVAS_PLATE_SELECT
 wxDECLARE_EVENT(EVT_GLCANVAS_PLATE_SELECT, SimpleEvent);

-using Vec2dEvent = Event<Vec2d>;
 // _bool_ value is used as a indicator of selection in the 3DScene
 using RBtnEvent = Event<std::pair<Vec2d, bool>>;
 using RBtnPlateEvent = Event<std::pair<Vec2d, int>>;
-template <size_t N> using Vec2dsEvent = ArrayEvent<Vec2d, N>;

-using Vec3dEvent = Event<Vec3d>;
 template <size_t N> using Vec3dsEvent = ArrayEvent<Vec3d, N>;

 using HeightProfileSmoothEvent = Event<HeightProfileSmoothingParams>;
@@ -54,7 +54,6 @@ struct Option {
 	Option(const ConfigOptionDef& _opt, t_config_option_key id) :
 		opt(_opt), opt_id(id) {}
 };
-using t_option = std::unique_ptr<Option>;	//!

 /// Represents option lines
 class Line : public UndoValueUIManager
@@ -108,7 +108,6 @@ class PlaterPresetComboBox;
 class PartPlateList;
 class SyncNozzleAndAmsDialog;
 class FinishSyncAmsDialog;
-using t_optgroups = std::vector <std::shared_ptr<ConfigOptionsGroup>>;

 class Plater;
 enum class ActionButtonType : int;
@@ -325,7 +324,6 @@ private:
 class Plater: public wxPanel
 {
 public:
-    using fs_path = boost::filesystem::path;

    Plater(wxWindow *parent, MainFrame *main_frame);
    Plater(Plater &&) = delete;
@@ -89,7 +89,6 @@ using fn_ft_job_get_result    = ft_err(FT_CALL *)(FT_JobHandle *, uint32_t timeo
 using fn_ft_tunnel_start_job  = ft_err(FT_CALL *)(FT_TunnelHandle *, FT_JobHandle *);
 using fn_ft_job_cancel        = ft_err(FT_CALL *)(FT_JobHandle *);

-using fn_ft_job_msg_destroy = void(FT_CALL *)(ft_job_msg *);
 using fn_ft_job_set_msg_cb  = ft_err(FT_CALL *)(FT_JobHandle *, void(FT_CALL *)(void *user, ft_job_msg msg), void *user);
 using fn_ft_job_try_get_msg = ft_err(FT_CALL *)(FT_JobHandle *, ft_job_msg *out_msg);
 using fn_ft_job_get_msg     = ft_err(FT_CALL *)(FT_JobHandle *, uint32_t timeout_ms, ft_job_msg *out_msg);
@@ -16,12 +16,12 @@
 namespace Slic3r {
 namespace Utils {

-using boost::asio::ip::tcp;
-
 // Generic command / response TCP telnet like console class.
 // Used by the MKS host to send G-code commands to test connection ("M105") and to start printing ("M23 filename", "M24").
 class TCPConsole
 {
+    using tcp = boost::asio::ip::tcp;
+
 public:
    TCPConsole() : m_resolver(m_io_context), m_socket(m_io_context) { set_defaults(); }
    TCPConsole(const std::string& host_name, const std::string& port_name) : m_resolver(m_io_context), m_socket(m_io_context)
@@ -16,11 +16,6 @@
 #include <iostream>
 #include <string>
 #include <chrono>
-namespace beast = boost::beast;         // from <boost/beast.hpp>
-namespace http = beast::http;           // from <boost/beast/http.hpp>
-namespace websocket = beast::websocket; // from <boost/beast/websocket.hpp>
-namespace net = boost::asio;            // from <boost/asio.hpp>
-using tcp = net::ip::tcp;               // from <boost/asio/ip/tcp.hpp>

 class WebSocketClient {
 public:
@@ -36,7 +31,7 @@ public:
        }
        try {
            // Close the WebSocket connection
-            ws_.close(websocket::close_code::normal);
+            ws_.close(boost::beast::websocket::close_code::normal);
        } catch (const std::exception& e) {
            std::cerr << "Error: " << e.what() << std::endl;
        }
@@ -49,7 +44,7 @@ public:
        auto const results = resolver_.resolve(host, port);

        // Make the connection on the IP address we get from a lookup
-        auto ep = net::connect(ws_.next_layer(), results);
+        auto ep = boost::asio::connect(ws_.next_layer(), results);
        std::string _host = host;
        //if _host last char is  '/', remove it
        if(_host.size()>0&&_host[host.size()-1] == '/'){
@@ -58,10 +53,10 @@ public:

        // _host += ':' + std::to_string(ep.port());
        // Set a decorator to change the User-Agent of the handshake
-        ws_.set_option(websocket::stream_base::decorator(
-            [](websocket::request_type& req)
+        ws_.set_option(boost::beast::websocket::stream_base::decorator(
+            [](boost::beast::websocket::request_type& req)
            {
-                req.set(http::field::user_agent,"ElegooSlicer");
+                req.set(boost::beast::http::field::user_agent,"ElegooSlicer");
            }));
        // Perform the WebSocket handshake
        ws_.handshake(_host, path);
@@ -70,25 +65,25 @@ public:

    void send(const std::string& message){
        // Send a message
-        ws_.write(net::buffer(message));
+        ws_.write(boost::asio::buffer(message));
    }

    std::string receive(int timeout = 0){
        // This buffer will hold the incoming message
-        beast::flat_buffer buffer;
+        boost::beast::flat_buffer buffer;

        // Read a message into our buffer
        ws_.read(buffer);

        // Return the message as a string
-        return beast::buffers_to_string(buffer.data());
+        return boost::beast::buffers_to_string(buffer.data());
    }


 private:
-    net::io_context ioc_;
-    tcp::resolver resolver_;
-    websocket::stream<tcp::socket> ws_;
+    boost::asio::io_context ioc_;
+    boost::asio::ip::tcp::resolver resolver_;
+    boost::beast::websocket::stream<boost::asio::ip::tcp::socket> ws_;
    bool is_connect;
 };

@@ -115,9 +115,6 @@ static const std::unordered_map<std::string, AuditEventCategory> audit_event_cat
    {"subprocess.Popen", AuditEventCategory::ProcessCreate},
    {"_winapi.CreateProcess", AuditEventCategory::ProcessCreate},
    {"_posixsubprocess.fork_exec", AuditEventCategory::ProcessCreate},
-
-    // processreplace: exec* replaces the current process image rather than spawning a child
-    {"os.exec", AuditEventCategory::ProcessReplace},
 };

 // Returns the category event_name belongs to, or AuditEventCategory::None when it isn't audited.
@@ -711,7 +708,6 @@ static const std::unordered_map<std::string, std::vector<Py_ssize_t>> audit_targ
    {"pty.spawn", {0}},
    {"_winapi.CreateProcess", {1, 0}},
    {"_posixsubprocess.fork_exec", {0}},
-    {"os.exec", {0}},
 };

 AuditEventCategory open_category(PyObject* args)
@@ -765,7 +761,6 @@ std::vector<std::string>* permission_list_for(AuditEventCategory category, Plugi
    case AuditEventCategory::Http:          return &permissions.network_http;
    case AuditEventCategory::Socket:        return &permissions.network_socket;
    case AuditEventCategory::ProcessCreate: return &permissions.process;
-    case AuditEventCategory::ProcessReplace: return &permissions.process;
    default:                                return nullptr;
    }
 }
@@ -837,8 +832,6 @@ wxString audit_message(AuditEventCategory category, const wxString& plugin_name,
        return wxString::Format(_L("Plugin \"%s\" is requesting to open a network connection to:\n%s"), plugin_name, target_list);
    case AuditEventCategory::ProcessCreate:
        return wxString::Format(_L("Plugin \"%s\" is requesting to run the following command(s):\n%s"), plugin_name, target_list);
-    case AuditEventCategory::ProcessReplace:
-        return wxString::Format(_L("Plugin \"%s\" is requesting to replace the running application with:\n%s"), plugin_name, target_list);
    default:
        return wxString::Format(_L("Plugin \"%s\" is requesting permission for the Python audit event \"%s\"."), plugin_name, event_name);
    }
@@ -45,7 +45,6 @@ enum class AuditEventCategory {
    Http,
    Socket,
    ProcessCreate,
-    ProcessReplace,
    Threading,
 };

@@ -17,20 +17,18 @@
 #include <map>
 #include <unordered_map>

-using json = nlohmann::json;
-
 // Put serializers in correct ADL namespaces for each type

 namespace Slic3r {
 namespace FilamentGroupUtils {

-inline void to_json(json& j, const Color& c) {
+inline void to_json(nlohmann::json& j, const Color& c) {
    char buf[10];
    snprintf(buf, sizeof(buf), "#%02X%02X%02X%02X", c.r, c.g, c.b, c.a);
    j = std::string(buf);
 }

-inline void from_json(const json& j, Color& c) {
+inline void from_json(const nlohmann::json& j, Color& c) {
    std::string s = j.get<std::string>();
    if (s.size() >= 7 && s[0] == '#') {
        c.r = (unsigned char)std::stoi(s.substr(1, 2), nullptr, 16);
@@ -40,8 +38,8 @@ inline void from_json(const json& j, Color& c) {
    }
 }

-inline void to_json(json& j, const FilamentInfo& fi) {
-    j = json{
+inline void to_json(nlohmann::json& j, const FilamentInfo& fi) {
+    j = nlohmann::json{
        {"color", fi.color},
        {"type", fi.type},
        {"is_support", fi.is_support},
@@ -49,15 +47,15 @@ inline void to_json(json& j, const FilamentInfo& fi) {
    };
 }

-inline void from_json(const json& j, FilamentInfo& fi) {
+inline void from_json(const nlohmann::json& j, FilamentInfo& fi) {
    fi.color = j.at("color").get<Color>();
    j.at("type").get_to(fi.type);
    j.at("is_support").get_to(fi.is_support);
    fi.usage_type = (FilamentUsageType)j.at("usage_type").get<int>();
 }

-inline void to_json(json& j, const MachineFilamentInfo& mfi) {
-    j = json{
+inline void to_json(nlohmann::json& j, const MachineFilamentInfo& mfi) {
+    j = nlohmann::json{
        {"color", mfi.color},
        {"type", mfi.type},
        {"is_support", mfi.is_support},
@@ -67,7 +65,7 @@ inline void to_json(json& j, const MachineFilamentInfo& mfi) {
    };
 }

-inline void from_json(const json& j, MachineFilamentInfo& mfi) {
+inline void from_json(const nlohmann::json& j, MachineFilamentInfo& mfi) {
    mfi.color = j.at("color").get<Color>();
    j.at("type").get_to(mfi.type);
    j.at("is_support").get_to(mfi.is_support);
@@ -80,8 +78,8 @@ inline void from_json(const json& j, MachineFilamentInfo& mfi) {

 namespace MultiNozzleUtils {

-inline void to_json(json& j, const NozzleInfo& ni) {
-    j = json{
+inline void to_json(nlohmann::json& j, const NozzleInfo& ni) {
+    j = nlohmann::json{
        {"diameter", ni.diameter},
        {"volume_type", (int)ni.volume_type},
        {"extruder_id", ni.extruder_id},
@@ -89,15 +87,15 @@ inline void to_json(json& j, const NozzleInfo& ni) {
    };
 }

-inline void from_json(const json& j, NozzleInfo& ni) {
+inline void from_json(const nlohmann::json& j, NozzleInfo& ni) {
    j.at("diameter").get_to(ni.diameter);
    ni.volume_type = (NozzleVolumeType)j.at("volume_type").get<int>();
    j.at("extruder_id").get_to(ni.extruder_id);
    j.at("group_id").get_to(ni.group_id);
 }

-inline void to_json(json& j, const FilamentChangeTimeParams& p) {
-    j = json{
+inline void to_json(nlohmann::json& j, const FilamentChangeTimeParams& p) {
+    j = nlohmann::json{
        {"selector_load_time", p.selector_load_time},
        {"selector_unload_time", p.selector_unload_time},
        {"standard_load_time", p.standard_load_time},
@@ -105,7 +103,7 @@ inline void to_json(json& j, const FilamentChangeTimeParams& p) {
    };
 }

-inline void from_json(const json& j, FilamentChangeTimeParams& p) {
+inline void from_json(const nlohmann::json& j, FilamentChangeTimeParams& p) {
    j.at("selector_load_time").get_to(p.selector_load_time);
    j.at("selector_unload_time").get_to(p.selector_unload_time);
    j.at("standard_load_time").get_to(p.standard_load_time);
@@ -116,22 +114,22 @@ inline void from_json(const json& j, FilamentChangeTimeParams& p) {

 // ============ Helper: set<int> as JSON array ============
 namespace FGTestDetail {
-inline json set_to_json(const std::set<int>& s) {
-    return json(std::vector<int>(s.begin(), s.end()));
+inline nlohmann::json set_to_json(const std::set<int>& s) {
+    return nlohmann::json(std::vector<int>(s.begin(), s.end()));
 }

-inline std::set<int> json_to_set(const json& j) {
+inline std::set<int> json_to_set(const nlohmann::json& j) {
    auto v = j.get<std::vector<int>>();
    return std::set<int>(v.begin(), v.end());
 }

-inline json nvt_set_to_json(const std::set<NozzleVolumeType>& s) {
+inline nlohmann::json nvt_set_to_json(const std::set<NozzleVolumeType>& s) {
    std::vector<int> v;
    for (auto t : s) v.push_back((int)t);
-    return json(v);
+    return nlohmann::json(v);
 }

-inline std::set<NozzleVolumeType> json_to_nvt_set(const json& j) {
+inline std::set<NozzleVolumeType> json_to_nvt_set(const nlohmann::json& j) {
    std::set<NozzleVolumeType> s;
    for (auto& item : j) s.insert((NozzleVolumeType)item.get<int>());
    return s;
@@ -139,28 +137,28 @@ inline std::set<NozzleVolumeType> json_to_nvt_set(const json& j) {
 } // namespace FGTestDetail

 // ============ FilamentGroupContext::ModelInfo ============
-inline void to_json(json& j, const FilamentGroupContext::ModelInfo& mi) {
+inline void to_json(nlohmann::json& j, const FilamentGroupContext::ModelInfo& mi) {
    using namespace FGTestDetail;
    j["flush_matrix"] = mi.flush_matrix;
    j["layer_filaments"] = mi.layer_filaments;

-    j["filament_info"] = json::array();
+    j["filament_info"] = nlohmann::json::array();
    for (auto& fi : mi.filament_info)
        j["filament_info"].push_back(fi);

    j["filament_ids"] = mi.filament_ids;

-    j["unprintable_filaments"] = json::array();
+    j["unprintable_filaments"] = nlohmann::json::array();
    for (auto& s : mi.unprintable_filaments)
        j["unprintable_filaments"].push_back(set_to_json(s));

-    json uv = json::object();
+    nlohmann::json uv = nlohmann::json::object();
    for (auto& [fil, types] : mi.unprintable_volumes)
        uv[std::to_string(fil)] = nvt_set_to_json(types);
    j["unprintable_volumes"] = uv;
 }

-inline void from_json(const json& j, FilamentGroupContext::ModelInfo& mi) {
+inline void from_json(const nlohmann::json& j, FilamentGroupContext::ModelInfo& mi) {
    using namespace FGTestDetail;
    j.at("flush_matrix").get_to(mi.flush_matrix);
    j.at("layer_filaments").get_to(mi.layer_filaments);
@@ -183,8 +181,8 @@ inline void from_json(const json& j, FilamentGroupContext::ModelInfo& mi) {
 }

 // ============ FilamentGroupContext::GroupInfo ============
-inline void to_json(json& j, const FilamentGroupContext::GroupInfo& gi) {
-    j = json{
+inline void to_json(nlohmann::json& j, const FilamentGroupContext::GroupInfo& gi) {
+    j = nlohmann::json{
        {"total_filament_num", gi.total_filament_num},
        {"max_gap_threshold", gi.max_gap_threshold},
        {"mode", (int)gi.mode},
@@ -195,7 +193,7 @@ inline void to_json(json& j, const FilamentGroupContext::GroupInfo& gi) {
    };
 }

-inline void from_json(const json& j, FilamentGroupContext::GroupInfo& gi) {
+inline void from_json(const nlohmann::json& j, FilamentGroupContext::GroupInfo& gi) {
    j.at("total_filament_num").get_to(gi.total_filament_num);
    j.at("max_gap_threshold").get_to(gi.max_gap_threshold);
    gi.mode = (FGMode)j.at("mode").get<int>();
@@ -206,12 +204,12 @@ inline void from_json(const json& j, FilamentGroupContext::GroupInfo& gi) {
 }

 // ============ FilamentGroupContext::MachineInfo ============
-inline void to_json(json& j, const FilamentGroupContext::MachineInfo& mi) {
+inline void to_json(nlohmann::json& j, const FilamentGroupContext::MachineInfo& mi) {
    j["max_group_size"] = mi.max_group_size;

-    j["machine_filament_info"] = json::array();
+    j["machine_filament_info"] = nlohmann::json::array();
    for (auto& vec : mi.machine_filament_info) {
-        json arr = json::array();
+        nlohmann::json arr = nlohmann::json::array();
        for (auto& mfi : vec) arr.push_back(mfi);
        j["machine_filament_info"].push_back(arr);
    }
@@ -220,7 +218,7 @@ inline void to_json(json& j, const FilamentGroupContext::MachineInfo& mi) {
    j["master_extruder_id"] = mi.master_extruder_id;
 }

-inline void from_json(const json& j, FilamentGroupContext::MachineInfo& mi) {
+inline void from_json(const nlohmann::json& j, FilamentGroupContext::MachineInfo& mi) {
    j.at("max_group_size").get_to(mi.max_group_size);

    mi.machine_filament_info.clear();
@@ -236,10 +234,10 @@ inline void from_json(const json& j, FilamentGroupContext::MachineInfo& mi) {
 }

 // ============ FilamentGroupContext::SpeedInfo ============
-inline void to_json(json& j, const FilamentGroupContext::SpeedInfo& si) {
-    json fpt = json::object();
+inline void to_json(nlohmann::json& j, const FilamentGroupContext::SpeedInfo& si) {
+    nlohmann::json fpt = nlohmann::json::object();
    for (auto& [fil, inner] : si.filament_print_time) {
-        json inner_j = json::object();
+        nlohmann::json inner_j = nlohmann::json::object();
        for (auto& [layer, time] : inner)
            inner_j[std::to_string(layer)] = time;
        fpt[std::to_string(fil)] = inner_j;
@@ -252,7 +250,7 @@ inline void to_json(json& j, const FilamentGroupContext::SpeedInfo& si) {
    j["ams_preload_enabled"] = si.ams_preload_enabled;
 }

-inline void from_json(const json& j, FilamentGroupContext::SpeedInfo& si) {
+inline void from_json(const nlohmann::json& j, FilamentGroupContext::SpeedInfo& si) {
    si.filament_print_time.clear();
    if (j.contains("filament_print_time")) {
        for (auto& [k, v] : j.at("filament_print_time").items()) {
@@ -269,23 +267,23 @@ inline void from_json(const json& j, FilamentGroupContext::SpeedInfo& si) {
 }

 // ============ FilamentGroupContext::NozzleInfo ============
-inline void to_json(json& j, const FilamentGroupContext::NozzleInfo& ni) {
-    json enl = json::object();
+inline void to_json(nlohmann::json& j, const FilamentGroupContext::NozzleInfo& ni) {
+    nlohmann::json enl = nlohmann::json::object();
    for (auto& [ext, nozzles] : ni.extruder_nozzle_list)
        enl[std::to_string(ext)] = nozzles;
    j["extruder_nozzle_list"] = enl;

-    j["nozzle_list"] = json::array();
+    j["nozzle_list"] = nlohmann::json::array();
    for (auto& n : ni.nozzle_list)
        j["nozzle_list"].push_back(n);

-    json ns = json::object();
+    nlohmann::json ns = nlohmann::json::object();
    for (auto& [noz, fil] : ni.nozzle_status)
        ns[std::to_string(noz)] = fil;
    j["nozzle_status"] = ns;
 }

-inline void from_json(const json& j, FilamentGroupContext::NozzleInfo& ni) {
+inline void from_json(const nlohmann::json& j, FilamentGroupContext::NozzleInfo& ni) {
    ni.extruder_nozzle_list.clear();
    for (auto& [k, v] : j.at("extruder_nozzle_list").items())
        ni.extruder_nozzle_list[std::stoi(k)] = v.get<std::vector<int>>();
@@ -302,8 +300,8 @@ inline void from_json(const json& j, FilamentGroupContext::NozzleInfo& ni) {
 }

 // ============ Full FilamentGroupContext ============
-inline void to_json(json& j, const FilamentGroupContext& ctx) {
-    json mi, gi, mai, si, ni;
+inline void to_json(nlohmann::json& j, const FilamentGroupContext& ctx) {
+    nlohmann::json mi, gi, mai, si, ni;
    to_json(mi, ctx.model_info);
    to_json(gi, ctx.group_info);
    to_json(mai, ctx.machine_info);
@@ -316,7 +314,7 @@ inline void to_json(json& j, const FilamentGroupContext& ctx) {
    j["nozzle_info"] = ni;
 }

-inline void from_json(const json& j, FilamentGroupContext& ctx) {
+inline void from_json(const nlohmann::json& j, FilamentGroupContext& ctx) {
    from_json(j.at("model_info"), ctx.model_info);
    from_json(j.at("group_info"), ctx.group_info);
    from_json(j.at("machine_info"), ctx.machine_info);
@@ -336,11 +334,11 @@ struct TestMetadata {
    int seed = 0;
 };

-inline void to_json(json& j, const TestMetadata& m) {
-    j = json{{"id", m.id}, {"config_type", m.config_type}, {"seed", m.seed}};
+inline void to_json(nlohmann::json& j, const TestMetadata& m) {
+    j = nlohmann::json{{"id", m.id}, {"config_type", m.config_type}, {"seed", m.seed}};
 }

-inline void from_json(const json& j, TestMetadata& m) {
+inline void from_json(const nlohmann::json& j, TestMetadata& m) {
    j.at("id").get_to(m.id);
    j.at("config_type").get_to(m.config_type);
    j.at("seed").get_to(m.seed);
@@ -354,8 +352,8 @@ struct TestResult {
    std::vector<std::string> violations;
 };

-inline void to_json(json& j, const TestResult& r) {
-    j = json{
+inline void to_json(nlohmann::json& j, const TestResult& r) {
+    j = nlohmann::json{
        {"filament_map", r.filament_map},
        {"flush_cost", r.flush_cost},
        {"elapsed_ms", r.elapsed_ms},
@@ -364,7 +362,7 @@ inline void to_json(json& j, const TestResult& r) {
    };
 }

-inline void from_json(const json& j, TestResult& r) {
+inline void from_json(const nlohmann::json& j, TestResult& r) {
    j.at("filament_map").get_to(r.filament_map);
    j.at("flush_cost").get_to(r.flush_cost);
    j.at("elapsed_ms").get_to(r.elapsed_ms);
@@ -380,15 +378,15 @@ struct BaseResult {
    bool constraints_ok = true;
 };

-inline void to_json(json& j, const BaseResult& g) {
-    j = json{
+inline void to_json(nlohmann::json& j, const BaseResult& g) {
+    j = nlohmann::json{
        {"full_score", g.full_score},
        {"flush_cost", g.flush_cost},
        {"constraints_ok", g.constraints_ok}
    };
 }

-inline void from_json(const json& j, BaseResult& g) {
+inline void from_json(const nlohmann::json& j, BaseResult& g) {
    j.at("full_score").get_to(g.full_score);
    j.at("flush_cost").get_to(g.flush_cost);
    j.at("constraints_ok").get_to(g.constraints_ok);
@@ -403,7 +401,7 @@ struct TestCase {

 inline TestCase load_test_case(const std::string& path) {
    std::ifstream f(path);
-    json j = json::parse(f);
+    nlohmann::json j = nlohmann::json::parse(f);
    TestCase tc;
    tc.metadata = j.at("metadata").get<TestMetadata>();
    Slic3r::from_json(j.at("context"), tc.context);
@@ -413,9 +411,9 @@ inline TestCase load_test_case(const std::string& path) {
 }

 inline void save_test_case(const std::string& path, const TestCase& tc) {
-    json j;
+    nlohmann::json j;
    j["metadata"] = tc.metadata;
-    json ctx_j;
+    nlohmann::json ctx_j;
    Slic3r::to_json(ctx_j, tc.context);
    j["context"] = ctx_j;
    if (tc.base_result)
@@ -432,14 +430,14 @@ inline void save_result(const std::string& case_path, const TestResult& result)
    else
        result_path += ".result.json";

-    json j = result;
+    nlohmann::json j = result;
    std::ofstream f(result_path);
    f << j.dump(2);
 }

 inline TestResult load_result(const std::string& result_path) {
    std::ifstream f(result_path);
-    json j = json::parse(f);
+    nlohmann::json j = nlohmann::json::parse(f);
    return j.get<TestResult>();
 }

@@ -31,6 +31,8 @@
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/ExtrusionEntity.hpp"

+using namespace Slic3r;
+
 namespace {

 const char *const BELOW_PAD_TEST_OBJECTS[] = {
@@ -36,6 +36,8 @@
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/Line.hpp"

+using namespace Slic3r;
+
 void test_support_model_collision(const std::string          &obj_filename,
                                  const sla::SupportTreeConfig   &input_supportcfg,
                                  const sla::HollowingConfig &hollowingcfg,
@@ -33,33 +33,31 @@ namespace Slic3r::sla { struct PadConfig; }
 namespace Slic3r::sla { struct SupportTreeConfig; }


-using namespace Slic3r;
-
 enum e_validity {
    ASSUME_NO_EMPTY = 1,
    ASSUME_MANIFOLD = 2,
    ASSUME_NO_REPAIR = 4
 };

-void check_validity(const TriangleMesh &input_mesh,
+void check_validity(const Slic3r::TriangleMesh &input_mesh,
                    int flags = ASSUME_NO_EMPTY | ASSUME_MANIFOLD |
                                ASSUME_NO_REPAIR);

 struct PadByproducts
 {
-    ExPolygons   model_contours;
-    ExPolygons   support_contours;
-    TriangleMesh mesh;
+    Slic3r::ExPolygons   model_contours;
+    Slic3r::ExPolygons   support_contours;
+    Slic3r::TriangleMesh mesh;
 };

-void test_concave_hull(const ExPolygons &polys);
+void test_concave_hull(const Slic3r::ExPolygons &polys);

 void test_pad(const std::string &   obj_filename,
-              const sla::PadConfig &padcfg,
+              const Slic3r::sla::PadConfig &padcfg,
              PadByproducts &       out);

 inline void test_pad(const std::string &   obj_filename,
-              const sla::PadConfig &padcfg = {})
+              const Slic3r::sla::PadConfig &padcfg = {})
 {
    PadByproducts byproducts;
    test_pad(obj_filename, padcfg, byproducts);
@@ -69,53 +67,53 @@ struct SupportByproducts
 {
    std::string             obj_fname;
    std::vector<float>      slicegrid;
-    std::vector<ExPolygons> model_slices;
-    sla::SupportTreeBuilder supporttree;
-    TriangleMesh            input_mesh;
+    std::vector<Slic3r::ExPolygons> model_slices;
+    Slic3r::sla::SupportTreeBuilder supporttree;
+    Slic3r::TriangleMesh            input_mesh;
 };

 const constexpr float CLOSING_RADIUS = 0.005f;

-void check_support_tree_integrity(const sla::SupportTreeBuilder &stree,
-                                  const sla::SupportTreeConfig &cfg);
+void check_support_tree_integrity(const Slic3r::sla::SupportTreeBuilder &stree,
+                                  const Slic3r::sla::SupportTreeConfig &cfg);

 void test_supports(const std::string          &obj_filename,
-                   const sla::SupportTreeConfig   &supportcfg,
-                   const sla::HollowingConfig &hollowingcfg,
-                   const sla::DrainHoles      &drainholes,
+                   const Slic3r::sla::SupportTreeConfig   &supportcfg,
+                   const Slic3r::sla::HollowingConfig &hollowingcfg,
+                   const Slic3r::sla::DrainHoles      &drainholes,
                   SupportByproducts          &out);

 inline void test_supports(const std::string &obj_filename,
-                   const sla::SupportTreeConfig &supportcfg,
+                   const Slic3r::sla::SupportTreeConfig &supportcfg,
                   SupportByproducts        &out) 
 {
-    sla::HollowingConfig hcfg;
+    Slic3r::sla::HollowingConfig hcfg;
    hcfg.enabled = false;
    test_supports(obj_filename, supportcfg, hcfg, {}, out);    
 }

 inline void test_supports(const std::string &obj_filename,
-                   const sla::SupportTreeConfig &supportcfg = {})
+                   const Slic3r::sla::SupportTreeConfig &supportcfg = {})
 {
    SupportByproducts byproducts;
    test_supports(obj_filename, supportcfg, byproducts);
 }

-void export_failed_case(const std::vector<ExPolygons> &support_slices,
+void export_failed_case(const std::vector<Slic3r::ExPolygons> &support_slices,
                        const SupportByproducts &byproducts);


 void test_support_model_collision(
    const std::string          &obj_filename,
-    const sla::SupportTreeConfig   &input_supportcfg,
-    const sla::HollowingConfig &hollowingcfg,
-    const sla::DrainHoles      &drainholes);
+    const Slic3r::sla::SupportTreeConfig   &input_supportcfg,
+    const Slic3r::sla::HollowingConfig &hollowingcfg,
+    const Slic3r::sla::DrainHoles      &drainholes);

 inline void test_support_model_collision(
    const std::string        &obj_filename,
-    const sla::SupportTreeConfig &input_supportcfg = {}) 
+    const Slic3r::sla::SupportTreeConfig &input_supportcfg = {}) 
 {
-    sla::HollowingConfig hcfg;
+    Slic3r::sla::HollowingConfig hcfg;
    hcfg.enabled = false;
    test_support_model_collision(obj_filename, input_supportcfg, hcfg, {});
 }
@@ -156,8 +154,8 @@ template <class I, class II> void test_pairhash()
        
        REQUIRE(a != b);
        
-        II hash_ab = sla::pairhash<I, II>(a, b);
-        II hash_ba = sla::pairhash<I, II>(b, a);
+        II hash_ab = Slic3r::sla::pairhash<I, II>(a, b);
+        II hash_ba = Slic3r::sla::pairhash<I, II>(b, a);
        REQUIRE(hash_ab == hash_ba);
        
        auto it = ints.find(hash_ab);
@@ -180,23 +178,23 @@ static constexpr const TPixel FullBlack = 0;

 template <class A, int N> constexpr int arraysize(const A (&)[N]) { return N; }

-void check_raster_transformations(sla::RasterBase::Orientation o,
-                                  sla::RasterBase::TMirroring  mirroring);
+void check_raster_transformations(Slic3r::sla::RasterBase::Orientation o,
+                                  Slic3r::sla::RasterBase::TMirroring  mirroring);

-ExPolygon square_with_hole(double v);
+Slic3r::ExPolygon square_with_hole(double v);

-inline double pixel_area(TPixel px, const sla::PixelDim &pxdim)
+inline double pixel_area(TPixel px, const Slic3r::sla::PixelDim &pxdim)
 {
    return (pxdim.h_mm * pxdim.w_mm) * px * 1. / (FullWhite - FullBlack);
 }

-double raster_white_area(const sla::RasterGrayscaleAA &raster);
-long raster_pxsum(const sla::RasterGrayscaleAA &raster);
+double raster_white_area(const Slic3r::sla::RasterGrayscaleAA &raster);
+long raster_pxsum(const Slic3r::sla::RasterGrayscaleAA &raster);

-double predict_error(const ExPolygon &p, const sla::PixelDim &pd);
+double predict_error(const Slic3r::ExPolygon &p, const Slic3r::sla::PixelDim &pd);

-sla::SupportPoints calc_support_pts(
-    const TriangleMesh &                      mesh,
-    const sla::SupportPointGenerator::Config &cfg = {});
+Slic3r::sla::SupportPoints calc_support_pts(
+    const Slic3r::TriangleMesh &                      mesh,
+    const Slic3r::sla::SupportPointGenerator::Config &cfg = {});

 #endif // SLA_TEST_UTILS_HPP