Size a Project's Mixed-Colour Metadata to the Filaments in the CLI

The mixed-colour metadata options are parallel per-slot arrays in the project
config. A project saved before they were sized per slot stores a single value
for the gradient ones, and one saved before they existed stores none. The GUI
sizes all seven to the filament count when it opens a project; the CLI kept
the stored arrays and exported one-element defaults for absent ones, so a
project it exported carried one-element arrays where the GUI writes one entry
per filament. Slicing is unaffected, every reader treats a missing entry as
not mixed / no gradient, but the GUI-vs-CLI comparison reported the four
gradient keys on every mixed-filament project.

The resize helper moves from PresetBundle.cpp, where it was file-local, to
PrintConfig.cpp next to set_filament_dev_options(). It creates an option the
config lacks before sizing it, a no-op for the bundle's project config where
all seven always exist. The CLI calls it with its filament count once the
project and loaded filaments are merged, after the check that every mixed
slot has a filament of its own.

src/OrcaSlicer.cpp

@@ -4094,6 +4094,8 @@ int CLI::run(int argc, char **argv)
             flush_and_exit(CLI_MIXED_FILAMENT_INVALID);
         }
     }
+    if (filament_count > 0)
+        resize_mixed_filament_metadata(m_print_config, size_t(filament_count), size_t(filament_count));
 
     m_print_config.option<ConfigOptionEnum<PrinterTechnology>>("printer_technology", true)->value = printer_technology;
 

src/libslic3r/GCode/ConflictChecker.hpp

@@ -148,6 +148,8 @@ 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);

src/libslic3r/GCode/PreciseSeam.hpp

@@ -22,6 +22,9 @@
 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;
@@ -134,7 +137,7 @@ SegmentExtraction extract_perimeter_segments(const PreparedPerimeter &prepared,
 
 // Result of weak modifier segment processing
 struct WeakModifierSegment {
-    SeamPlacerImpl::EnforcedBlockedSeamPoint type;  // Enforced/Blocked/Neutral
+    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

src/libslic3r/GCode/Thumbnails.hpp

@@ -40,7 +40,8 @@ std::string get_error_string(const ThumbnailErrors& errors);
 
 
 typedef std::vector<std::pair<GCodeThumbnailsFormat, Vec2d>> GCodeThumbnailDefinitionsList;
-std::pair<GCodeThumbnailDefinitionsList, ThumbnailErrors> make_and_check_thumbnail_list(const std::string& thumbnails_string, const std::string_view def_ext = "PNG");
+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 ConfigBase &config);
 
 

src/libslic3r/Geometry/Circle.hpp

@@ -94,6 +94,8 @@ 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);

src/libslic3r/MarchingSquares.hpp

@@ -154,12 +154,13 @@ template<class ExecutionPolicy, class Enable = void> struct _Loop
 };
 
 // Add Specialization for using ExecutionTBB for parallel loops.
-template<> struct _Loop<Slic3r::ExecutionTBB>
+using namespace Slic3r;
+template<> struct _Loop<ExecutionTBB>
 {
     template<class It, class Fn> static void for_each_idx(It from, It to, Fn&& fn)
     {
-        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));
+        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));
     }
 };
 

src/libslic3r/PresetBundle.cpp

@@ -3601,24 +3601,6 @@ void PresetBundle::export_selections(AppConfig &config)
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": printer %1%, print %2%, filaments[0] %3% ")%printers.get_selected_preset_name() % prints.get_selected_preset_name() %filament_presets[0];
 }
 
-// Preserve metadata only for existing colour slots; new slots get false/empty defaults.
-static void resize_mixed_filament_metadata(DynamicPrintConfig &config, size_t old_slot_count, size_t new_slot_count)
-{
-    auto resize = [old_slot_count, new_slot_count](auto *opt) {
-        if (opt) {
-            opt->values.resize(std::min(old_slot_count, opt->values.size()));
-            opt->values.resize(new_slot_count);
-        }
-    };
-    resize(config.option<ConfigOptionBools>("filament_is_mixed"));
-    resize(config.option<ConfigOptionStrings>("filament_mixed_components"));
-    resize(config.option<ConfigOptionStrings>("filament_mixed_sublayer_ratios"));
-    resize(config.option<ConfigOptionBools>("filament_mixed_gradient"));
-    resize(config.option<ConfigOptionStrings>("filament_mixed_gradient_range"));
-    resize(config.option<ConfigOptionStrings>("filament_mixed_gradient_curve"));
-    resize(config.option<ConfigOptionBools>("filament_mixed_gradient_per_part"));
-}
-
 void PresetBundle::set_num_filaments(unsigned int n, std::string new_color)
 {
     unsigned old_filament_count = this->filament_presets.size();

src/libslic3r/PrintConfig.cpp

@@ -10838,6 +10838,21 @@ void set_filament_dev_options(DynamicPrintConfig &config, const std::vector<cons
     }
 }
 
