From e3c33844d5d89b2bf61aa781cca2cb963d9bef59 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hejl?= <hejl.lukas@gmail.com>
Date: Mon, 19 Apr 2021 07:01:11 +0200
Subject: [PATCH] WIP: Duplicated the FDM support gizmo for the MMU
 segmentation

---
 src/libslic3r/Format/3mf.cpp                  |  18 +-
 src/libslic3r/Model.cpp                       |  13 +
 src/libslic3r/Model.hpp                       |  34 +-
 src/libslic3r/Print.cpp                       |   2 +
 src/slic3r/CMakeLists.txt                     |   2 +
 src/slic3r/GUI/GLCanvas3D.cpp                 |  12 +-
 .../GUI/Gizmos/GLGizmoMmuSegmentation.cpp     | 358 ++++++++++++++++++
 .../GUI/Gizmos/GLGizmoMmuSegmentation.hpp     |  46 +++
 src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp  |   4 +-
 src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp  |   3 +-
 src/slic3r/GUI/Gizmos/GLGizmos.hpp            |   1 +
 src/slic3r/GUI/Gizmos/GLGizmosManager.cpp     |  23 +-
 src/slic3r/GUI/Gizmos/GLGizmosManager.hpp     |   1 +
 src/slic3r/GUI/Plater.cpp                     |   6 +-
 14 files changed, 498 insertions(+), 25 deletions(-)
 create mode 100644 src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp
 create mode 100644 src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.hpp

diff --git a/src/libslic3r/Format/3mf.cpp b/src/libslic3r/Format/3mf.cpp
index 152d72079..631f4769c 100644
--- a/src/libslic3r/Format/3mf.cpp
+++ b/src/libslic3r/Format/3mf.cpp
@@ -95,6 +95,7 @@ static constexpr const char* PRINTABLE_ATTR = "printable";
 static constexpr const char* INSTANCESCOUNT_ATTR = "instances_count";
 static constexpr const char* CUSTOM_SUPPORTS_ATTR = "slic3rpe:custom_supports";
 static constexpr const char* CUSTOM_SEAM_ATTR = "slic3rpe:custom_seam";
+static constexpr const char* MMU_SEGMENTATION_ATTR = "slic3rpe:mmu_segmentation";
 
 static constexpr const char* KEY_ATTR = "key";
 static constexpr const char* VALUE_ATTR = "value";
@@ -289,6 +290,7 @@ namespace Slic3r {
             std::vector<unsigned int> triangles;
             std::vector<std::string> custom_supports;
             std::vector<std::string> custom_seam;
+            std::vector<std::string> mmu_segmentation;
 
             bool empty() { return vertices.empty() || triangles.empty(); }
 
@@ -297,6 +299,7 @@ namespace Slic3r {
                 triangles.clear();
                 custom_supports.clear();
                 custom_seam.clear();
+                mmu_segmentation.clear();
             }
         };
 
@@ -1564,6 +1567,7 @@ namespace Slic3r {
 
         m_curr_object.geometry.custom_supports.push_back(get_attribute_value_string(attributes, num_attributes, CUSTOM_SUPPORTS_ATTR));
         m_curr_object.geometry.custom_seam.push_back(get_attribute_value_string(attributes, num_attributes, CUSTOM_SEAM_ATTR));
+        m_curr_object.geometry.mmu_segmentation.push_back(get_attribute_value_string(attributes, num_attributes, MMU_SEGMENTATION_ATTR));
         return true;
     }
 
