Merge branch 'tm_SPE-1866'

src/libslic3r/Arrange/ArrangeImpl.hpp

@@ -444,7 +444,7 @@ ArrItem AdvancedItemConverter<ArrItem>::get_arritem(const Arrangeable &arrbl,
 
     auto simpl_tol = static_cast<double>(this->simplification_tolerance());
 
-    if (simpl_tol > 0)
+    if (simpl_tol > 0.)
     {
         outline = expolygons_simplify(outline, simpl_tol);
         if (!envelope.empty())

src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.cpp

@@ -7,6 +7,11 @@
 namespace Slic3r {
 
 ArrangeSettingsDb_AppCfg::ArrangeSettingsDb_AppCfg(AppConfig *appcfg) : m_appcfg{appcfg}
+{
+    sync();
+}
+
+void ArrangeSettingsDb_AppCfg::sync()
 {
     m_settings_fff.postfix = "_fff";
     m_settings_fff_seq.postfix = "_fff_seq_print";
@@ -39,16 +44,6 @@ ArrangeSettingsDb_AppCfg::ArrangeSettingsDb_AppCfg(AppConfig *appcfg) : m_appcfg
     std::string en_rot_sla_str =
         m_appcfg->get("arrange", "enable_rotation_sla");
 
-    //    std::string alignment_fff_str =
-    //        m_appcfg->get("arrange", "alignment_fff");
-
-    //    std::string alignment_fff_seqp_str =
-    //        m_appcfg->get("arrange", "alignment_fff_seq_pring");
-
-    //    std::string alignment_sla_str =
-    //        m_appcfg->get("arrange", "alignment_sla");
-
-    // Override default alignment and save save/load it to a temporary slot "alignment_xl"
     std::string alignment_xl_str =
         m_appcfg->get("arrange", "alignment_xl");
 
@@ -60,71 +55,64 @@ ArrangeSettingsDb_AppCfg::ArrangeSettingsDb_AppCfg(AppConfig *appcfg) : m_appcfg
 
     if (!dist_fff_str.empty())
         m_settings_fff.vals.d_obj = string_to_float_decimal_point(dist_fff_str);
+    else
+        m_settings_fff.vals.d_obj = m_settings_fff.defaults.d_obj;
 
     if (!dist_bed_fff_str.empty())
         m_settings_fff.vals.d_bed = string_to_float_decimal_point(dist_bed_fff_str);
+    else
+        m_settings_fff.vals.d_bed = m_settings_fff.defaults.d_bed;
 
     if (!dist_fff_seq_print_str.empty())
         m_settings_fff_seq.vals.d_obj = string_to_float_decimal_point(dist_fff_seq_print_str);
+    else
+        m_settings_fff_seq.vals.d_obj = m_settings_fff_seq.defaults.d_obj;
 
     if (!dist_bed_fff_seq_print_str.empty())
         m_settings_fff_seq.vals.d_bed = string_to_float_decimal_point(dist_bed_fff_seq_print_str);
+    else
+        m_settings_fff_seq.vals.d_bed = m_settings_fff_seq.defaults.d_bed;
 
     if (!dist_sla_str.empty())
         m_settings_sla.vals.d_obj = string_to_float_decimal_point(dist_sla_str);
+    else
+        m_settings_sla.vals.d_obj = m_settings_sla.defaults.d_obj;
 
     if (!dist_bed_sla_str.empty())
         m_settings_sla.vals.d_bed = string_to_float_decimal_point(dist_bed_sla_str);
+    else
+        m_settings_sla.vals.d_bed = m_settings_sla.defaults.d_bed;
 
     if (!en_rot_fff_str.empty())
         m_settings_fff.vals.rotations = (en_rot_fff_str == "1" || en_rot_fff_str == "yes");
 
     if (!en_rot_fff_seqp_str.empty())
         m_settings_fff_seq.vals.rotations = (en_rot_fff_seqp_str == "1" || en_rot_fff_seqp_str == "yes");
+    else
+        m_settings_fff_seq.vals.rotations = m_settings_fff_seq.defaults.rotations;
 
     if (!en_rot_sla_str.empty())
         m_settings_sla.vals.rotations = (en_rot_sla_str == "1" || en_rot_sla_str == "yes");
+    else
+        m_settings_sla.vals.rotations = m_settings_sla.defaults.rotations;
 
-    //    if (!alignment_sla_str.empty())
-    //        m_arrange_settings_sla.alignment = std::stoi(alignment_sla_str);
-
-    //    if (!alignment_fff_str.empty())
-    //        m_arrange_settings_fff.alignment = std::stoi(alignment_fff_str);
-
-    //    if (!alignment_fff_seqp_str.empty())
-    //        m_arrange_settings_fff_seq_print.alignment = std::stoi(alignment_fff_seqp_str);
-
-    // Override default alignment and save save/load it to a temporary slot "alignment_xl"
-    ArrangeSettingsView::XLPivots arr_alignment = ArrangeSettingsView::xlpFrontLeft;
-    if (!alignment_xl_str.empty()) {
-        int align_val = std::stoi(alignment_xl_str);
-
-        if (align_val >= 0 && align_val < ArrangeSettingsView::xlpCount)
-            arr_alignment =
-                static_cast<ArrangeSettingsView::XLPivots>(align_val);
-    }
+    // Override default alignment and save/load it to a temporary slot "alignment_xl"
+    auto arr_alignment = ArrangeSettingsView::to_xl_pivots(alignment_xl_str)
+                             .value_or(m_settings_fff.defaults.xl_align);
 
     m_settings_sla.vals.xl_align = arr_alignment ;
     m_settings_fff.vals.xl_align = arr_alignment ;
     m_settings_fff_seq.vals.xl_align = arr_alignment ;
 
-    ArrangeSettingsView::GeometryHandling geom_handl = arr2::ArrangeSettingsView::ghConvex;
-    if (!geom_handling_str.empty()) {
-        int gh = std::stoi(geom_handling_str);
-        if(gh >= 0 && gh < ArrangeSettingsView::GeometryHandling::ghCount)
-            geom_handl = static_cast<ArrangeSettingsView::GeometryHandling>(gh);
-    }
+    auto geom_handl = ArrangeSettingsView::to_geometry_handling(geom_handling_str)
+                          .value_or(m_settings_fff.defaults.geom_handling);
 
     m_settings_sla.vals.geom_handling = geom_handl;
     m_settings_fff.vals.geom_handling = geom_handl;
     m_settings_fff_seq.vals.geom_handling = geom_handl;
 
-    ArrangeSettingsView::ArrangeStrategy arr_strategy = arr2::ArrangeSettingsView::asAuto;
-    if (!strategy_str.empty()) {
-        int strateg = std::stoi(strategy_str);
-        if(strateg >= 0 && strateg < ArrangeSettingsView::ArrangeStrategy::asCount)
-            arr_strategy = static_cast<ArrangeSettingsView::ArrangeStrategy>(strateg);
-    }
+    auto arr_strategy = ArrangeSettingsView::to_arrange_strategy(strategy_str)
+                            .value_or(m_settings_fff.defaults.arr_strategy);
 
     m_settings_sla.vals.arr_strategy = arr_strategy;
     m_settings_fff.vals.arr_strategy = arr_strategy;
@@ -177,7 +165,7 @@ arr2::ArrangeSettingsDb& ArrangeSettingsDb_AppCfg::set_rotation_enabled(bool v)
 arr2::ArrangeSettingsDb& ArrangeSettingsDb_AppCfg::set_xl_alignment(XLPivots v)
 {
     m_settings_fff.vals.xl_align = v;
-    m_appcfg->set("arrange", "alignment_xl", std::to_string(v));
+    m_appcfg->set("arrange", "alignment_xl", std::string{get_label(v)});
 
     return *this;
 }
@@ -185,7 +173,7 @@ arr2::ArrangeSettingsDb& ArrangeSettingsDb_AppCfg::set_xl_alignment(XLPivots v)
 arr2::ArrangeSettingsDb& ArrangeSettingsDb_AppCfg::set_geometry_handling(GeometryHandling v)
 {
     m_settings_fff.vals.geom_handling = v;
-    m_appcfg->set("arrange", "geometry_handling", std::to_string(v));
+    m_appcfg->set("arrange", "geometry_handling", std::string{get_label(v)});
 
     return *this;
 }
@@ -193,7 +181,7 @@ arr2::ArrangeSettingsDb& ArrangeSettingsDb_AppCfg::set_geometry_handling(Geometr
 arr2::ArrangeSettingsDb& ArrangeSettingsDb_AppCfg::set_arrange_strategy(ArrangeStrategy v)
 {
     m_settings_fff.vals.arr_strategy = v;
-    m_appcfg->set("arrange", "arrange_strategy", std::to_string(v));
+    m_appcfg->set("arrange", "arrange_strategy", std::string{get_label(v)});
 
     return *this;
 }

src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.hpp

@@ -55,6 +55,8 @@ private:
 public:
     explicit ArrangeSettingsDb_AppCfg(AppConfig *appcfg);
 
+    void sync();
+
     float get_distance_from_objects() const override { return get_ref(this).d_obj; }
     float get_distance_from_bed() const  override { return get_ref(this).d_bed; }
     bool  is_rotation_enabled() const override { return get_ref(this).rotations; }

src/libslic3r/Arrange/ArrangeSettingsView.hpp

@@ -5,8 +5,15 @@
 #ifndef ARRANGESETTINGSVIEW_HPP
 #define ARRANGESETTINGSVIEW_HPP
 
+#include <string_view>
+#include <array>
+
+#include "libslic3r/StaticMap.hpp"
+
 namespace Slic3r { namespace arr2 {
 
+using namespace std::string_view_literals;
+
 class ArrangeSettingsView
 {
 public:
@@ -31,6 +38,115 @@ public:
     virtual XLPivots         get_xl_alignment() const      = 0;
     virtual GeometryHandling get_geometry_handling() const = 0;
     virtual ArrangeStrategy  get_arrange_strategy() const  = 0;
+
+    static constexpr std::string_view get_label(GeometryHandling v)
+    {
+        constexpr auto STR = std::array{
+            "0"sv, // convex
+            "1"sv, // balanced
+            "2"sv, // advanced
+            "-1"sv, // undefined
+        };
+
+        return STR[v];
+    }
+
+    static constexpr std::string_view get_label(ArrangeStrategy v)
+    {
+        constexpr auto STR = std::array{
+            "0"sv, // auto
+            "1"sv, // pulltocenter
+            "-1"sv, // undefined
+        };
+
+        return STR[v];
+    }
+
+    static constexpr std::string_view get_label(XLPivots v)
+    {
+        constexpr auto STR = std::array{
+            "0"sv, // center
+            "1"sv, // rearleft
+            "2"sv, // frontleft
+            "3"sv, // frontright
+            "4"sv, // rearright
+            "5"sv, // random
+            "-1"sv, // undefined
+        };
+
+        return STR[v];
+    }
+
+private:
+
+    template<class EnumType, size_t N>
+    using EnumMap = StaticMap<std::string_view, EnumType, N>;
+
+    template<class EnumType, size_t N>
+    static constexpr std::optional<EnumType> get_enumval(std::string_view str,
+                                                         const EnumMap<EnumType, N> &emap)
+    {
+        std::optional<EnumType> ret;
+
+        if (auto v = query(emap, str); v.has_value()) {
+            ret = *v;
+        }
+
+        return ret;
+    }
+
+public:
+
+    static constexpr std::optional<GeometryHandling> to_geometry_handling(std::string_view str)
+    {
+        return get_enumval(str, GeometryHandlingLabels);
+    }
+
+    static constexpr std::optional<ArrangeStrategy> to_arrange_strategy(std::string_view str)
+    {
+        return get_enumval(str, ArrangeStrategyLabels);
+    }
+
+    static constexpr std::optional<XLPivots> to_xl_pivots(std::string_view str)
+    {
+        return get_enumval(str, XLPivotsLabels);
+    }
+
+private:
+
+    static constexpr const auto GeometryHandlingLabels = make_staticmap<std::string_view, GeometryHandling>({
+        {"convex"sv, ghConvex},
+        {"balanced"sv, ghBalanced},
+        {"advanced"sv, ghAdvanced},
+
+        {"0"sv, ghConvex},
+        {"1"sv, ghBalanced},
+        {"2"sv, ghAdvanced},
+    });
+
+    static constexpr const auto ArrangeStrategyLabels = make_staticmap<std::string_view, ArrangeStrategy>({
+        {"auto"sv, asAuto},
+        {"pulltocenter"sv, asPullToCenter},
+
+        {"0"sv, asAuto},
+        {"1"sv, asPullToCenter}
+    });
+
+    static constexpr const auto XLPivotsLabels = make_staticmap<std::string_view, XLPivots>({
+        {"center"sv,     xlpCenter },
+        {"rearleft"sv,   xlpRearLeft },
+        {"frontleft"sv,  xlpFrontLeft },
+        {"frontright"sv, xlpFrontRight },
+        {"rearright"sv,  xlpRearRight },
+        {"random"sv,     xlpRandom },
+
+        {"0"sv, xlpCenter },
+        {"1"sv, xlpRearLeft },
+        {"2"sv, xlpFrontLeft },
+        {"3"sv, xlpFrontRight },
+        {"4"sv, xlpRearRight },
+        {"5"sv, xlpRandom }
+    });
 };
 
 class ArrangeSettingsDb: public ArrangeSettingsView

src/slic3r/GUI/GLCanvas3D.cpp

@@ -1642,7 +1642,6 @@ void GLCanvas3D::set_config(const DynamicPrintConfig* config)
     m_config = config;
     m_layers_editing.set_config(config);
 
-
     if (config) {
         PrinterTechnology ptech = current_printer_technology();
 
@@ -1663,7 +1662,14 @@ void GLCanvas3D::set_config(const DynamicPrintConfig* config)
         double objdst = min_object_distance(*config);
         double min_obj_dst = slot == ArrangeSettingsDb_AppCfg::slotFFFSeqPrint ? objdst : 0.;
         m_arrange_settings_db.set_distance_from_obj_range(slot, min_obj_dst, 100.);
-        m_arrange_settings_db.get_defaults(slot).d_obj = objdst;
+        
+        if (std::abs(m_arrange_settings_db.get_defaults(slot).d_obj - objdst) > EPSILON) {
+            m_arrange_settings_db.get_defaults(slot).d_obj = objdst;
+
+            // Defaults have changed, so let's sync with the app config and fill
+            // in the missing values with the new defaults.
+            m_arrange_settings_db.sync();
+        }
     }
 }