+void resize_mixed_filament_metadata(DynamicPrintConfig &config, size_t old_slot_count, size_t new_slot_count)
+{
+    auto resize = [old_slot_count, new_slot_count](auto *opt) {
+        opt->values.resize(std::min(old_slot_count, opt->values.size()));
+        opt->values.resize(new_slot_count);
+    };
+    resize(config.option<ConfigOptionBools>("filament_is_mixed", true));
+    resize(config.option<ConfigOptionStrings>("filament_mixed_components", true));
+    resize(config.option<ConfigOptionStrings>("filament_mixed_sublayer_ratios", true));
+    resize(config.option<ConfigOptionBools>("filament_mixed_gradient", true));
+    resize(config.option<ConfigOptionStrings>("filament_mixed_gradient_range", true));
+    resize(config.option<ConfigOptionStrings>("filament_mixed_gradient_curve", true));
+    resize(config.option<ConfigOptionBools>("filament_mixed_gradient_per_part", true));
+}
+
 
 //used for object/region config
 //use the smallest of multiple to single

src/libslic3r/PrintConfig.hpp

@@ -933,6 +933,10 @@ extern std::set<std::string> filament_dev_options;
 // filament_configs, one config per filament in slot order, as the filaments' values one after another.
 void set_filament_dev_options(DynamicPrintConfig &config, const std::vector<const DynamicPrintConfig *> &filament_configs);
 
+// Orca: sizes the per-slot mixed-colour metadata options to new_slot_count, keeping the first
+// old_slot_count values; an option the config lacks is created.
+void resize_mixed_filament_metadata(DynamicPrintConfig &config, size_t old_slot_count, size_t new_slot_count);
+
 extern void update_static_print_config_from_dynamic(ConfigBase& config, const DynamicPrintConfig& dest_config, std::vector<int> variant_index, std::set<std::string>& key_set1, int stride = 1);
 extern void compute_filament_override_value(const std::string& opt_key, const ConfigOption *opt_old_machine, const ConfigOption *opt_new_machine, const ConfigOption *opt_new_filament, const DynamicPrintConfig& new_full_config,
     t_config_option_keys& diff_keys, DynamicPrintConfig& filament_overrides, std::vector<int>& f_map_indices);

src/libslic3r/SLA/AGGRaster.hpp

@@ -49,6 +49,7 @@ 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:
     

src/libslic3r/TextureToColor/ColorUtils.hpp

@@ -17,6 +17,9 @@ 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

src/libslic3r/TextureToColor/Repair.hpp

@@ -23,6 +23,8 @@
 
 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
@@ -58,7 +60,6 @@ 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;
 
@@ -85,7 +86,6 @@ 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,7 +111,6 @@ 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();

src/libslic3r/libslic3r.h

@@ -432,6 +432,8 @@ 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

src/slic3r/GUI/DeviceCore/DevDefs.h

@@ -198,3 +198,6 @@ 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>>;

src/slic3r/GUI/GLCanvas3D.hpp

@@ -183,10 +183,13 @@ 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>;

src/slic3r/GUI/OptionsGroup.hpp

@@ -54,6 +54,7 @@ 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

src/slic3r/GUI/Plater.hpp

@@ -108,6 +108,7 @@ class PlaterPresetComboBox;
 class PartPlateList;
 class SyncNozzleAndAmsDialog;
 class FinishSyncAmsDialog;
+using t_optgroups = std::vector <std::shared_ptr<ConfigOptionsGroup>>;
 
 class Plater;
 enum class ActionButtonType : int;
@@ -324,6 +325,7 @@ private:
 class Plater: public wxPanel
 {
 public:
+    using fs_path = boost::filesystem::path;
 
     Plater(wxWindow *parent, MainFrame *main_frame);
     Plater(Plater &&) = delete;

src/slic3r/Utils/FileTransferUtils.hpp

@@ -89,6 +89,7 @@ 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);