@@ -1888,15 +1892,18 @@ namespace Slic3r {
                 volume->source.transform = Slic3r::Geometry::Transformation(volume_matrix_to_object);
             volume->calculate_convex_hull();
 
-            // recreate custom supports and seam from previously loaded attribute
+            // recreate custom supports, seam and mmu segmentation from previously loaded attribute
             for (unsigned i=0; i<triangles_count; ++i) {
                 size_t index = src_start_id/3 + i;
                 assert(index < geometry.custom_supports.size());
                 assert(index < geometry.custom_seam.size());
+                assert(index < geometry.mmu_segmentation.size());
                 if (! geometry.custom_supports[index].empty())
                     volume->supported_facets.set_triangle_from_string(i, geometry.custom_supports[index]);
                 if (! geometry.custom_seam[index].empty())
                     volume->seam_facets.set_triangle_from_string(i, geometry.custom_seam[index]);
+                if (! geometry.mmu_segmentation[index].empty())
+                    volume->mmu_segmentation_facets.set_triangle_from_string(i, geometry.mmu_segmentation[index]);
             }
 
 
@@ -2530,6 +2537,15 @@ namespace Slic3r {
                     output_buffer += "\"";
                 }
 
+                std::string mmu_painting_data_string = volume->mmu_segmentation_facets.get_triangle_as_string(i);
+                if (! mmu_painting_data_string.empty()) {
+                    output_buffer += " ";
+                    output_buffer += MMU_SEGMENTATION_ATTR;
+                    output_buffer += "=\"";
+                    output_buffer += mmu_painting_data_string;
+                    output_buffer += "\"";
+                }
+
                 output_buffer += "/>\n";
 
                 if (! flush())
diff --git a/src/libslic3r/Model.cpp b/src/libslic3r/Model.cpp
index d48443181..ddfa26552 100644
--- a/src/libslic3r/Model.cpp
+++ b/src/libslic3r/Model.cpp
@@ -1086,6 +1086,7 @@ void ModelObject::convert_units(ModelObjectPtrs& new_objects, ConversionType con
 
             vol->supported_facets.assign(volume->supported_facets);
             vol->seam_facets.assign(volume->seam_facets);
+            vol->mmu_segmentation_facets.assign(volume->mmu_segmentation_facets);
 
             // Perform conversion only if the target "imperial" state is different from the current one.
             // This check supports conversion of "mixed" set of volumes, each with different "imperial" state.
@@ -1187,6 +1188,7 @@ ModelObjectPtrs ModelObject::cut(size_t instance, coordf_t z, bool keep_upper, b
 
         volume->supported_facets.clear();
         volume->seam_facets.clear();
+        volume->mmu_segmentation_facets.clear();
 
         if (! volume->is_model_part()) {
             // Modifiers are not cut, but we still need to add the instance transformation
@@ -1780,6 +1782,7 @@ void ModelVolume::assign_new_unique_ids_recursive()
     config.set_new_unique_id();
     supported_facets.set_new_unique_id();
     seam_facets.set_new_unique_id();
+    mmu_segmentation_facets.set_new_unique_id();
 }
 
 void ModelVolume::rotate(double angle, Axis axis)
@@ -2096,6 +2099,16 @@ bool model_custom_seam_data_changed(const ModelObject& mo, const ModelObject& mo
     return false;
 }
 
+bool model_mmu_segmentation_data_changed(const ModelObject& mo, const ModelObject& mo_new) {
+    assert(! model_volume_list_changed(mo, mo_new, ModelVolumeType::MODEL_PART));
+    assert(mo.volumes.size() == mo_new.volumes.size());
+    for (size_t i=0; i<mo_new.volumes.size(); ++i) {
+        if (! mo_new.volumes[i]->mmu_segmentation_facets.timestamp_matches(mo.volumes[i]->mmu_segmentation_facets))
+            return true;
+    }
+    return false;
+}
+
 extern bool model_has_multi_part_objects(const Model &model)
 {
     for (const ModelObject *model_object : model.objects)
diff --git a/src/libslic3r/Model.hpp b/src/libslic3r/Model.hpp
index 868639ee8..0fce954ff 100644
--- a/src/libslic3r/Model.hpp
+++ b/src/libslic3r/Model.hpp
@@ -588,6 +588,9 @@ public:
     // List of seam enforcers/blockers.
     FacetsAnnotation    seam_facets;
 
+    // List of mesh facets painted for MMU segmentation.
+    FacetsAnnotation    mmu_segmentation_facets;
+
     // A parent object owning this modifier volume.
     ModelObject*        get_object() const { return this->object; }
     ModelVolumeType     type() const { return m_type; }
@@ -675,6 +678,7 @@ public:
         this->config.set_new_unique_id();
         this->supported_facets.set_new_unique_id();
         this->seam_facets.set_new_unique_id();
+        this->mmu_segmentation_facets.set_new_unique_id();
     }
 
 protected:
@@ -713,22 +717,26 @@ private:
 		assert(this->id().valid()); 
         assert(this->config.id().valid()); 
         assert(this->supported_facets.id().valid()); 
-        assert(this->seam_facets.id().valid()); 
+        assert(this->seam_facets.id().valid());
+        assert(this->mmu_segmentation_facets.id().valid());
         assert(this->id() != this->config.id());
         assert(this->id() != this->supported_facets.id());
         assert(this->id() != this->seam_facets.id());
+        assert(this->id() != this->mmu_segmentation_facets.id());
         if (mesh.stl.stats.number_of_facets > 1)
             calculate_convex_hull();
     }
     ModelVolume(ModelObject *object, TriangleMesh &&mesh, TriangleMesh &&convex_hull) :
 		m_mesh(new TriangleMesh(std::move(mesh))), m_convex_hull(new TriangleMesh(std::move(convex_hull))), m_type(ModelVolumeType::MODEL_PART), object(object) {
 		assert(this->id().valid()); 
-        assert(this->config.id().valid()); 
-        assert(this->supported_facets.id().valid()); 
-        assert(this->seam_facets.id().valid()); 
+        assert(this->config.id().valid());
+        assert(this->supported_facets.id().valid());
+        assert(this->seam_facets.id().valid());
+        assert(this->mmu_segmentation_facets.id().valid());
         assert(this->id() != this->config.id());
         assert(this->id() != this->supported_facets.id());
         assert(this->id() != this->seam_facets.id());
+        assert(this->id() != this->mmu_segmentation_facets.id());
 	}
 
     // Copying an existing volume, therefore this volume will get a copy of the ID assigned.
@@ -736,19 +744,22 @@ private:
         ObjectBase(other),
         name(other.name), source(other.source), m_mesh(other.m_mesh), m_convex_hull(other.m_convex_hull),
         config(other.config), m_type(other.m_type), object(object), m_transformation(other.m_transformation),
-        supported_facets(other.supported_facets), seam_facets(other.seam_facets)
+        supported_facets(other.supported_facets), seam_facets(other.seam_facets), mmu_segmentation_facets(other.mmu_segmentation_facets)
     {
 		assert(this->id().valid()); 
         assert(this->config.id().valid()); 
         assert(this->supported_facets.id().valid());
         assert(this->seam_facets.id().valid());
+        assert(this->mmu_segmentation_facets.id().valid());
         assert(this->id() != this->config.id());
         assert(this->id() != this->supported_facets.id());
         assert(this->id() != this->seam_facets.id());
+        assert(this->id() != this->mmu_segmentation_facets.id());
 		assert(this->id() == other.id());
         assert(this->config.id() == other.config.id());
         assert(this->supported_facets.id() == other.supported_facets.id());
         assert(this->seam_facets.id() == other.seam_facets.id());
+        assert(this->mmu_segmentation_facets.id() == other.mmu_segmentation_facets.id());
         this->set_material_id(other.material_id());
     }
     // Providing a new mesh, therefore this volume will get a new unique ID assigned.
@@ -759,9 +770,11 @@ private:
         assert(this->config.id().valid()); 
         assert(this->supported_facets.id().valid());
         assert(this->seam_facets.id().valid());
+        assert(this->mmu_segmentation_facets.id().valid());
         assert(this->id() != this->config.id());
         assert(this->id() != this->supported_facets.id());
         assert(this->id() != this->seam_facets.id());
+        assert(this->id() != this->mmu_segmentation_facets.id());
 		assert(this->id() != other.id());
         assert(this->config.id() == other.config.id());
         this->set_material_id(other.material_id());
@@ -772,9 +785,11 @@ private:
         assert(this->config.id() != other.config.id()); 
         assert(this->supported_facets.id() != other.supported_facets.id());
         assert(this->seam_facets.id() != other.seam_facets.id());
+        assert(this->mmu_segmentation_facets.id() != other.mmu_segmentation_facets.id());
         assert(this->id() != this->config.id());
         assert(this->supported_facets.empty());
         assert(this->seam_facets.empty());
+        assert(this->mmu_segmentation_facets.empty());
     }
 
     ModelVolume& operator=(ModelVolume &rhs) = delete;
@@ -782,17 +797,19 @@ private:
 	friend class cereal::access;
 	friend class UndoRedo::StackImpl;
 	// Used for deserialization, therefore no IDs are allocated.
-	ModelVolume() : ObjectBase(-1), config(-1), supported_facets(-1), seam_facets(-1), object(nullptr) {
+	ModelVolume() : ObjectBase(-1), config(-1), supported_facets(-1), seam_facets(-1), mmu_segmentation_facets(-1), object(nullptr) {
 		assert(this->id().invalid());
         assert(this->config.id().invalid());
         assert(this->supported_facets.id().invalid());
         assert(this->seam_facets.id().invalid());
+        assert(this->mmu_segmentation_facets.id().invalid());
 	}
 	template<class Archive> void load(Archive &ar) {
 		bool has_convex_hull;
         ar(name, source, m_mesh, m_type, m_material_id, m_transformation, m_is_splittable, has_convex_hull);
         cereal::load_by_value(ar, supported_facets);
         cereal::load_by_value(ar, seam_facets);
+        cereal::load_by_value(ar, mmu_segmentation_facets);
         cereal::load_by_value(ar, config);
 		assert(m_mesh);
 		if (has_convex_hull) {
@@ -808,6 +825,7 @@ private:
         ar(name, source, m_mesh, m_type, m_material_id, m_transformation, m_is_splittable, has_convex_hull);
         cereal::save_by_value(ar, supported_facets);
         cereal::save_by_value(ar, seam_facets);
+        cereal::save_by_value(ar, mmu_segmentation_facets);
         cereal::save_by_value(ar, config);
 		if (has_convex_hull)
 			cereal::save_optional(ar, m_convex_hull);
@@ -1078,6 +1096,10 @@ extern bool model_custom_supports_data_changed(const ModelObject& mo, const Mode
 // The function assumes that volumes list is synchronized.
 extern bool model_custom_seam_data_changed(const ModelObject& mo, const ModelObject& mo_new);
 
+// Test whether the now ModelObject has newer MMU segmentation data than the old one.
+// The function assumes that volumes list is synchronized.
+extern bool model_mmu_segmentation_data_changed(const ModelObject& mo, const ModelObject& mo_new);
+
 // If the model has multi-part objects, then it is currently not supported by the SLA mode.
 // Either the model cannot be loaded, or a SLA printer has to be activated.
 extern bool model_has_multi_part_objects(const Model &model);
diff --git a/src/libslic3r/Print.cpp b/src/libslic3r/Print.cpp
index ce5bf1b29..fbbacad1c 100644
--- a/src/libslic3r/Print.cpp
+++ b/src/libslic3r/Print.cpp
@@ -412,6 +412,8 @@ static inline void model_volume_list_copy_configs(ModelObject &model_object_dst,
         mv_dst.supported_facets.assign(mv_src.supported_facets);
         assert(mv_dst.seam_facets.id() == mv_src.seam_facets.id());
         mv_dst.seam_facets.assign(mv_src.seam_facets);
+        assert(mv_dst.mmu_segmentation_facets.id() == mv_src.mmu_segmentation_facets.id());
+        mv_dst.mmu_segmentation_facets.assign(mv_src.mmu_segmentation_facets);
         //FIXME what to do with the materials?
         // mv_dst.m_material_id = mv_src.m_material_id;
         ++ i_src;
diff --git a/src/slic3r/CMakeLists.txt b/src/slic3r/CMakeLists.txt
index 4b3a1c6ca..62c8172b0 100644
--- a/src/slic3r/CMakeLists.txt
+++ b/src/slic3r/CMakeLists.txt
@@ -57,6 +57,8 @@ set(SLIC3R_GUI_SOURCES
     GUI/Gizmos/GLGizmoPainterBase.hpp
     GUI/Gizmos/GLGizmoSeam.cpp
     GUI/Gizmos/GLGizmoSeam.hpp
+    GUI/Gizmos/GLGizmoMmuSegmentation.cpp
+    GUI/Gizmos/GLGizmoMmuSegmentation.hpp
     GUI/GLSelectionRectangle.cpp
     GUI/GLSelectionRectangle.hpp
     GUI/GLModel.hpp
diff --git a/src/slic3r/GUI/GLCanvas3D.cpp b/src/slic3r/GUI/GLCanvas3D.cpp
index 7bbdc72b1..025b94004 100644
--- a/src/slic3r/GUI/GLCanvas3D.cpp
+++ b/src/slic3r/GUI/GLCanvas3D.cpp
@@ -1347,7 +1347,8 @@ void GLCanvas3D::toggle_model_objects_visibility(bool visible, const ModelObject
                     const GLGizmosManager& gm = get_gizmos_manager();
                     auto gizmo_type = gm.get_current_type();
                     if (    (gizmo_type == GLGizmosManager::FdmSupports
-                          || gizmo_type == GLGizmosManager::Seam)
+                          || gizmo_type == GLGizmosManager::Seam
+                          || gizmo_type == GLGizmosManager::MmuSegmentation)
                         && ! vol->is_modifier)
                         vol->force_neutral_color = true;
                     else
@@ -3227,7 +3228,8 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
         else if (evt.LeftDown() && (evt.ShiftDown() || evt.AltDown()) && m_picking_enabled) {
             if (m_gizmos.get_current_type() != GLGizmosManager::SlaSupports
              && m_gizmos.get_current_type() != GLGizmosManager::FdmSupports
-             && m_gizmos.get_current_type() != GLGizmosManager::Seam) {
+             && m_gizmos.get_current_type() != GLGizmosManager::Seam
+             && m_gizmos.get_current_type() != GLGizmosManager::MmuSegmentation) {
                 m_rectangle_selection.start_dragging(m_mouse.position, evt.ShiftDown() ? GLSelectionRectangle::Select : GLSelectionRectangle::Deselect);
                 m_dirty = true;
             }
@@ -5046,7 +5048,8 @@ void GLCanvas3D::_render_bed(bool bottom, bool show_axes) const
             (m_gizmos.get_current_type() != GLGizmosManager::FdmSupports
           && m_gizmos.get_current_type() != GLGizmosManager::SlaSupports
           && m_gizmos.get_current_type() != GLGizmosManager::Hollow
-          && m_gizmos.get_current_type() != GLGizmosManager::Seam);
+          && m_gizmos.get_current_type() != GLGizmosManager::Seam
+          && m_gizmos.get_current_type() != GLGizmosManager::MmuSegmentation);
 
     wxGetApp().plater()->get_bed().render(const_cast<GLCanvas3D&>(*this), bottom, scale_factor, show_axes, show_texture);
 }
@@ -5104,7 +5107,8 @@ void GLCanvas3D::_render_objects() const
             const GLGizmosManager& gm = get_gizmos_manager();
             GLGizmosManager::EType type = gm.get_current_type();
             if (type == GLGizmosManager::FdmSupports
-             || type == GLGizmosManager::Seam) {
+                || type == GLGizmosManager::Seam
+                || type == GLGizmosManager::MmuSegmentation) {
                 shader->stop_using();
                 gm.render_painter_gizmo();
                 shader->start_using();
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp b/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp
new file mode 100644
index 000000000..e26b0341d
--- /dev/null
+++ b/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp
@@ -0,0 +1,358 @@
+#include "GLGizmoMmuSegmentation.hpp"
+
+#include "libslic3r/Model.hpp"
+
+//#include "slic3r/GUI/3DScene.hpp"
+#include "slic3r/GUI/GLCanvas3D.hpp"
+#include "slic3r/GUI/GUI_App.hpp"
+#include "slic3r/GUI/ImGuiWrapper.hpp"
+#include "slic3r/GUI/Plater.hpp"
+
+
+#include <GL/glew.h>
+
+
+namespace Slic3r {
+
+namespace GUI {
+
+
+
+void GLGizmoMmuSegmentation::on_shutdown()
+{
+    m_angle_threshold_deg = 0.f;
+    m_parent.use_slope(false);
+}
+
+
+
+std::string GLGizmoMmuSegmentation::on_get_name() const
+{
+    // FIXME Lukas H.: Discuss and change shortcut
+    return (_L("MMU painting") + " [N]").ToUTF8().data();
+}
+
+
+
+bool GLGizmoMmuSegmentation::on_init()
+{
+    // FIXME Lukas H.: Discuss and change shortcut
+    m_shortcut_key = WXK_CONTROL_N;
+
+    m_desc["clipping_of_view"] = _L("Clipping of view") + ": ";
+    m_desc["reset_direction"]  = _L("Reset direction");
+    m_desc["cursor_size"]      = _L("Brush size") + ": ";
+    m_desc["cursor_type"]      = _L("Brush shape") + ": ";
+    m_desc["enforce_caption"]  = _L("Left mouse button") + ": ";
+    m_desc["enforce"]          = _L("Enforce supports");
+    m_desc["block_caption"]    = _L("Right mouse button") + ": ";
+    m_desc["block"]            = _L("Block supports");
+    m_desc["remove_caption"]   = _L("Shift + Left mouse button") + ": ";
+    m_desc["remove"]           = _L("Remove selection");
+    m_desc["remove_all"]       = _L("Remove all selection");
+    m_desc["circle"]           = _L("Circle");
+    m_desc["sphere"]           = _L("Sphere");
+    m_desc["highlight_by_angle"] = _L("Highlight by angle");
+    m_desc["enforce_button"]   = _L("Enforce");
+    m_desc["cancel"]           = _L("Cancel");
+
+    return true;
+}
+
+
+
+void GLGizmoMmuSegmentation::render_painter_gizmo() const
+{
+    const Selection& selection = m_parent.get_selection();
+
+    glsafe(::glEnable(GL_BLEND));
+    glsafe(::glEnable(GL_DEPTH_TEST));
+
+    render_triangles(selection);
+
+    m_c->object_clipper()->render_cut();
+    render_cursor();
+
+    glsafe(::glDisable(GL_BLEND));
+}
+
+
+
+void GLGizmoMmuSegmentation::on_render_input_window(float x, float y, float bottom_limit)
+{
+    if (! m_c->selection_info()->model_object())
+        return;
+
+    const float approx_height = m_imgui->scaled(17.0f);
+    y = std::min(y, bottom_limit - approx_height);
+    m_imgui->set_next_window_pos(x, y, ImGuiCond_Always);
+
+    m_imgui->begin(on_get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse);
+
+    // First calculate width of all the texts that are could possibly be shown. We will decide set the dialog width based on that:
+    const float clipping_slider_left = std::max(m_imgui->calc_text_size(m_desc.at("clipping_of_view")).x,
+                                                m_imgui->calc_text_size(m_desc.at("reset_direction")).x)
+                                          + m_imgui->scaled(1.5f);
+    const float cursor_slider_left = m_imgui->calc_text_size(m_desc.at("cursor_size")).x + m_imgui->scaled(1.f);
+    const float autoset_slider_left = m_imgui->calc_text_size(m_desc.at("highlight_by_angle")).x + m_imgui->scaled(1.f);
+    const float cursor_type_radio_left  = m_imgui->calc_text_size(m_desc.at("cursor_type")).x + m_imgui->scaled(1.f);
+    const float cursor_type_radio_width1 = m_imgui->calc_text_size(m_desc["circle"]).x
+                                             + m_imgui->scaled(2.5f);
+    const float cursor_type_radio_width2 = m_imgui->calc_text_size(m_desc["sphere"]).x
+                                             + m_imgui->scaled(2.5f);
+    const float button_width = m_imgui->calc_text_size(m_desc.at("remove_all")).x + m_imgui->scaled(1.f);
+    const float button_enforce_width = m_imgui->calc_text_size(m_desc.at("enforce_button")).x;
+    const float button_cancel_width = m_imgui->calc_text_size(m_desc.at("cancel")).x;
+    const float buttons_width = std::max(button_enforce_width, button_cancel_width) + m_imgui->scaled(0.5f);
+    const float minimal_slider_width = m_imgui->scaled(4.f);
+
+    float caption_max = 0.f;
+    float total_text_max = 0.;
+    for (const std::string& t : {"enforce", "block", "remove"}) {
+        caption_max = std::max(caption_max, m_imgui->calc_text_size(m_desc.at(t+"_caption")).x);
+        total_text_max = std::max(total_text_max, caption_max + m_imgui->calc_text_size(m_desc.at(t)).x);
+    }
+    caption_max += m_imgui->scaled(1.f);
+    total_text_max += m_imgui->scaled(1.f);
+
+    float window_width = minimal_slider_width + std::max(autoset_slider_left, std::max(cursor_slider_left, clipping_slider_left));
+    window_width = std::max(window_width, total_text_max);
+    window_width = std::max(window_width, button_width);
+    window_width = std::max(window_width, cursor_type_radio_left + cursor_type_radio_width1 + cursor_type_radio_width2);
+    window_width = std::max(window_width, 2.f * buttons_width + m_imgui->scaled(1.f));
+
+    auto draw_text_with_caption = [this, &caption_max](const wxString& caption, const wxString& text) {
+        m_imgui->text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, caption);
+        ImGui::SameLine(caption_max);
+        m_imgui->text(text);
+    };
+
+    for (const std::string& t : {"enforce", "block", "remove"})
+        draw_text_with_caption(m_desc.at(t + "_caption"), m_desc.at(t));
+
+    m_imgui->text("");
+    ImGui::Separator();
+
+    m_imgui->text(m_desc["highlight_by_angle"] + ":");
+    ImGui::AlignTextToFramePadding();
+    std::string format_str = std::string("%.f") + I18N::translate_utf8("°",
+        "Degree sign to use in the respective slider in FDM supports gizmo,"
+        "placed after the number with no whitespace in between.");
+    ImGui::SameLine(autoset_slider_left);
+    ImGui::PushItemWidth(window_width - autoset_slider_left);
+    if (m_imgui->slider_float("", &m_angle_threshold_deg, 0.f, 90.f, format_str.data())) {
+        m_parent.set_slope_normal_angle(90.f - m_angle_threshold_deg);
+        if (! m_parent.is_using_slope()) {
+            m_parent.use_slope(true);
+            m_parent.set_as_dirty();
+        }
+    }
+
+    m_imgui->disabled_begin(m_angle_threshold_deg == 0.f);
+    ImGui::NewLine();
+    ImGui::SameLine(window_width - 2.f*buttons_width - m_imgui->scaled(0.5f));
+    if (m_imgui->button(m_desc["enforce_button"], buttons_width, 0.f)) {
+        select_facets_by_angle(m_angle_threshold_deg, false);
+        m_angle_threshold_deg = 0.f;
+    }
+    ImGui::SameLine(window_width - buttons_width);
+    if (m_imgui->button(m_desc["cancel"], buttons_width, 0.f)) {
+        m_angle_threshold_deg = 0.f;
+        m_parent.use_slope(false);
+    }
+    m_imgui->disabled_end();
+
+    ImGui::Separator();
+
+    if (m_imgui->button(m_desc.at("remove_all"))) {
+        Plater::TakeSnapshot(wxGetApp().plater(), wxString(_L("Reset selection")));
+        ModelObject* mo = m_c->selection_info()->model_object();
+        int idx = -1;
+        for (ModelVolume* mv : mo->volumes) {
+            if (mv->is_model_part()) {
+                ++idx;
+                m_triangle_selectors[idx]->reset();
+            }
+        }
+
+        update_model_object();
+        m_parent.set_as_dirty();
+    }
+
+
+    const float max_tooltip_width = ImGui::GetFontSize() * 20.0f;
+
+    ImGui::AlignTextToFramePadding();
+    m_imgui->text(m_desc.at("cursor_size"));
+    ImGui::SameLine(cursor_slider_left);
+    ImGui::PushItemWidth(window_width - cursor_slider_left);
+    ImGui::SliderFloat(" ", &m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f");
+    if (ImGui::IsItemHovered()) {
+        ImGui::BeginTooltip();
+        ImGui::PushTextWrapPos(max_tooltip_width);
+        ImGui::TextUnformatted(_L("Alt + Mouse wheel").ToUTF8().data());
+        ImGui::PopTextWrapPos();
+        ImGui::EndTooltip();
+    }
+
+
+    ImGui::AlignTextToFramePadding();
+    m_imgui->text(m_desc.at("cursor_type"));
+    ImGui::SameLine(cursor_type_radio_left + m_imgui->scaled(0.f));
+    ImGui::PushItemWidth(cursor_type_radio_width1);
+
+    bool sphere_sel = m_cursor_type == TriangleSelector::CursorType::SPHERE;
+    if (m_imgui->radio_button(m_desc["sphere"], sphere_sel))
+        sphere_sel = true;
+
+    if (ImGui::IsItemHovered()) {
+        ImGui::BeginTooltip();
+        ImGui::PushTextWrapPos(max_tooltip_width);
+        ImGui::TextUnformatted(_L("Paints all facets inside, regardless of their orientation.").ToUTF8().data());
+        ImGui::PopTextWrapPos();
+        ImGui::EndTooltip();
+    }
+
+    ImGui::SameLine(cursor_type_radio_left + cursor_type_radio_width2 + m_imgui->scaled(0.f));
+    ImGui::PushItemWidth(cursor_type_radio_width2);
+
+    if (m_imgui->radio_button(m_desc["circle"], ! sphere_sel))
+        sphere_sel = false;
+
+    if (ImGui::IsItemHovered()) {
+        ImGui::BeginTooltip();
+        ImGui::PushTextWrapPos(max_tooltip_width);
+        ImGui::TextUnformatted(_L("Ignores facets facing away from the camera.").ToUTF8().data());
+        ImGui::PopTextWrapPos();
+        ImGui::EndTooltip();
+    }
+
+    m_cursor_type = sphere_sel
+            ? TriangleSelector::CursorType::SPHERE
+            : TriangleSelector::CursorType::CIRCLE;
+
+
+
+
+    ImGui::Separator();
+    if (m_c->object_clipper()->get_position() == 0.f) {
+        ImGui::AlignTextToFramePadding();
+        m_imgui->text(m_desc.at("clipping_of_view"));
+    }
+    else {
+        if (m_imgui->button(m_desc.at("reset_direction"))) {
+            wxGetApp().CallAfter([this](){
+                    m_c->object_clipper()->set_position(-1., false);
+                });
+        }
+    }
+
+    ImGui::SameLine(clipping_slider_left);
+    ImGui::PushItemWidth(window_width - clipping_slider_left);
+    float clp_dist = m_c->object_clipper()->get_position();
+    if (ImGui::SliderFloat("  ", &clp_dist, 0.f, 1.f, "%.2f"))
+    m_c->object_clipper()->set_position(clp_dist, true);
+    if (ImGui::IsItemHovered()) {
+        ImGui::BeginTooltip();
+        ImGui::PushTextWrapPos(max_tooltip_width);
+        ImGui::TextUnformatted(_L("Ctrl + Mouse wheel").ToUTF8().data());
+        ImGui::PopTextWrapPos();
+        ImGui::EndTooltip();
+    }
+    m_imgui->end();
+}
+
+
+
+void GLGizmoMmuSegmentation::select_facets_by_angle(float threshold_deg, bool block)
+{
+    float threshold = (M_PI/180.)*threshold_deg;
+    const Selection& selection = m_parent.get_selection();
+    const ModelObject* mo = m_c->selection_info()->model_object();
+    const ModelInstance* mi = mo->instances[selection.get_instance_idx()];
+
+    int mesh_id = -1;
+    for (const ModelVolume* mv : mo->volumes) {
+        if (! mv->is_model_part())
+            continue;
+
+        ++mesh_id;
+
+        const Transform3d trafo_matrix = mi->get_matrix(true) * mv->get_matrix(true);
+        Vec3f down  = (trafo_matrix.inverse() * (-Vec3d::UnitZ())).cast<float>().normalized();
+        Vec3f limit = (trafo_matrix.inverse() * Vec3d(std::sin(threshold), 0, -std::cos(threshold))).cast<float>().normalized();
+
+        float dot_limit = limit.dot(down);
+
+        // Now calculate dot product of vert_direction and facets' normals.
+        int idx = -1;
+        for (const stl_facet& facet : mv->mesh().stl.facet_start) {
+            ++idx;
+            if (facet.normal.dot(down) > dot_limit)
+                m_triangle_selectors[mesh_id]->set_facet(idx,
+                                                         block
+                                                         ? EnforcerBlockerType::BLOCKER
+                                                         : EnforcerBlockerType::ENFORCER);
+        }
+    }
+
+    activate_internal_undo_redo_stack(true);
+
+    Plater::TakeSnapshot(wxGetApp().plater(), block ? _L("Block supports by angle")
+                                                    : _L("Add supports by angle"));
+    update_model_object();
+    m_parent.set_as_dirty();
+}
+
+
+
+void GLGizmoMmuSegmentation::update_model_object() const
+{
+    bool updated = false;
+    ModelObject* mo = m_c->selection_info()->model_object();
+    int idx = -1;
+    for (ModelVolume* mv : mo->volumes) {
+        if (! mv->is_model_part())
+            continue;
+        ++idx;
+        updated |= mv->mmu_segmentation_facets.set(*m_triangle_selectors[idx].get());
+    }
+
+    if (updated)
+        m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
+}
+
+
+
+void GLGizmoMmuSegmentation::update_from_model_object()
+{
+    wxBusyCursor wait;
+
+    const ModelObject* mo = m_c->selection_info()->model_object();
+    m_triangle_selectors.clear();
+
+    int volume_id = -1;
+    for (const ModelVolume* mv : mo->volumes) {
+        if (! mv->is_model_part())
+            continue;
+
+        ++volume_id;
+
+        // This mesh does not account for the possible Z up SLA offset.
+        const TriangleMesh* mesh = &mv->mesh();
+
+        m_triangle_selectors.emplace_back(std::make_unique<TriangleSelectorGUI>(*mesh));
+        m_triangle_selectors.back()->deserialize(mv->mmu_segmentation_facets.get_data());
+    }
+}
+
+
+
+PainterGizmoType GLGizmoMmuSegmentation::get_painter_type() const
+{
+    return PainterGizmoType::MMU_SEGMENTATION;
+}
+
+
+} // namespace GUI
+} // namespace Slic3r
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.hpp b/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.hpp
new file mode 100644
index 000000000..9511b56a4
--- /dev/null
+++ b/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.hpp
@@ -0,0 +1,46 @@
+#ifndef slic3r_GLGizmoMmuSegmentation_hpp_
+#define slic3r_GLGizmoMmuSegmentation_hpp_
+
+#include "GLGizmoPainterBase.hpp"
+
+namespace Slic3r {
+
+namespace GUI {
+
+class GLGizmoMmuSegmentation : public GLGizmoPainterBase
+{
+public:
+    GLGizmoMmuSegmentation(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
+        : GLGizmoPainterBase(parent, icon_filename, sprite_id) {}
+
+    void render_painter_gizmo() const override;
+
+protected:
+    void on_render_input_window(float x, float y, float bottom_limit) override;
+    std::string on_get_name() const override;
+
+private:
+    bool on_init() override;
+
+    void update_model_object() const override;
+    void update_from_model_object() override;
+
+    void on_opening() override {}
+    void on_shutdown() override;
+    PainterGizmoType get_painter_type() const override;
+
+    void select_facets_by_angle(float threshold, bool block);
+    float m_angle_threshold_deg = 0.f;
+
+    // This map holds all translated description texts, so they can be easily referenced during layout calculations
+    // etc. When language changes, GUI is recreated and this class constructed again, so the change takes effect.
+    std::map<std::string, wxString> m_desc;
+};
+
+
+
+} // namespace GUI
+} // namespace Slic3r
+
+
+#endif // slic3r_GLGizmoMmuSegmentation_hpp_
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp b/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp
index 91aef75d9..c6b5bbc8e 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp
@@ -37,7 +37,7 @@ void GLGizmoPainterBase::activate_internal_undo_redo_stack(bool activate)
     if (activate && ! m_internal_stack_active) {
         wxString str = get_painter_type() == PainterGizmoType::FDM_SUPPORTS
                            ? _L("Entering Paint-on supports")
-                           : _L("Entering Seam painting");
+                           : (get_painter_type() == PainterGizmoType::MMU_SEGMENTATION ? _L("Entering MMU segmentation") : _L("Entering Seam painting"));
         Plater::TakeSnapshot(wxGetApp().plater(), str);
         wxGetApp().plater()->enter_gizmos_stack();
         m_internal_stack_active = true;
@@ -45,7 +45,7 @@ void GLGizmoPainterBase::activate_internal_undo_redo_stack(bool activate)
     if (! activate && m_internal_stack_active) {
         wxString str = get_painter_type() == PainterGizmoType::SEAM
                            ? _L("Leaving Seam painting")
-                           : _L("Leaving Paint-on supports");
+                           : (get_painter_type() == PainterGizmoType::MMU_SEGMENTATION ? _L("Leaving MMU segmentation") : _L("Leaving Paint-on supports"));
         wxGetApp().plater()->leave_gizmos_stack();
         Plater::TakeSnapshot(wxGetApp().plater(), str);
         m_internal_stack_active = false;
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp b/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp
index da415ce09..400934ca3 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp
@@ -25,7 +25,8 @@ struct Camera;
 
 enum class PainterGizmoType {
     FDM_SUPPORTS,
-    SEAM
+    SEAM,
+    MMU_SEGMENTATION
 };
 
 
diff --git a/src/slic3r/GUI/Gizmos/GLGizmos.hpp b/src/slic3r/GUI/Gizmos/GLGizmos.hpp
index e8e73959c..0252dee15 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmos.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmos.hpp
@@ -32,6 +32,7 @@ enum class SLAGizmoEventType : unsigned char {
 #include "slic3r/GUI/Gizmos/GLGizmoFlatten.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp"
+#include "slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoCut.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoHollow.hpp"
 
diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
index 9dc785b3f..453b98dad 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
@@ -18,6 +18,7 @@
 #include "slic3r/GUI/Gizmos/GLGizmoCut.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoHollow.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoSeam.hpp"
+#include "slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.hpp"
 
 #include "libslic3r/Model.hpp"
 #include "libslic3r/PresetBundle.hpp"
@@ -107,6 +108,7 @@ bool GLGizmosManager::init()
     m_gizmos.emplace_back(new GLGizmoSlaSupports(m_parent, "sla_supports.svg", 6));
     m_gizmos.emplace_back(new GLGizmoFdmSupports(m_parent, "fdm_supports.svg", 7));
     m_gizmos.emplace_back(new GLGizmoSeam(m_parent, "seam.svg", 8));
+    m_gizmos.emplace_back(new GLGizmoMmuSegmentation(m_parent, "fdm_supports.svg", 9));
 
     m_common_gizmos_data.reset(new CommonGizmosDataPool(&m_parent));
 
@@ -392,6 +394,7 @@ void GLGizmosManager::set_painter_gizmo_data()
 
     dynamic_cast<GLGizmoFdmSupports*>(m_gizmos[FdmSupports].get())->set_painter_gizmo_data(m_parent.get_selection());
     dynamic_cast<GLGizmoSeam*>(m_gizmos[Seam].get())->set_painter_gizmo_data(m_parent.get_selection());
+    dynamic_cast<GLGizmoMmuSegmentation*>(m_gizmos[MmuSegmentation].get())->set_painter_gizmo_data(m_parent.get_selection());
 }
 
 // Returns true if the gizmo used the event to do something, false otherwise.
@@ -408,6 +411,8 @@ bool GLGizmosManager::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_p
         return dynamic_cast<GLGizmoFdmSupports*>(m_gizmos[FdmSupports].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
     else if (m_current == Seam)
         return dynamic_cast<GLGizmoSeam*>(m_gizmos[Seam].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
+    else if (m_current == MmuSegmentation)
+        return dynamic_cast<GLGizmoMmuSegmentation*>(m_gizmos[MmuSegmentation].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
     else
         return false;
 }
@@ -484,7 +489,7 @@ bool GLGizmosManager::on_mouse_wheel(wxMouseEvent& evt)
 {
     bool processed = false;
 
-    if (m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam) {
+    if (m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam || m_current == MmuSegmentation) {
         float rot = (float)evt.GetWheelRotation() / (float)evt.GetWheelDelta();
         if (gizmo_event((rot > 0.f ? SLAGizmoEventType::MouseWheelUp : SLAGizmoEventType::MouseWheelDown), Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.ControlDown()))
             processed = true;
@@ -617,7 +622,7 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
         m_tooltip = "";
 
         if (evt.LeftDown() && (!control_down || grabber_contains_mouse())) {
-            if ((m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam)
+            if ((m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam || m_current == MmuSegmentation)
                 && gizmo_event(SLAGizmoEventType::LeftDown, mouse_pos, evt.ShiftDown(), evt.AltDown()))
                 // the gizmo got the event and took some action, there is no need to do anything more
                 processed = true;
@@ -643,16 +648,16 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
             // event was taken care of by the SlaSupports gizmo
             processed = true;
         }
-        else if (evt.RightDown() && !control_down && selected_object_idx != -1 && (m_current == FdmSupports || m_current == Seam)
+        else if (evt.RightDown() && !control_down && selected_object_idx != -1 && (m_current == FdmSupports || m_current == Seam || m_current == MmuSegmentation)
             && gizmo_event(SLAGizmoEventType::RightDown, mouse_pos)) {
-            // event was taken care of by the FdmSupports / Seam gizmo
+            // event was taken care of by the FdmSupports / Seam / MMUPainting gizmo
             processed = true;
         }
         else if (evt.Dragging() && m_parent.get_move_volume_id() != -1
-             && (m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam))
+            && (m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam || m_current == MmuSegmentation))
             // don't allow dragging objects with the Sla gizmo on
             processed = true;
-        else if (evt.Dragging() && !control_down && (m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam)
+        else if (evt.Dragging() && !control_down && (m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam  || m_current == MmuSegmentation)
             && gizmo_event(SLAGizmoEventType::Dragging, mouse_pos, evt.ShiftDown(), evt.AltDown())) {
             // the gizmo got the event and took some action, no need to do anything more here
             m_parent.set_as_dirty();
@@ -665,7 +670,7 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
             else if (evt.RightIsDown())
                 gizmo_event(SLAGizmoEventType::RightUp, mouse_pos, evt.ShiftDown(), evt.AltDown(), true);
         }
-        else if (evt.LeftUp() && (m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam) && !m_parent.is_mouse_dragging()) {
+        else if (evt.LeftUp() && (m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam || m_current == MmuSegmentation) && !m_parent.is_mouse_dragging()) {
             // in case SLA/FDM gizmo is selected, we just pass the LeftUp event and stop processing - neither
             // object moving or selecting is suppressed in that case
             gizmo_event(SLAGizmoEventType::LeftUp, mouse_pos, evt.ShiftDown(), evt.AltDown(), control_down);
@@ -675,7 +680,7 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
             // to avoid to loose the selection when user clicks an the white faces of a different object while the Flatten gizmo is active
             processed = true;
         }
-        else if (evt.RightUp() && (m_current == FdmSupports || m_current == Seam) && !m_parent.is_mouse_dragging()) {
+        else if (evt.RightUp() && (m_current == FdmSupports || m_current == Seam || m_current == MmuSegmentation) && !m_parent.is_mouse_dragging()) {
             gizmo_event(SLAGizmoEventType::RightUp, mouse_pos, evt.ShiftDown(), evt.AltDown(), control_down);
             processed = true;
         }
@@ -759,7 +764,7 @@ bool GLGizmosManager::on_char(wxKeyEvent& evt)
         case 'r' :
         case 'R' :
         {
-            if ((m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam) && gizmo_event(SLAGizmoEventType::ResetClippingPlane))
+            if ((m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam || m_current == MmuSegmentation) && gizmo_event(SLAGizmoEventType::ResetClippingPlane))
                 processed = true;
 
             break;
diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp
index 917a5830c..02fcc4ed8 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp
@@ -68,6 +68,7 @@ public:
         SlaSupports,
         FdmSupports,
         Seam,
+        MmuSegmentation,
         Undefined
     };
 
diff --git a/src/slic3r/GUI/Plater.cpp b/src/slic3r/GUI/Plater.cpp
index 50adb89e4..2c3fbe7af 100644
--- a/src/slic3r/GUI/Plater.cpp
+++ b/src/slic3r/GUI/Plater.cpp
@@ -3233,6 +3233,7 @@ void Plater::priv::reload_from_disk()
                         new_volume->convert_from_meters();
                     new_volume->supported_facets.assign(old_volume->supported_facets);
                     new_volume->seam_facets.assign(old_volume->seam_facets);
+                    new_volume->mmu_segmentation_facets.assign(old_volume->mmu_segmentation_facets);
                     std::swap(old_model_object->volumes[sel_v.volume_idx], old_model_object->volumes.back());
                     old_model_object->delete_volume(old_model_object->volumes.size() - 1);
                     old_model_object->ensure_on_bed();
@@ -3306,13 +3307,14 @@ void Plater::priv::fix_through_netfabb(const int obj_idx, const int vol_idx/* =
 
     ModelObject* mo = model.objects[obj_idx];
 
-    // If there are custom supports/seams, remove them. Fixed mesh
+    // If there are custom supports/seams/mmu segmentation, remove them. Fixed mesh
     // may be different and they would make no sense.
     bool paint_removed = false;
     for (ModelVolume* mv : mo->volumes) {
-        paint_removed |= ! mv->supported_facets.empty() || ! mv->seam_facets.empty();
+        paint_removed |= ! mv->supported_facets.empty() || ! mv->seam_facets.empty() || ! mv->mmu_segmentation_facets.empty();
         mv->supported_facets.clear();
         mv->seam_facets.clear();
+        mv->mmu_segmentation_facets.clear();
     }
     if (paint_removed) {
         // snapshot_time is captured by copy so the lambda knows where to undo/redo to.