src/slic3r/Utils/TCPConsole.hpp

@@ -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)

src/slic3r/Utils/WebSocketClient.hpp

@@ -16,6 +16,11 @@
 #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:
@@ -31,7 +36,7 @@ public:
         }
         try {
             // Close the WebSocket connection
-            ws_.close(boost::beast::websocket::close_code::normal);
+            ws_.close(websocket::close_code::normal);
         } catch (const std::exception& e) {
             std::cerr << "Error: " << e.what() << std::endl;
         }
@@ -44,7 +49,7 @@ public:
         auto const results = resolver_.resolve(host, port);
 
         // Make the connection on the IP address we get from a lookup
-        auto ep = boost::asio::connect(ws_.next_layer(), results);
+        auto ep = net::connect(ws_.next_layer(), results);
         std::string _host = host;
         //if _host last char is  '/', remove it
         if(_host.size()>0&&_host[host.size()-1] == '/'){
@@ -53,10 +58,10 @@ public:
 
         // _host += ':' + std::to_string(ep.port());
         // Set a decorator to change the User-Agent of the handshake
-        ws_.set_option(boost::beast::websocket::stream_base::decorator(
-            [](boost::beast::websocket::request_type& req)
+        ws_.set_option(websocket::stream_base::decorator(
+            [](websocket::request_type& req)
             {
-                req.set(boost::beast::http::field::user_agent,"ElegooSlicer");
+                req.set(http::field::user_agent,"ElegooSlicer");
             }));
         // Perform the WebSocket handshake
         ws_.handshake(_host, path);
@@ -65,25 +70,25 @@ public:
 
     void send(const std::string& message){
         // Send a message
-        ws_.write(boost::asio::buffer(message));
+        ws_.write(net::buffer(message));
     }
 
     std::string receive(int timeout = 0){
         // This buffer will hold the incoming message
-        boost::beast::flat_buffer buffer;
+        beast::flat_buffer buffer;
 
         // Read a message into our buffer
         ws_.read(buffer);
 
         // Return the message as a string
-        return boost::beast::buffers_to_string(buffer.data());
+        return beast::buffers_to_string(buffer.data());
     }
 
 
 private:
-    boost::asio::io_context ioc_;
-    boost::asio::ip::tcp::resolver resolver_;
-    boost::beast::websocket::stream<boost::asio::ip::tcp::socket> ws_;
+    net::io_context ioc_;
+    tcp::resolver resolver_;
+    websocket::stream<tcp::socket> ws_;
     bool is_connect;
 };
 

tests/filament_group/fg_test_serialization.hpp

@@ -17,18 +17,20 @@
 #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(nlohmann::json& j, const Color& c) {
+inline void to_json(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 nlohmann::json& j, Color& c) {
+inline void from_json(const 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);
@@ -38,8 +40,8 @@ inline void from_json(const nlohmann::json& j, Color& c) {
     }
 }
 
-inline void to_json(nlohmann::json& j, const FilamentInfo& fi) {
-    j = nlohmann::json{
+inline void to_json(json& j, const FilamentInfo& fi) {
+    j = json{
         {"color", fi.color},
         {"type", fi.type},
         {"is_support", fi.is_support},
@@ -47,15 +49,15 @@ inline void to_json(nlohmann::json& j, const FilamentInfo& fi) {
     };
 }
 
-inline void from_json(const nlohmann::json& j, FilamentInfo& fi) {
+inline void from_json(const 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(nlohmann::json& j, const MachineFilamentInfo& mfi) {
-    j = nlohmann::json{
+inline void to_json(json& j, const MachineFilamentInfo& mfi) {
+    j = json{
         {"color", mfi.color},
         {"type", mfi.type},
         {"is_support", mfi.is_support},
@@ -65,7 +67,7 @@ inline void to_json(nlohmann::json& j, const MachineFilamentInfo& mfi) {
     };
 }
 
-inline void from_json(const nlohmann::json& j, MachineFilamentInfo& mfi) {
+inline void from_json(const 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);
@@ -78,8 +80,8 @@ inline void from_json(const nlohmann::json& j, MachineFilamentInfo& mfi) {
 
 namespace MultiNozzleUtils {
 
-inline void to_json(nlohmann::json& j, const NozzleInfo& ni) {
-    j = nlohmann::json{
+inline void to_json(json& j, const NozzleInfo& ni) {
+    j = json{
         {"diameter", ni.diameter},
         {"volume_type", (int)ni.volume_type},
         {"extruder_id", ni.extruder_id},
@@ -87,15 +89,15 @@ inline void to_json(nlohmann::json& j, const NozzleInfo& ni) {
     };
 }
 
-inline void from_json(const nlohmann::json& j, NozzleInfo& ni) {
+inline void from_json(const 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(nlohmann::json& j, const FilamentChangeTimeParams& p) {
-    j = nlohmann::json{
+inline void to_json(json& j, const FilamentChangeTimeParams& p) {
+    j = json{
         {"selector_load_time", p.selector_load_time},
         {"selector_unload_time", p.selector_unload_time},
         {"standard_load_time", p.standard_load_time},
@@ -103,7 +105,7 @@ inline void to_json(nlohmann::json& j, const FilamentChangeTimeParams& p) {
     };
 }
 
-inline void from_json(const nlohmann::json& j, FilamentChangeTimeParams& p) {
+inline void from_json(const 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);
@@ -114,22 +116,22 @@ inline void from_json(const nlohmann::json& j, FilamentChangeTimeParams& p) {
 
 // ============ Helper: set<int> as JSON array ============
 namespace FGTestDetail {
-inline nlohmann::json set_to_json(const std::set<int>& s) {
-    return nlohmann::json(std::vector<int>(s.begin(), s.end()));
+inline json set_to_json(const std::set<int>& s) {
+    return json(std::vector<int>(s.begin(), s.end()));
 }
 
-inline std::set<int> json_to_set(const nlohmann::json& j) {
+inline std::set<int> json_to_set(const json& j) {
     auto v = j.get<std::vector<int>>();
     return std::set<int>(v.begin(), v.end());
 }
 
-inline nlohmann::json nvt_set_to_json(const std::set<NozzleVolumeType>& s) {
+inline json nvt_set_to_json(const std::set<NozzleVolumeType>& s) {
     std::vector<int> v;
     for (auto t : s) v.push_back((int)t);
-    return nlohmann::json(v);
+    return json(v);
 }
 
-inline std::set<NozzleVolumeType> json_to_nvt_set(const nlohmann::json& j) {
+inline std::set<NozzleVolumeType> json_to_nvt_set(const json& j) {
     std::set<NozzleVolumeType> s;
     for (auto& item : j) s.insert((NozzleVolumeType)item.get<int>());
     return s;
@@ -137,28 +139,28 @@ inline std::set<NozzleVolumeType> json_to_nvt_set(const nlohmann::json& j) {
 } // namespace FGTestDetail
 
 // ============ FilamentGroupContext::ModelInfo ============
-inline void to_json(nlohmann::json& j, const FilamentGroupContext::ModelInfo& mi) {
+inline void to_json(json& j, const FilamentGroupContext::ModelInfo& mi) {
     using namespace FGTestDetail;
     j["flush_matrix"] = mi.flush_matrix;
     j["layer_filaments"] = mi.layer_filaments;
 
-    j["filament_info"] = nlohmann::json::array();
+    j["filament_info"] = json::array();
     for (auto& fi : mi.filament_info)
         j["filament_info"].push_back(fi);
 
     j["filament_ids"] = mi.filament_ids;
 
-    j["unprintable_filaments"] = nlohmann::json::array();
+    j["unprintable_filaments"] = json::array();
     for (auto& s : mi.unprintable_filaments)
         j["unprintable_filaments"].push_back(set_to_json(s));
 
-    nlohmann::json uv = nlohmann::json::object();
+    json uv = 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 nlohmann::json& j, FilamentGroupContext::ModelInfo& mi) {
+inline void from_json(const 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);
@@ -181,8 +183,8 @@ inline void from_json(const nlohmann::json& j, FilamentGroupContext::ModelInfo&
 }
 
 // ============ FilamentGroupContext::GroupInfo ============
-inline void to_json(nlohmann::json& j, const FilamentGroupContext::GroupInfo& gi) {
-    j = nlohmann::json{
+inline void to_json(json& j, const FilamentGroupContext::GroupInfo& gi) {
+    j = json{
         {"total_filament_num", gi.total_filament_num},
         {"max_gap_threshold", gi.max_gap_threshold},
         {"mode", (int)gi.mode},
@@ -193,7 +195,7 @@ inline void to_json(nlohmann::json& j, const FilamentGroupContext::GroupInfo& gi
     };
 }
 
-inline void from_json(const nlohmann::json& j, FilamentGroupContext::GroupInfo& gi) {
+inline void from_json(const 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>();
@@ -204,12 +206,12 @@ inline void from_json(const nlohmann::json& j, FilamentGroupContext::GroupInfo&
 }
 
 // ============ FilamentGroupContext::MachineInfo ============
-inline void to_json(nlohmann::json& j, const FilamentGroupContext::MachineInfo& mi) {
+inline void to_json(json& j, const FilamentGroupContext::MachineInfo& mi) {
     j["max_group_size"] = mi.max_group_size;
 
-    j["machine_filament_info"] = nlohmann::json::array();
+    j["machine_filament_info"] = json::array();
     for (auto& vec : mi.machine_filament_info) {
-        nlohmann::json arr = nlohmann::json::array();
+        json arr = json::array();
         for (auto& mfi : vec) arr.push_back(mfi);
         j["machine_filament_info"].push_back(arr);
     }
@@ -218,7 +220,7 @@ inline void to_json(nlohmann::json& j, const FilamentGroupContext::MachineInfo&
     j["master_extruder_id"] = mi.master_extruder_id;
 }
 
-inline void from_json(const nlohmann::json& j, FilamentGroupContext::MachineInfo& mi) {
+inline void from_json(const json& j, FilamentGroupContext::MachineInfo& mi) {
     j.at("max_group_size").get_to(mi.max_group_size);
 
     mi.machine_filament_info.clear();
@@ -234,10 +236,10 @@ inline void from_json(const nlohmann::json& j, FilamentGroupContext::MachineInfo
 }
 
 // ============ FilamentGroupContext::SpeedInfo ============
-inline void to_json(nlohmann::json& j, const FilamentGroupContext::SpeedInfo& si) {
-    nlohmann::json fpt = nlohmann::json::object();
+inline void to_json(json& j, const FilamentGroupContext::SpeedInfo& si) {
+    json fpt = json::object();
     for (auto& [fil, inner] : si.filament_print_time) {
-        nlohmann::json inner_j = nlohmann::json::object();
+        json inner_j = json::object();
         for (auto& [layer, time] : inner)
             inner_j[std::to_string(layer)] = time;
         fpt[std::to_string(fil)] = inner_j;
@@ -250,7 +252,7 @@ inline void to_json(nlohmann::json& j, const FilamentGroupContext::SpeedInfo& si
     j["ams_preload_enabled"] = si.ams_preload_enabled;
 }
 
-inline void from_json(const nlohmann::json& j, FilamentGroupContext::SpeedInfo& si) {
+inline void from_json(const 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()) {
@@ -267,23 +269,23 @@ inline void from_json(const nlohmann::json& j, FilamentGroupContext::SpeedInfo&
 }
 
 // ============ FilamentGroupContext::NozzleInfo ============
-inline void to_json(nlohmann::json& j, const FilamentGroupContext::NozzleInfo& ni) {
-    nlohmann::json enl = nlohmann::json::object();
+inline void to_json(json& j, const FilamentGroupContext::NozzleInfo& ni) {
+    json enl = json::object();
     for (auto& [ext, nozzles] : ni.extruder_nozzle_list)
         enl[std::to_string(ext)] = nozzles;
     j["extruder_nozzle_list"] = enl;
 
-    j["nozzle_list"] = nlohmann::json::array();
+    j["nozzle_list"] = json::array();
     for (auto& n : ni.nozzle_list)
         j["nozzle_list"].push_back(n);
 
-    nlohmann::json ns = nlohmann::json::object();
+    json ns = json::object();
     for (auto& [noz, fil] : ni.nozzle_status)
         ns[std::to_string(noz)] = fil;
     j["nozzle_status"] = ns;
 }
 
-inline void from_json(const nlohmann::json& j, FilamentGroupContext::NozzleInfo& ni) {
+inline void from_json(const 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>>();
@@ -300,8 +302,8 @@ inline void from_json(const nlohmann::json& j, FilamentGroupContext::NozzleInfo&
 }
 
 // ============ Full FilamentGroupContext ============
-inline void to_json(nlohmann::json& j, const FilamentGroupContext& ctx) {
-    nlohmann::json mi, gi, mai, si, ni;
+inline void to_json(json& j, const FilamentGroupContext& ctx) {
+    json mi, gi, mai, si, ni;
     to_json(mi, ctx.model_info);
     to_json(gi, ctx.group_info);
     to_json(mai, ctx.machine_info);
@@ -314,7 +316,7 @@ inline void to_json(nlohmann::json& j, const FilamentGroupContext& ctx) {
     j["nozzle_info"] = ni;
 }
 
-inline void from_json(const nlohmann::json& j, FilamentGroupContext& ctx) {
+inline void from_json(const 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);
@@ -334,11 +336,11 @@ struct TestMetadata {
     int seed = 0;
 };
 
-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 to_json(json& j, const TestMetadata& m) {
+    j = json{{"id", m.id}, {"config_type", m.config_type}, {"seed", m.seed}};
 }
 
-inline void from_json(const nlohmann::json& j, TestMetadata& m) {
+inline void from_json(const 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);
@@ -352,8 +354,8 @@ struct TestResult {
     std::vector<std::string> violations;
 };
 
-inline void to_json(nlohmann::json& j, const TestResult& r) {
-    j = nlohmann::json{
+inline void to_json(json& j, const TestResult& r) {
+    j = json{
         {"filament_map", r.filament_map},
         {"flush_cost", r.flush_cost},
         {"elapsed_ms", r.elapsed_ms},
@@ -362,7 +364,7 @@ inline void to_json(nlohmann::json& j, const TestResult& r) {
     };
 }
 
-inline void from_json(const nlohmann::json& j, TestResult& r) {
+inline void from_json(const 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);
@@ -378,15 +380,15 @@ struct BaseResult {
     bool constraints_ok = true;
 };
 
-inline void to_json(nlohmann::json& j, const BaseResult& g) {
-    j = nlohmann::json{
+inline void to_json(json& j, const BaseResult& g) {
+    j = json{
         {"full_score", g.full_score},
         {"flush_cost", g.flush_cost},
         {"constraints_ok", g.constraints_ok}
     };
 }
 
-inline void from_json(const nlohmann::json& j, BaseResult& g) {
+inline void from_json(const 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);
@@ -401,7 +403,7 @@ struct TestCase {
 
 inline TestCase load_test_case(const std::string& path) {
     std::ifstream f(path);
-    nlohmann::json j = nlohmann::json::parse(f);
+    json j = json::parse(f);
     TestCase tc;
     tc.metadata = j.at("metadata").get<TestMetadata>();
     Slic3r::from_json(j.at("context"), tc.context);
@@ -411,9 +413,9 @@ inline TestCase load_test_case(const std::string& path) {
 }
 
 inline void save_test_case(const std::string& path, const TestCase& tc) {
-    nlohmann::json j;
+    json j;
     j["metadata"] = tc.metadata;
-    nlohmann::json ctx_j;
+    json ctx_j;
     Slic3r::to_json(ctx_j, tc.context);
     j["context"] = ctx_j;
     if (tc.base_result)
@@ -430,14 +432,14 @@ inline void save_result(const std::string& case_path, const TestResult& result)
     else
         result_path += ".result.json";
 
-    nlohmann::json j = result;
+    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);
-    nlohmann::json j = nlohmann::json::parse(f);
+    json j = json::parse(f);
     return j.get<TestResult>();
 }
 

tests/libslic3r/test_config_variant_expansion.cpp

@@ -826,3 +826,23 @@ TEST_CASE("The device drying options are rebuilt as each filament's values in sl
     set_filament_dev_options(config, {&two_values, &no_value});
     REQUIRE(config.option<ConfigOptionStrings>("filament_dev_ams_drying_ams_limitations")->values == std::vector<std::string>({"1", "0", ""}));
 }
+
+TEST_CASE("The mixed filament metadata is sized to the filament count", "[Config]")
+{
+    DynamicPrintConfig config;
+    config.option<ConfigOptionBools>("filament_is_mixed", true)->values            = {false, false, true};
+    config.option<ConfigOptionStrings>("filament_mixed_components", true)->values  = {"", "", "1,2"};
+    config.option<ConfigOptionBools>("filament_mixed_gradient", true)->values      = {false};
+    config.option<ConfigOptionStrings>("filament_mixed_gradient_range", true)->values = {""};
+
+    resize_mixed_filament_metadata(config, 3, 3);
+    REQUIRE(config.option<ConfigOptionBools>("filament_is_mixed")->values == std::vector<unsigned char>({false, false, true}));
+    REQUIRE(config.option<ConfigOptionStrings>("filament_mixed_components")->values == std::vector<std::string>({"", "", "1,2"}));
+    REQUIRE(config.option<ConfigOptionBools>("filament_mixed_gradient")->values == std::vector<unsigned char>({false, false, false}));
+    REQUIRE(config.option<ConfigOptionStrings>("filament_mixed_gradient_range")->values == std::vector<std::string>({"", "", ""}));
+    REQUIRE(config.option<ConfigOptionStrings>("filament_mixed_gradient_curve")->values == std::vector<std::string>({"", "", ""}));
+
+    resize_mixed_filament_metadata(config, 2, 4);
+    REQUIRE(config.option<ConfigOptionBools>("filament_is_mixed")->values == std::vector<unsigned char>({false, false, false, false}));
+    REQUIRE(config.option<ConfigOptionStrings>("filament_mixed_components")->values == std::vector<std::string>({"", "", "", ""}));
+}

tests/sla_print/sla_print_tests.cpp

@@ -31,8 +31,6 @@
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/ExtrusionEntity.hpp"
 
-using namespace Slic3r;
-
 namespace {
 
 const char *const BELOW_PAD_TEST_OBJECTS[] = {

tests/sla_print/sla_test_utils.cpp

@@ -36,8 +36,6 @@
 #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,

tests/sla_print/sla_test_utils.hpp

@@ -33,31 +33,33 @@ 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 Slic3r::TriangleMesh &input_mesh,
+void check_validity(const TriangleMesh &input_mesh,
                     int flags = ASSUME_NO_EMPTY | ASSUME_MANIFOLD |
                                 ASSUME_NO_REPAIR);
 
 struct PadByproducts
 {
-    Slic3r::ExPolygons   model_contours;
-    Slic3r::ExPolygons   support_contours;
-    Slic3r::TriangleMesh mesh;
+    ExPolygons   model_contours;
+    ExPolygons   support_contours;
+    TriangleMesh mesh;
 };
 
-void test_concave_hull(const Slic3r::ExPolygons &polys);
+void test_concave_hull(const ExPolygons &polys);
 
 void test_pad(const std::string &   obj_filename,
-              const Slic3r::sla::PadConfig &padcfg,
+              const sla::PadConfig &padcfg,
               PadByproducts &       out);
 
 inline void test_pad(const std::string &   obj_filename,
-              const Slic3r::sla::PadConfig &padcfg = {})
+              const sla::PadConfig &padcfg = {})
 {
     PadByproducts byproducts;
     test_pad(obj_filename, padcfg, byproducts);
@@ -67,53 +69,53 @@ struct SupportByproducts
 {
     std::string             obj_fname;
     std::vector<float>      slicegrid;
-    std::vector<Slic3r::ExPolygons> model_slices;
-    Slic3r::sla::SupportTreeBuilder supporttree;
-    Slic3r::TriangleMesh            input_mesh;
+    std::vector<ExPolygons> model_slices;
+    sla::SupportTreeBuilder supporttree;
+    TriangleMesh            input_mesh;
 };
 
 const constexpr float CLOSING_RADIUS = 0.005f;
 
-void check_support_tree_integrity(const Slic3r::sla::SupportTreeBuilder &stree,
-                                  const Slic3r::sla::SupportTreeConfig &cfg);
+void check_support_tree_integrity(const sla::SupportTreeBuilder &stree,
+                                  const sla::SupportTreeConfig &cfg);
 
 void test_supports(const std::string          &obj_filename,
-                   const Slic3r::sla::SupportTreeConfig   &supportcfg,
-                   const Slic3r::sla::HollowingConfig &hollowingcfg,
-                   const Slic3r::sla::DrainHoles      &drainholes,
+                   const sla::SupportTreeConfig   &supportcfg,
+                   const sla::HollowingConfig &hollowingcfg,
+                   const sla::DrainHoles      &drainholes,
                    SupportByproducts          &out);
 
 inline void test_supports(const std::string &obj_filename,
-                   const Slic3r::sla::SupportTreeConfig &supportcfg,
+                   const sla::SupportTreeConfig &supportcfg,
                    SupportByproducts        &out) 
 {
-    Slic3r::sla::HollowingConfig hcfg;
+    sla::HollowingConfig hcfg;
     hcfg.enabled = false;
     test_supports(obj_filename, supportcfg, hcfg, {}, out);    
 }
 
 inline void test_supports(const std::string &obj_filename,
-                   const Slic3r::sla::SupportTreeConfig &supportcfg = {})
+                   const sla::SupportTreeConfig &supportcfg = {})
 {
     SupportByproducts byproducts;
     test_supports(obj_filename, supportcfg, byproducts);
 }
 
-void export_failed_case(const std::vector<Slic3r::ExPolygons> &support_slices,
+void export_failed_case(const std::vector<ExPolygons> &support_slices,
                         const SupportByproducts &byproducts);
 
 
 void test_support_model_collision(
     const std::string          &obj_filename,
-    const Slic3r::sla::SupportTreeConfig   &input_supportcfg,
-    const Slic3r::sla::HollowingConfig &hollowingcfg,
-    const Slic3r::sla::DrainHoles      &drainholes);
+    const sla::SupportTreeConfig   &input_supportcfg,
+    const sla::HollowingConfig &hollowingcfg,
+    const sla::DrainHoles      &drainholes);
 
 inline void test_support_model_collision(
     const std::string        &obj_filename,
-    const Slic3r::sla::SupportTreeConfig &input_supportcfg = {}) 
+    const sla::SupportTreeConfig &input_supportcfg = {}) 
 {
-    Slic3r::sla::HollowingConfig hcfg;
+    sla::HollowingConfig hcfg;
     hcfg.enabled = false;
     test_support_model_collision(obj_filename, input_supportcfg, hcfg, {});
 }
@@ -154,8 +156,8 @@ template <class I, class II> void test_pairhash()
         
         REQUIRE(a != b);
         
-        II hash_ab = Slic3r::sla::pairhash<I, II>(a, b);
-        II hash_ba = Slic3r::sla::pairhash<I, II>(b, a);
+        II hash_ab = sla::pairhash<I, II>(a, b);
+        II hash_ba = sla::pairhash<I, II>(b, a);
         REQUIRE(hash_ab == hash_ba);
         
         auto it = ints.find(hash_ab);
@@ -178,23 +180,23 @@ static constexpr const TPixel FullBlack = 0;
 
 template <class A, int N> constexpr int arraysize(const A (&)[N]) { return N; }
 
-void check_raster_transformations(Slic3r::sla::RasterBase::Orientation o,
-                                  Slic3r::sla::RasterBase::TMirroring  mirroring);
+void check_raster_transformations(sla::RasterBase::Orientation o,
+                                  sla::RasterBase::TMirroring  mirroring);
 
-Slic3r::ExPolygon square_with_hole(double v);
+ExPolygon square_with_hole(double v);
 
-inline double pixel_area(TPixel px, const Slic3r::sla::PixelDim &pxdim)
+inline double pixel_area(TPixel px, const sla::PixelDim &pxdim)
 {
     return (pxdim.h_mm * pxdim.w_mm) * px * 1. / (FullWhite - FullBlack);
 }
 
-double raster_white_area(const Slic3r::sla::RasterGrayscaleAA &raster);
-long raster_pxsum(const Slic3r::sla::RasterGrayscaleAA &raster);
+double raster_white_area(const sla::RasterGrayscaleAA &raster);
+long raster_pxsum(const sla::RasterGrayscaleAA &raster);
 
-double predict_error(const Slic3r::ExPolygon &p, const Slic3r::sla::PixelDim &pd);
+double predict_error(const ExPolygon &p, const sla::PixelDim &pd);
 
-Slic3r::sla::SupportPoints calc_support_pts(
-    const Slic3r::TriangleMesh &                      mesh,
-    const Slic3r::sla::SupportPointGenerator::Config &cfg = {});
+sla::SupportPoints calc_support_pts(
+    const TriangleMesh &                      mesh,
+    const sla::SupportPointGenerator::Config &cfg = {});
 
 #endif // SLA_TEST_UTILS_HPP