From 76435e7add9f93a6d5fafcc1c0336b14da6505bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hejl?= Date: Tue, 6 Feb 2024 18:47:34 +0100 Subject: [PATCH] SPE-1840: Rework multi-material segmentation to work directly on the Voronoi diagram without creating a copy of it. Previous algorithms assume that they can get an invalid Voronoi diagram. Because of that, during the multi-material segmentation, a copy of the Voronoi diagram was created, and there were several attempts to fix missing vertices and edges. But as it shows, this wasn't a good enough approach and sometimes led to several issues like bleeding layers. After generalization, our approach for detection and repairs of invalid Voronoi diagrams from Arachne, we could assume that multi-material segmentation gets non-invalid Voronoi diagrams. With this assumption, we reimplement multi-materials segmentation to work directly on the Voronoi diagram. That should make multi-material segmentation more stable. So, this should fix several issues like bleeding layers. Also, memory consumption should decrease by a lot. Also, there should be some speedup of multi-materials segmentation. --- src/libslic3r/Format/3mf.cpp | 28 +- src/libslic3r/Geometry/Voronoi.cpp | 4 +- src/libslic3r/Geometry/VoronoiUtils.cpp | 13 +- src/libslic3r/Geometry/VoronoiUtils.hpp | 2 + src/libslic3r/Geometry/VoronoiUtilsCgal.cpp | 4 +- src/libslic3r/Model.cpp | 8 +- src/libslic3r/Model.hpp | 36 +- src/libslic3r/MultiMaterialSegmentation.cpp | 1267 ++++++----------- src/libslic3r/PrintApply.cpp | 6 +- src/libslic3r/PrintObjectSlice.cpp | 2 +- src/slic3r/GUI/GLCanvas3D.cpp | 4 +- src/slic3r/GUI/GUI_ObjectList.cpp | 4 +- src/slic3r/GUI/GUI_Preview.cpp | 2 +- .../GUI/Gizmos/GLGizmoMmuSegmentation.cpp | 4 +- src/slic3r/GUI/Plater.cpp | 6 +- 15 files changed, 468 insertions(+), 922 deletions(-) diff --git a/src/libslic3r/Format/3mf.cpp b/src/libslic3r/Format/3mf.cpp index 34f2eee4e1..dd9fab6123 100644 --- a/src/libslic3r/Format/3mf.cpp +++ b/src/libslic3r/Format/3mf.cpp @@ -124,7 +124,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* MM_SEGMENTATION_ATTR = "slic3rpe:mmu_segmentation"; static constexpr const char* KEY_ATTR = "key"; static constexpr const char* VALUE_ATTR = "value"; @@ -362,7 +362,7 @@ namespace Slic3r { std::vector triangles; std::vector custom_supports; std::vector custom_seam; - std::vector mmu_segmentation; + std::vector mm_segmentation; bool empty() { return vertices.empty() || triangles.empty(); } @@ -371,7 +371,7 @@ namespace Slic3r { triangles.clear(); custom_supports.clear(); custom_seam.clear(); - mmu_segmentation.clear(); + mm_segmentation.clear(); } }; @@ -1830,7 +1830,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)); + m_curr_object.geometry.mm_segmentation.push_back(get_attribute_value_string(attributes, num_attributes, MM_SEGMENTATION_ATTR)); return true; } @@ -2320,25 +2320,25 @@ namespace Slic3r { if (has_transform) volume->source.transform = Slic3r::Geometry::Transformation(volume_matrix_to_object); - // recreate custom supports, seam and mmu segmentation from previously loaded attribute + // recreate custom supports, seam and mm segmentation from previously loaded attribute volume->supported_facets.reserve(triangles_count); volume->seam_facets.reserve(triangles_count); - volume->mmu_segmentation_facets.reserve(triangles_count); + volume->mm_segmentation_facets.reserve(triangles_count); for (size_t i=0; isupported_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]); + if (! geometry.mm_segmentation[index].empty()) + volume->mm_segmentation_facets.set_triangle_from_string(i, geometry.mm_segmentation[index]); } volume->supported_facets.shrink_to_fit(); volume->seam_facets.shrink_to_fit(); - volume->mmu_segmentation_facets.shrink_to_fit(); + volume->mm_segmentation_facets.shrink_to_fit(); if (auto &es = volume_data.shape_configuration; es.has_value()) volume->emboss_shape = std::move(es); @@ -3002,12 +3002,12 @@ 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()) { + std::string mm_painting_data_string = volume->mm_segmentation_facets.get_triangle_as_string(i); + if (! mm_painting_data_string.empty()) { output_buffer += " "; - output_buffer += MMU_SEGMENTATION_ATTR; + output_buffer += MM_SEGMENTATION_ATTR; output_buffer += "=\""; - output_buffer += mmu_painting_data_string; + output_buffer += mm_painting_data_string; output_buffer += "\""; } diff --git a/src/libslic3r/Geometry/Voronoi.cpp b/src/libslic3r/Geometry/Voronoi.cpp index 404c5c7634..e1df7322a4 100644 --- a/src/libslic3r/Geometry/Voronoi.cpp +++ b/src/libslic3r/Geometry/Voronoi.cpp @@ -11,11 +11,11 @@ namespace Slic3r::Geometry { using PolygonsSegmentIndexConstIt = std::vector::const_iterator; using LinesIt = Lines::iterator; -using ColoredLinesIt = ColoredLines::iterator; +using ColoredLinesConstIt = ColoredLines::const_iterator; // Explicit template instantiation. template void VoronoiDiagram::construct_voronoi(LinesIt, LinesIt, bool); -template void VoronoiDiagram::construct_voronoi(ColoredLinesIt, ColoredLinesIt, bool); +template void VoronoiDiagram::construct_voronoi(ColoredLinesConstIt, ColoredLinesConstIt, bool); template void VoronoiDiagram::construct_voronoi(PolygonsSegmentIndexConstIt, PolygonsSegmentIndexConstIt, bool); template diff --git a/src/libslic3r/Geometry/VoronoiUtils.cpp b/src/libslic3r/Geometry/VoronoiUtils.cpp index 628e39f27d..fae30e0f98 100644 --- a/src/libslic3r/Geometry/VoronoiUtils.cpp +++ b/src/libslic3r/Geometry/VoronoiUtils.cpp @@ -8,19 +8,22 @@ namespace Slic3r::Geometry { using PolygonsSegmentIndexConstIt = std::vector::const_iterator; using LinesIt = Lines::iterator; using ColoredLinesIt = ColoredLines::iterator; +using ColoredLinesConstIt = ColoredLines::const_iterator; // Explicit template instantiation. template LinesIt::reference VoronoiUtils::get_source_segment(const VoronoiDiagram::cell_type &, LinesIt, LinesIt); template VD::SegmentIt::reference VoronoiUtils::get_source_segment(const VoronoiDiagram::cell_type &, VD::SegmentIt, VD::SegmentIt); template ColoredLinesIt::reference VoronoiUtils::get_source_segment(const VoronoiDiagram::cell_type &, ColoredLinesIt, ColoredLinesIt); +template ColoredLinesConstIt::reference VoronoiUtils::get_source_segment(const VoronoiDiagram::cell_type &, ColoredLinesConstIt, ColoredLinesConstIt); template PolygonsSegmentIndexConstIt::reference VoronoiUtils::get_source_segment(const VoronoiDiagram::cell_type &, PolygonsSegmentIndexConstIt, PolygonsSegmentIndexConstIt); template Point VoronoiUtils::get_source_point(const VoronoiDiagram::cell_type &, LinesIt, LinesIt); template Point VoronoiUtils::get_source_point(const VoronoiDiagram::cell_type &, VD::SegmentIt, VD::SegmentIt); template Point VoronoiUtils::get_source_point(const VoronoiDiagram::cell_type &, ColoredLinesIt, ColoredLinesIt); +template Point VoronoiUtils::get_source_point(const VoronoiDiagram::cell_type &, ColoredLinesConstIt, ColoredLinesConstIt); template Point VoronoiUtils::get_source_point(const VoronoiDiagram::cell_type &, PolygonsSegmentIndexConstIt, PolygonsSegmentIndexConstIt); template SegmentCellRange VoronoiUtils::compute_segment_cell_range(const VoronoiDiagram::cell_type &, LinesIt, LinesIt); template SegmentCellRange VoronoiUtils::compute_segment_cell_range(const VoronoiDiagram::cell_type &, VD::SegmentIt, VD::SegmentIt); -template SegmentCellRange VoronoiUtils::compute_segment_cell_range(const VoronoiDiagram::cell_type &, ColoredLinesIt, ColoredLinesIt); +template SegmentCellRange VoronoiUtils::compute_segment_cell_range(const VoronoiDiagram::cell_type &, ColoredLinesConstIt, ColoredLinesConstIt); template SegmentCellRange VoronoiUtils::compute_segment_cell_range(const VoronoiDiagram::cell_type &, PolygonsSegmentIndexConstIt, PolygonsSegmentIndexConstIt); template Points VoronoiUtils::discretize_parabola(const Point &, const Arachne::PolygonsSegmentIndex &, const Point &, const Point &, coord_t, float); template Arachne::PolygonsPointIndex VoronoiUtils::get_source_point_index(const VoronoiDiagram::cell_type &, PolygonsSegmentIndexConstIt, PolygonsSegmentIndexConstIt); @@ -241,7 +244,13 @@ VoronoiUtils::compute_segment_cell_range(const VD::cell_type &cell, const Segmen Vec2i64 VoronoiUtils::to_point(const VD::vertex_type *vertex) { - const double x = vertex->x(), y = vertex->y(); + assert(vertex != nullptr); + return VoronoiUtils::to_point(*vertex); +} + +Vec2i64 VoronoiUtils::to_point(const VD::vertex_type &vertex) +{ + const double x = vertex.x(), y = vertex.y(); assert(std::isfinite(x) && std::isfinite(y)); assert(is_in_range(x) && is_in_range(y)); diff --git a/src/libslic3r/Geometry/VoronoiUtils.hpp b/src/libslic3r/Geometry/VoronoiUtils.hpp index 577841e75c..bf63914677 100644 --- a/src/libslic3r/Geometry/VoronoiUtils.hpp +++ b/src/libslic3r/Geometry/VoronoiUtils.hpp @@ -29,6 +29,8 @@ class VoronoiUtils public: static Vec2i64 to_point(const VD::vertex_type *vertex); + static Vec2i64 to_point(const VD::vertex_type &vertex); + static bool is_finite(const VD::vertex_type &vertex); static VD::vertex_type make_rotated_vertex(VD::vertex_type &vertex, double angle); diff --git a/src/libslic3r/Geometry/VoronoiUtilsCgal.cpp b/src/libslic3r/Geometry/VoronoiUtilsCgal.cpp index e14499facd..e80f1a5a88 100644 --- a/src/libslic3r/Geometry/VoronoiUtilsCgal.cpp +++ b/src/libslic3r/Geometry/VoronoiUtilsCgal.cpp @@ -19,12 +19,12 @@ namespace Slic3r::Geometry { using PolygonsSegmentIndexConstIt = std::vector::const_iterator; using LinesIt = Lines::iterator; -using ColoredLinesIt = ColoredLines::iterator; +using ColoredLinesConstIt = ColoredLines::const_iterator; // Explicit template instantiation. template bool VoronoiUtilsCgal::is_voronoi_diagram_planar_angle(const VD &, LinesIt, LinesIt); template bool VoronoiUtilsCgal::is_voronoi_diagram_planar_angle(const VD &, VD::SegmentIt, VD::SegmentIt); -template bool VoronoiUtilsCgal::is_voronoi_diagram_planar_angle(const VD &, ColoredLinesIt, ColoredLinesIt); +template bool VoronoiUtilsCgal::is_voronoi_diagram_planar_angle(const VD &, ColoredLinesConstIt, ColoredLinesConstIt); template bool VoronoiUtilsCgal::is_voronoi_diagram_planar_angle(const VD &, PolygonsSegmentIndexConstIt, PolygonsSegmentIndexConstIt); // The tangent vector of the parabola is computed based on the Proof of the reflective property. diff --git a/src/libslic3r/Model.cpp b/src/libslic3r/Model.cpp index 9d061dfef1..c7c53cf55d 100644 --- a/src/libslic3r/Model.cpp +++ b/src/libslic3r/Model.cpp @@ -1237,7 +1237,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); + vol->mm_segmentation_facets.assign(volume->mm_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. @@ -1349,7 +1349,7 @@ void ModelVolume::reset_extra_facets() { this->supported_facets.reset(); this->seam_facets.reset(); - this->mmu_segmentation_facets.reset(); + this->mm_segmentation_facets.reset(); } @@ -1915,7 +1915,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(); + mm_segmentation_facets.set_new_unique_id(); } void ModelVolume::rotate(double angle, Axis axis) @@ -2224,7 +2224,7 @@ bool model_mmu_segmentation_data_changed(const ModelObject& mo, const ModelObjec { return model_property_changed(mo, mo_new, [](const ModelVolumeType t) { return t == ModelVolumeType::MODEL_PART; }, - [](const ModelVolume &mv_old, const ModelVolume &mv_new){ return mv_old.mmu_segmentation_facets.timestamp_matches(mv_new.mmu_segmentation_facets); }); + [](const ModelVolume &mv_old, const ModelVolume &mv_new){ return mv_old.mm_segmentation_facets.timestamp_matches(mv_new.mm_segmentation_facets); }); } bool model_has_parameter_modifiers_in_objects(const Model &model) diff --git a/src/libslic3r/Model.hpp b/src/libslic3r/Model.hpp index 5afd77883e..c885b78e56 100644 --- a/src/libslic3r/Model.hpp +++ b/src/libslic3r/Model.hpp @@ -823,8 +823,8 @@ public: // List of seam enforcers/blockers. FacetsAnnotation seam_facets; - // List of mesh facets painted for MMU segmentation. - FacetsAnnotation mmu_segmentation_facets; + // List of mesh facets painted for MM segmentation. + FacetsAnnotation mm_segmentation_facets; // Is set only when volume is Embossed Text type // Contain information how to re-create volume @@ -929,12 +929,12 @@ 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(); + this->mm_segmentation_facets.set_new_unique_id(); } bool is_fdm_support_painted() const { return !this->supported_facets.empty(); } bool is_seam_painted() const { return !this->seam_facets.empty(); } - bool is_mm_painted() const { return !this->mmu_segmentation_facets.empty(); } + bool is_mm_painted() const { return !this->mm_segmentation_facets.empty(); } protected: friend class Print; @@ -973,11 +973,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->mm_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() != this->mm_segmentation_facets.id()); return true; } @@ -1003,23 +1003,23 @@ 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), mmu_segmentation_facets(other.mmu_segmentation_facets), + supported_facets(other.supported_facets), seam_facets(other.seam_facets), mm_segmentation_facets(other.mm_segmentation_facets), cut_info(other.cut_info), text_configuration(other.text_configuration), emboss_shape(other.emboss_shape) { 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->mm_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() != this->mm_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()); + assert(this->mm_segmentation_facets.id() == other.mm_segmentation_facets.id()); this->set_material_id(other.material_id()); } // Providing a new mesh, therefore this volume will get a new unique ID assigned. @@ -1031,11 +1031,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->mm_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() != this->mm_segmentation_facets.id()); assert(this->id() != other.id()); assert(this->config.id() == other.config.id()); this->set_material_id(other.material_id()); @@ -1046,11 +1046,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->mm_segmentation_facets.id() != other.mm_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()); + assert(this->mm_segmentation_facets.empty()); } ModelVolume& operator=(ModelVolume &rhs) = delete; @@ -1058,19 +1058,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), mmu_segmentation_facets(-1), object(nullptr) { + ModelVolume() : ObjectBase(-1), config(-1), supported_facets(-1), seam_facets(-1), mm_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()); + assert(this->mm_segmentation_facets.id().invalid()); } template 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, cut_info); 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, mm_segmentation_facets); cereal::load_by_value(ar, config); cereal::load(ar, text_configuration); cereal::load(ar, emboss_shape); @@ -1088,7 +1088,7 @@ private: ar(name, source, m_mesh, m_type, m_material_id, m_transformation, m_is_splittable, has_convex_hull, cut_info); 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, mm_segmentation_facets); cereal::save_by_value(ar, config); cereal::save(ar, text_configuration); cereal::save(ar, emboss_shape); diff --git a/src/libslic3r/MultiMaterialSegmentation.cpp b/src/libslic3r/MultiMaterialSegmentation.cpp index e40c081066..708bdcf5ee 100644 --- a/src/libslic3r/MultiMaterialSegmentation.cpp +++ b/src/libslic3r/MultiMaterialSegmentation.cpp @@ -8,11 +8,11 @@ #include "Layer.hpp" #include "Print.hpp" #include "Geometry/VoronoiVisualUtils.hpp" +#include "Geometry/VoronoiUtils.hpp" #include "MutablePolygon.hpp" #include "format.hpp" #include -#include #include #include @@ -20,13 +20,19 @@ #include #include -#include +//#define MM_SEGMENTATION_DEBUG_GRAPH +//#define MM_SEGMENTATION_DEBUG_REGIONS +//#define MM_SEGMENTATION_DEBUG_INPUT +//#define MM_SEGMENTATION_DEBUG_PAINTED_LINES +//#define MM_SEGMENTATION_DEBUG_COLORIZED_POLYGONS -//#define MMU_SEGMENTATION_DEBUG_GRAPH -//#define MMU_SEGMENTATION_DEBUG_REGIONS -//#define MMU_SEGMENTATION_DEBUG_INPUT -//#define MMU_SEGMENTATION_DEBUG_PAINTED_LINES -//#define MMU_SEGMENTATION_DEBUG_COLORIZED_POLYGONS +#if defined(MM_SEGMENTATION_DEBUG_GRAPH) || defined(MM_SEGMENTATION_DEBUG_REGIONS) || \ + defined(MM_SEGMENTATION_DEBUG_INPUT) || defined(MM_SEGMENTATION_DEBUG_PAINTED_LINES) || \ + defined(MM_SEGMENTATION_DEBUG_COLORIZED_POLYGONS) +#define MM_SEGMENTATION_DEBUG +#endif + +//#define MM_SEGMENTATION_DEBUG_TOP_BOTTOM namespace Slic3r { @@ -130,55 +136,31 @@ struct PaintedLineVisitor static inline const double append_threshold2 = Slic3r::sqr(append_threshold); }; -static Polygon colored_points_to_polygon(const std::vector &lines) -{ - Polygon out; - out.points.reserve(lines.size()); - for (const ColoredLine &l : lines) - out.points.emplace_back(l.line.a); - return out; -} - -static Polygons colored_points_to_polygon(const std::vector> &lines) -{ - Polygons out; - out.reserve(lines.size()); - for (const std::vector &l : lines) - out.emplace_back(colored_points_to_polygon(l)); - return out; +BoundingBox get_extents(const std::vector &colored_polygons) { + BoundingBox bbox; + for (const ColoredLines &colored_lines : colored_polygons) { + for (const ColoredLine &colored_line : colored_lines) { + bbox.merge(colored_line.line.a); + bbox.merge(colored_line.line.b); + } + } + return bbox; } // Flatten the vector of vectors into a vector. -static inline std::vector to_lines(const std::vector> &c_lines) +static inline ColoredLines to_lines(const std::vector &c_lines) { size_t n_lines = 0; for (const auto &c_line : c_lines) n_lines += c_line.size(); - std::vector lines; + ColoredLines lines; lines.reserve(n_lines); for (const auto &c_line : c_lines) lines.insert(lines.end(), c_line.begin(), c_line.end()); return lines; } -static bool vertex_equal_to_point(const Voronoi::VD::vertex_type &vertex, const Vec2d &ipt) -{ - // Convert ipt to doubles, force the 80bit FPU temporary to 64bit and then compare. - // This should work with any settings of math compiler switches and the C++ compiler - // shall understand the memcpies as type punning and it shall optimize them out. - using ulp_cmp_type = boost::polygon::detail::ulp_comparison; - ulp_cmp_type ulp_cmp; - static constexpr int ULPS = boost::polygon::voronoi_diagram_traits::vertex_equality_predicate_type::ULPS; - return ulp_cmp(vertex.x(), ipt.x(), ULPS) == ulp_cmp_type::EQUAL && - ulp_cmp(vertex.y(), ipt.y(), ULPS) == ulp_cmp_type::EQUAL; -} - -static inline bool vertex_equal_to_point(const Voronoi::VD::vertex_type *vertex, const Vec2d &ipt) -{ - return vertex_equal_to_point(*vertex, ipt); -} - -static std::vector> get_segments(const std::vector &polygon) +static std::vector> get_segments(const ColoredLines &polygon) { std::vector> segments; @@ -203,16 +185,6 @@ static std::vector> get_segments(const std::vector>> get_all_segments(const std::vector> &color_poly) -{ - std::vector>> all_segments(color_poly.size()); - for (size_t poly_idx = 0; poly_idx < color_poly.size(); ++poly_idx) { - const std::vector &c_polygon = color_poly[poly_idx]; - all_segments[poly_idx] = get_segments(c_polygon); - } - return all_segments; -} - static std::vector filter_painted_lines(const Line &line_to_process, const size_t start_idx, const size_t end_idx, const std::vector &painted_lines) { const int filter_eps_value = scale_(0.1f); @@ -293,7 +265,7 @@ static std::vector> post_process_painted_lines(const st } #ifndef NDEBUG -static bool are_lines_connected(const std::vector &colored_lines) +static bool are_lines_connected(const ColoredLines &colored_lines) { for (size_t line_idx = 1; line_idx < colored_lines.size(); ++line_idx) if (colored_lines[line_idx - 1].line.b != colored_lines[line_idx].line.a) @@ -302,7 +274,7 @@ static bool are_lines_connected(const std::vector &colored_lines) } #endif -static std::vector colorize_line(const Line &line_to_process, +static ColoredLines colorize_line(const Line &line_to_process, const size_t start_idx, const size_t end_idx, const std::vector &painted_contour) @@ -310,9 +282,9 @@ static std::vector colorize_line(const Line &line_to_process, assert(start_idx < painted_contour.size() && end_idx < painted_contour.size() && start_idx <= end_idx); assert(std::all_of(painted_contour.begin() + start_idx, painted_contour.begin() + end_idx + 1, [&painted_contour, &start_idx](const auto &p_line) { return painted_contour[start_idx].line_idx == p_line.line_idx; })); - const int filter_eps_value = scale_(0.1f); - std::vector final_lines; - const PaintedLine &first_line = painted_contour[start_idx]; + const int filter_eps_value = scale_(0.1f); + ColoredLines final_lines; + const PaintedLine &first_line = painted_contour[start_idx]; if (double dist_to_start = (first_line.projected_line.a - line_to_process.a).cast().norm(); dist_to_start > filter_eps_value) final_lines.push_back({Line(line_to_process.a, first_line.projected_line.a), 0}); final_lines.push_back({first_line.projected_line, first_line.color}); @@ -351,7 +323,7 @@ static std::vector colorize_line(const Line &line_to_process, if (line_1.line.length() <= scale_(0.2)) line_1.color = line_0.color; } - std::vector colored_lines_simple; + ColoredLines colored_lines_simple; colored_lines_simple.emplace_back(final_lines.front()); for (size_t line_idx = 1; line_idx < final_lines.size(); ++line_idx) { const ColoredLine &line_0 = final_lines[line_idx]; @@ -379,7 +351,7 @@ static std::vector colorize_line(const Line &line_to_process, return final_lines; } -static std::vector filter_colorized_polygon(std::vector &&new_lines) { +static ColoredLines filter_colorized_polygon(ColoredLines &&new_lines) { for (size_t line_idx = 2; line_idx < new_lines.size(); ++line_idx) { const ColoredLine &line_0 = new_lines[line_idx - 2]; ColoredLine &line_1 = new_lines[line_idx - 1]; @@ -468,10 +440,10 @@ static std::vector filter_colorized_polygon(std::vector colorize_contour(const EdgeGrid::Contour &contour, const std::vector &painted_contour) { +static ColoredLines colorize_contour(const EdgeGrid::Contour &contour, const std::vector &painted_contour) { assert(painted_contour.empty() || std::all_of(painted_contour.begin(), painted_contour.end(), [&painted_contour](const auto &p_line) { return painted_contour.front().contour_idx == p_line.contour_idx; })); - std::vector colorized_contour; + ColoredLines colorized_contour; if (painted_contour.empty()) { // Appends contour with default color for lines before the first PaintedLine. colorized_contour.reserve(contour.num_segments()); @@ -508,297 +480,33 @@ static std::vector colorize_contour(const EdgeGrid::Contour &contou return filter_colorized_polygon(std::move(colorized_contour)); } -static std::vector> colorize_contours(const std::vector &contours, const std::vector> &painted_contours) +static std::vector colorize_contours(const std::vector &contours, const std::vector> &painted_contours) { assert(contours.size() == painted_contours.size()); - std::vector> colorized_contours(contours.size()); + std::vector colorized_contours(contours.size()); for (const std::vector &painted_contour : painted_contours) { size_t contour_idx = &painted_contour - &painted_contours.front(); colorized_contours[contour_idx] = colorize_contour(contours[contour_idx], painted_contours[contour_idx]); } + + size_t poly_idx = 0; + for (ColoredLines &color_lines : colorized_contours) { + size_t line_idx = 0; + for (size_t color_line_idx = 0; color_line_idx < color_lines.size(); ++color_line_idx) { + color_lines[color_line_idx].poly_idx = int(poly_idx); + color_lines[color_line_idx].local_line_idx = int(line_idx); + ++line_idx; + } + ++poly_idx; + } + return colorized_contours; } -using boost::polygon::voronoi_diagram; - -static inline Point mk_point(const Voronoi::VD::vertex_type *point) { return {coord_t(point->x()), coord_t(point->y())}; } - -static inline Point mk_point(const Voronoi::Internal::point_type &point) { return {coord_t(point.x()), coord_t(point.y())}; } - -static inline Point mk_point(const voronoi_diagram::vertex_type &point) { return {coord_t(point.x()), coord_t(point.y())}; } - -static inline Point mk_point(const Vec2d &point) { return {coord_t(std::round(point.x())), coord_t(std::round(point.y()))}; } - -static inline Vec2d mk_vec2(const voronoi_diagram::vertex_type *point) { return {point->x(), point->y()}; } - -struct MMU_Graph -{ - enum class ARC_TYPE { BORDER, NON_BORDER }; - - struct Arc - { - size_t from_idx; - size_t to_idx; - int color; - ARC_TYPE type; - - bool operator==(const Arc &rhs) const { return (from_idx == rhs.from_idx) && (to_idx == rhs.to_idx) && (color == rhs.color) && (type == rhs.type); } - bool operator!=(const Arc &rhs) const { return !operator==(rhs); } - }; - - struct Node - { - Vec2d point; - std::list arc_idxs; - - void remove_edge(const size_t to_idx, MMU_Graph &graph) - { - for (auto arc_it = this->arc_idxs.begin(); arc_it != this->arc_idxs.end(); ++arc_it) { - MMU_Graph::Arc &arc = graph.arcs[*arc_it]; - if (arc.to_idx == to_idx) { - assert(arc.type != ARC_TYPE::BORDER); - this->arc_idxs.erase(arc_it); - break; - } - } - } - }; - - std::vector nodes; - std::vector arcs; - size_t all_border_points{}; - - std::vector polygon_idx_offset; - std::vector polygon_sizes; - - void remove_edge(const size_t from_idx, const size_t to_idx) - { - nodes[from_idx].remove_edge(to_idx, *this); - nodes[to_idx].remove_edge(from_idx, *this); - } - - [[nodiscard]] size_t get_global_index(const size_t poly_idx, const size_t point_idx) const { return polygon_idx_offset[poly_idx] + point_idx; } - - void append_edge(const size_t &from_idx, const size_t &to_idx, int color = -1, ARC_TYPE type = ARC_TYPE::NON_BORDER) - { - // Don't append duplicate edges between the same nodes. - for (const size_t &arc_idx : this->nodes[from_idx].arc_idxs) - if (arcs[arc_idx].to_idx == to_idx) - return; - for (const size_t &arc_idx : this->nodes[to_idx].arc_idxs) - if (arcs[arc_idx].to_idx == from_idx) - return; - - this->nodes[from_idx].arc_idxs.push_back(this->arcs.size()); - this->arcs.push_back({from_idx, to_idx, color, type}); - - // Always insert only one directed arc for the input polygons. - // Two directed arcs in both directions are inserted if arcs aren't between points of the input polygons. - if (type == ARC_TYPE::NON_BORDER) { - this->nodes[to_idx].arc_idxs.push_back(this->arcs.size()); - this->arcs.push_back({to_idx, from_idx, color, type}); - } - } - - // It assumes that between points of the input polygons is always only one directed arc, - // with the same direction as lines of the input polygon. - [[nodiscard]] MMU_Graph::Arc get_border_arc(size_t idx) const { - assert(idx < this->all_border_points); - return this->arcs[idx]; - } - - [[nodiscard]] size_t nodes_count() const { return this->nodes.size(); } - - void remove_nodes_with_one_arc() - { - std::queue update_queue; - for (const MMU_Graph::Node &node : this->nodes) { - size_t node_idx = &node - &this->nodes.front(); - // Skip nodes that represent points of input polygons. - if (node.arc_idxs.size() == 1 && node_idx >= this->all_border_points) - update_queue.emplace(&node - &this->nodes.front()); - } - - while (!update_queue.empty()) { - size_t node_from_idx = update_queue.front(); - MMU_Graph::Node &node_from = this->nodes[update_queue.front()]; - update_queue.pop(); - if (node_from.arc_idxs.empty()) - continue; - - assert(node_from.arc_idxs.size() == 1); - size_t node_to_idx = arcs[node_from.arc_idxs.front()].to_idx; - MMU_Graph::Node &node_to = this->nodes[node_to_idx]; - this->remove_edge(node_from_idx, node_to_idx); - if (node_to.arc_idxs.size() == 1 && node_to_idx >= this->all_border_points) - update_queue.emplace(node_to_idx); - } - } - - void add_contours(const std::vector> &color_poly) - { - this->all_border_points = nodes.size(); - this->polygon_sizes = std::vector(color_poly.size()); - for (size_t polygon_idx = 0; polygon_idx < color_poly.size(); ++polygon_idx) - this->polygon_sizes[polygon_idx] = color_poly[polygon_idx].size(); - this->polygon_idx_offset = std::vector(color_poly.size()); - this->polygon_idx_offset[0] = 0; - for (size_t polygon_idx = 1; polygon_idx < color_poly.size(); ++polygon_idx) { - this->polygon_idx_offset[polygon_idx] = this->polygon_idx_offset[polygon_idx - 1] + color_poly[polygon_idx - 1].size(); - } - - size_t poly_idx = 0; - for (const std::vector &color_lines : color_poly) { - size_t line_idx = 0; - for (const ColoredLine &color_line : color_lines) { - size_t from_idx = this->get_global_index(poly_idx, line_idx); - size_t to_idx = this->get_global_index(poly_idx, (line_idx + 1) % color_lines.size()); - this->append_edge(from_idx, to_idx, color_line.color, ARC_TYPE::BORDER); - ++line_idx; - } - ++poly_idx; - } - } - - // Nodes 0..all_border_points are only one with are on countour. Other vertexis are consider as not on coouter. So we check if base on attach index - inline bool is_vertex_on_contour(const Voronoi::VD::vertex_type *vertex) const - { - assert(vertex != nullptr); - return vertex->color() < this->all_border_points; - } - - [[nodiscard]] inline bool is_edge_attach_to_contour(const voronoi_diagram::const_edge_iterator &edge_iterator) const - { - return this->is_vertex_on_contour(edge_iterator->vertex0()) || this->is_vertex_on_contour(edge_iterator->vertex1()); - } - - [[nodiscard]] inline bool is_edge_connecting_two_contour_vertices(const voronoi_diagram::const_edge_iterator &edge_iterator) const - { - return this->is_vertex_on_contour(edge_iterator->vertex0()) && this->is_vertex_on_contour(edge_iterator->vertex1()); - } - - // All Voronoi vertices are post-processes to merge very close vertices to single. Witch eliminates issues with intersection edges. - // Also, Voronoi vertices outside of the bounding of input polygons are throw away by marking them. - void append_voronoi_vertices(const Voronoi::VD &vd, const Polygons &color_poly_tmp, BoundingBox bbox) { - bbox.offset(SCALED_EPSILON); - - struct CPoint - { - CPoint() = delete; - CPoint(const Vec2d &point, size_t contour_idx, size_t point_idx) : m_point_double(point), m_point(mk_point(point)), m_point_idx(point_idx), m_contour_idx(contour_idx) {} - CPoint(const Vec2d &point, size_t point_idx) : m_point_double(point), m_point(mk_point(point)), m_point_idx(point_idx), m_contour_idx(0) {} - const Vec2d m_point_double; - const Point m_point; - size_t m_point_idx; - size_t m_contour_idx; - - [[nodiscard]] const Vec2d &point_double() const { return m_point_double; } - [[nodiscard]] const Point &point() const { return m_point; } - bool operator==(const CPoint &rhs) const { return m_point_double == rhs.m_point_double && m_contour_idx == rhs.m_contour_idx && m_point_idx == rhs.m_point_idx; } - }; - struct CPointAccessor { const Point* operator()(const CPoint &pt) const { return &pt.point(); }}; - typedef ClosestPointInRadiusLookup CPointLookupType; - - CPointLookupType closest_voronoi_point(coord_t(SCALED_EPSILON)); - CPointLookupType closest_contour_point(3 * coord_t(SCALED_EPSILON)); - for (const Polygon &polygon : color_poly_tmp) - for (const Point &pt : polygon.points) - closest_contour_point.insert(CPoint(Vec2d(pt.x(), pt.y()), &polygon - &color_poly_tmp.front(), &pt - &polygon.points.front())); - - for (const voronoi_diagram::vertex_type &vertex : vd.vertices()) { - vertex.color(-1); - Vec2d vertex_point_double = Vec2d(vertex.x(), vertex.y()); - Point vertex_point = mk_point(vertex); - - const Vec2d &first_point_double = this->nodes[this->get_border_arc(vertex.incident_edge()->cell()->source_index()).from_idx].point; - const Vec2d &second_point_double = this->nodes[this->get_border_arc(vertex.incident_edge()->twin()->cell()->source_index()).from_idx].point; - - if (vertex_equal_to_point(&vertex, first_point_double)) { - assert(vertex.color() != vertex.incident_edge()->cell()->source_index()); - assert(vertex.color() != vertex.incident_edge()->twin()->cell()->source_index()); - vertex.color(this->get_border_arc(vertex.incident_edge()->cell()->source_index()).from_idx); - } else if (vertex_equal_to_point(&vertex, second_point_double)) { - assert(vertex.color() != vertex.incident_edge()->cell()->source_index()); - assert(vertex.color() != vertex.incident_edge()->twin()->cell()->source_index()); - vertex.color(this->get_border_arc(vertex.incident_edge()->twin()->cell()->source_index()).from_idx); - } else if (bbox.contains(vertex_point)) { - if (auto [contour_pt, c_dist_sqr] = closest_contour_point.find(vertex_point); contour_pt != nullptr && c_dist_sqr < Slic3r::sqr(3 * SCALED_EPSILON)) { - vertex.color(this->get_global_index(contour_pt->m_contour_idx, contour_pt->m_point_idx)); - } else if (auto [voronoi_pt, v_dist_sqr] = closest_voronoi_point.find(vertex_point); voronoi_pt == nullptr || v_dist_sqr >= Slic3r::sqr(SCALED_EPSILON / 10.0)) { - closest_voronoi_point.insert(CPoint(vertex_point_double, this->nodes_count())); - vertex.color(this->nodes_count()); - this->nodes.push_back({vertex_point_double}); - } else { - // Boost Voronoi diagram generator sometimes creates two very closed points instead of one point. - // For the example points (146872.99999999997, -146872.99999999997) and (146873, -146873), this example also included in Voronoi generator test cases. - std::vector> all_closes_c_points = closest_voronoi_point.find_all(vertex_point); - int merge_to_point = -1; - for (const std::pair &c_point : all_closes_c_points) - if ((vertex_point_double - c_point.first->point_double()).squaredNorm() <= Slic3r::sqr(EPSILON)) { - merge_to_point = int(c_point.first->m_point_idx); - break; - } - - if (merge_to_point != -1) { - vertex.color(merge_to_point); - } else { - closest_voronoi_point.insert(CPoint(vertex_point_double, this->nodes_count())); - vertex.color(this->nodes_count()); - this->nodes.push_back({vertex_point_double}); - } - } - } - } - } - - void garbage_collect() - { - std::vector nodes_map(this->nodes.size(), -1); - int nodes_count = 0; - size_t arcs_count = 0; - for (const MMU_Graph::Node &node : this->nodes) - if (size_t node_idx = &node - &this->nodes.front(); !node.arc_idxs.empty()) { - nodes_map[node_idx] = nodes_count++; - arcs_count += node.arc_idxs.size(); - } - - std::vector new_nodes; - std::vector new_arcs; - new_nodes.reserve(nodes_count); - new_arcs.reserve(arcs_count); - for (const MMU_Graph::Node &node : this->nodes) - if (size_t node_idx = &node - &this->nodes.front(); nodes_map[node_idx] >= 0) { - new_nodes.push_back({node.point}); - for (const size_t &arc_idx : node.arc_idxs) { - const Arc &arc = this->arcs[arc_idx]; - new_nodes.back().arc_idxs.emplace_back(new_arcs.size()); - new_arcs.push_back({size_t(nodes_map[arc.from_idx]), size_t(nodes_map[arc.to_idx]), arc.color, arc.type}); - } - } - - this->nodes = std::move(new_nodes); - this->arcs = std::move(new_arcs); - } -}; - -static inline void mark_processed(const voronoi_diagram::const_edge_iterator &edge_iterator) -{ - edge_iterator->color(true); - edge_iterator->twin()->color(true); -} - -// Return true, if "p" is closer to line.a, then line.b -static inline bool is_point_closer_to_beginning_of_line(const Line &line, const Point &p) -{ - return (p - line.a).cast().squaredNorm() < (p - line.b).cast().squaredNorm(); -} - -static inline bool has_same_color(const ColoredLine &cl1, const ColoredLine &cl2) { return cl1.color == cl2.color; } - // Determines if the line points from the point between two contour lines is pointing inside polygon or outside. static inline bool points_inside(const Line &contour_first, const Line &contour_second, const Point &new_point) { - // Used in points_inside for decision if line leading thought the common point of two lines is pointing inside polygon or outside + // TODO: Used in points_inside for decision if line leading thought the common point of two lines is pointing inside polygon or outside auto three_points_inward_normal = [](const Point &left, const Point &middle, const Point &right) -> Vec2d { assert(left != middle); assert(middle != right); @@ -813,440 +521,309 @@ static inline bool points_inside(const Line &contour_first, const Line &contour_ return side > 0.; } -static inline bool line_intersection_with_epsilon(const Line &line_to_extend, const Line &other, Point *intersection) -{ - Line extended_line = line_to_extend; - extended_line.extend(15 * SCALED_EPSILON); - return extended_line.intersection(other, intersection); +enum VD_ANNOTATION : Voronoi::VD::cell_type::color_type { + VERTEX_ON_CONTOUR = 1, + DELETED = 2 +}; + +#ifdef MM_SEGMENTATION_DEBUG_GRAPH +static void export_graph_to_svg(const std::string &path, const Voronoi::VD& vd, const std::vector& colored_polygons) { + const coordf_t stroke_width = scaled(0.05f); + const BoundingBox bbox = get_extents(colored_polygons); + + SVG svg(path.c_str(), bbox); + for (const ColoredLines &colored_lines : colored_polygons) + for (const ColoredLine &colored_line : colored_lines) + svg.draw(colored_line.line, "black", stroke_width); + + for (const Voronoi::VD::vertex_type &vertex : vd.vertices()) { + if (Geometry::VoronoiUtils::is_in_range(vertex)) { + if (const Point pt = Geometry::VoronoiUtils::to_point(&vertex).cast(); vertex.color() == VD_ANNOTATION::VERTEX_ON_CONTOUR) { + svg.draw(pt, "blue", coord_t(stroke_width)); + } else if (vertex.color() != VD_ANNOTATION::DELETED) { + svg.draw(pt, "green", coord_t(stroke_width)); + } + } + } + + for (const Voronoi::VD::edge_type &edge : vd.edges()) { + if (edge.is_infinite() || !Geometry::VoronoiUtils::is_in_range(edge)) + continue; + + const Point from = Geometry::VoronoiUtils::to_point(edge.vertex0()).cast(); + const Point to = Geometry::VoronoiUtils::to_point(edge.vertex1()).cast(); + + if (edge.color() != VD_ANNOTATION::DELETED) + svg.draw(Line(from, to), "red", stroke_width); + } +} +#endif // MM_SEGMENTATION_DEBUG_GRAPH + +static size_t non_deleted_edge_count(const VD::vertex_type &vertex) { + size_t non_deleted_edge_cnt = 0; + const VD::edge_type *edge = vertex.incident_edge(); + do { + if (edge->color() != VD_ANNOTATION::DELETED) + ++non_deleted_edge_cnt; + } while (edge = edge->prev()->twin(), edge != vertex.incident_edge()); + + return non_deleted_edge_cnt; } -// For every ColoredLine in lines_colored_out, assign the index of the polygon to which belongs and also the index of this line inside of the polygon. -static inline void init_polygon_indices(const MMU_Graph &graph, - const std::vector> &color_poly, - std::vector &lines_colored_out) -{ - size_t poly_idx = 0; - for (const std::vector &color_lines : color_poly) { - size_t line_idx = 0; - for (size_t color_line_idx = 0; color_line_idx < color_lines.size(); ++color_line_idx) { - size_t from_idx = graph.get_global_index(poly_idx, line_idx); - lines_colored_out[from_idx].poly_idx = int(poly_idx); - lines_colored_out[from_idx].local_line_idx = int(line_idx); - ++line_idx; - } - ++poly_idx; +static bool can_vertex_be_deleted(const VD::vertex_type &vertex) { + if (vertex.color() == VD_ANNOTATION::VERTEX_ON_CONTOUR || vertex.color() == VD_ANNOTATION::DELETED) + return false; + + return non_deleted_edge_count(vertex) <= 1; +} + +static void delete_vertex_deep(const VD::vertex_type &vertex) { + std::queue vertices_to_delete; + vertices_to_delete.emplace(&vertex); + + while (!vertices_to_delete.empty()) { + const VD::vertex_type &vertex_to_delete = *vertices_to_delete.front(); + vertices_to_delete.pop(); + vertex_to_delete.color(VD_ANNOTATION::DELETED); + + const VD::edge_type *edge = vertex_to_delete.incident_edge(); + do { + edge->color(VD_ANNOTATION::DELETED); + edge->twin()->color(VD_ANNOTATION::DELETED); + + if (edge->is_finite() && can_vertex_be_deleted(*edge->vertex1())) + vertices_to_delete.emplace(edge->vertex1()); + } while (edge = edge->prev()->twin(), edge != vertex_to_delete.incident_edge()); } } -// Voronoi edges produced by Voronoi generator cloud have coordinates that don't fit inside coord_t (int32_t). -// Because of that, this function tries to clip edges that have one endpoint of the edge inside the BoundingBox. -static inline Line clip_finite_voronoi_edge(const Voronoi::VD::edge_type &edge, const BoundingBoxf &bbox) -{ +static inline Vec2d mk_point_vec2d(const VD::vertex_type *point) { + assert(point != nullptr); + return {point->x(), point->y()}; +} + +static inline Vec2d mk_vector_vec2d(const VD::edge_type *edge) { + assert(edge != nullptr); + return mk_point_vec2d(edge->vertex1()) - mk_point_vec2d(edge->vertex0()); +} + +static inline Vec2d mk_flipped_vector_vec2d(const VD::edge_type *edge) { + assert(edge != nullptr); + return mk_point_vec2d(edge->vertex0()) - mk_point_vec2d(edge->vertex1()); +} + +static double edge_length(const VD::edge_type &edge) { assert(edge.is_finite()); - Vec2d v0 = mk_vec2(edge.vertex0()); - Vec2d v1 = mk_vec2(edge.vertex1()); - bool contains_v0 = bbox.contains(v0); - bool contains_v1 = bbox.contains(v1); - if ((contains_v0 && contains_v1) || (!contains_v0 && !contains_v1)) - return {mk_point(edge.vertex0()), mk_point(edge.vertex1())}; - - Vec2d vector = (v1 - v0).normalized() * bbox.size().norm(); - if (!contains_v0) - v0 = (v1 - vector); - else - v1 = (v0 + vector); - - return {v0.cast(), v1.cast()}; -} - -static MMU_Graph build_graph(size_t layer_idx, const std::vector> &color_poly) -{ - Voronoi::VD vd; - std::vector lines_colored = to_lines(color_poly); - const Polygons color_poly_tmp = colored_points_to_polygon(color_poly); - const Points points = to_points(color_poly_tmp); - const Lines lines = to_lines(color_poly_tmp); - - // The algorithm adds edges to the graph that are between two different colors. - // If a polygon is colored entirely with one color, we need to add at least one edge from that polygon artificially. - // Adding this edge is necessary for cases where the expolygon has an outer contour colored whole with one color - // and a hole colored with a different color. If an edge wasn't added to the graph, - // the entire expolygon would be colored with single random color instead of two different. - std::vector force_edge_adding(color_poly.size()); - - // For each polygon, check if it is all colored with the same color. If it is, we need to force adding one edge to it. - for (const std::vector &c_poly : color_poly) { - bool force_edge = true; - for (const ColoredLine &c_line : c_poly) - if (c_line.color != c_poly.front().color) { - force_edge = false; - break; - } - force_edge_adding[&c_poly - &color_poly.front()] = force_edge; - } - - vd.construct_voronoi(lines_colored.begin(), lines_colored.end()); - MMU_Graph graph; - graph.nodes.reserve(points.size() + vd.vertices().size()); - for (const Point &point : points) - graph.nodes.push_back({Vec2d(double(point.x()), double(point.y()))}); - - graph.add_contours(color_poly); - init_polygon_indices(graph, color_poly, lines_colored); - - assert(graph.nodes.size() == lines_colored.size()); - BoundingBox bbox = get_extents(color_poly_tmp); - graph.append_voronoi_vertices(vd, color_poly_tmp, bbox); - - auto get_prev_contour_line = [&lines_colored, &color_poly, &graph](const voronoi_diagram::const_edge_iterator &edge_it) -> ColoredLine { - size_t contour_line_local_idx = lines_colored[edge_it->cell()->source_index()].local_line_idx; - size_t contour_line_size = color_poly[lines_colored[edge_it->cell()->source_index()].poly_idx].size(); - size_t contour_prev_idx = graph.get_global_index(lines_colored[edge_it->cell()->source_index()].poly_idx, - (contour_line_local_idx > 0) ? contour_line_local_idx - 1 : contour_line_size - 1); - return lines_colored[contour_prev_idx]; - }; - - auto get_next_contour_line = [&lines_colored, &color_poly, &graph](const voronoi_diagram::const_edge_iterator &edge_it) -> ColoredLine { - size_t contour_line_local_idx = lines_colored[edge_it->cell()->source_index()].local_line_idx; - size_t contour_line_size = color_poly[lines_colored[edge_it->cell()->source_index()].poly_idx].size(); - size_t contour_next_idx = graph.get_global_index(lines_colored[edge_it->cell()->source_index()].poly_idx, - (contour_line_local_idx + 1) % contour_line_size); - return lines_colored[contour_next_idx]; - }; - - bbox.offset(scale_(10.)); - const BoundingBoxf bbox_clip(bbox.min.cast(), bbox.max.cast()); - const double bbox_dim_max = double(std::max(bbox.size().x(), bbox.size().y())); - - // Make a copy of the input segments with the double type. - std::vector segments; - for (const Line &line : lines) - segments.emplace_back(Voronoi::Internal::point_type(double(line.a(0)), double(line.a(1))), - Voronoi::Internal::point_type(double(line.b(0)), double(line.b(1)))); - - for (auto edge_it = vd.edges().begin(); edge_it != vd.edges().end(); ++edge_it) { - // Skip second half-edge - if (edge_it->cell()->source_index() > edge_it->twin()->cell()->source_index() || edge_it->color()) - continue; - - if (edge_it->is_infinite() && (edge_it->vertex0() != nullptr || edge_it->vertex1() != nullptr)) { - // Infinite edge is leading through a point on the counter, but there are no Voronoi vertices. - // So we could fix this case by computing the intersection between the contour line and infinity edge. - std::vector samples; - Voronoi::Internal::clip_infinite_edge(points, segments, *edge_it, bbox_dim_max, &samples); - if (samples.empty()) - continue; - - const Line edge_line(mk_point(samples[0]), mk_point(samples[1])); - const ColoredLine &contour_line = lines_colored[edge_it->cell()->source_index()]; - Point contour_intersection; - - if (line_intersection_with_epsilon(contour_line.line, edge_line, &contour_intersection)) { - const MMU_Graph::Arc &graph_arc = graph.get_border_arc(edge_it->cell()->source_index()); - const size_t from_idx = (edge_it->vertex1() != nullptr) ? edge_it->vertex1()->color() : edge_it->vertex0()->color(); - size_t to_idx = ((contour_line.line.a - contour_intersection).cast().squaredNorm() < - (contour_line.line.b - contour_intersection).cast().squaredNorm()) ? - graph_arc.from_idx : - graph_arc.to_idx; - if (from_idx != to_idx && from_idx < graph.nodes_count() && to_idx < graph.nodes_count()) { - graph.append_edge(from_idx, to_idx); - mark_processed(edge_it); - } - } - } else if (edge_it->is_finite()) { - // Both points are on contour, so skip them. In cases of duplicate Voronoi vertices, skip edges between the same two points. - if (graph.is_edge_connecting_two_contour_vertices(edge_it) || (edge_it->vertex0()->color() == edge_it->vertex1()->color())) - continue; - - const Line edge_line = clip_finite_voronoi_edge(*edge_it, bbox_clip); - const Line contour_line = lines_colored[edge_it->cell()->source_index()].line; - const ColoredLine colored_line = lines_colored[edge_it->cell()->source_index()]; - const ColoredLine contour_line_prev = get_prev_contour_line(edge_it); - const ColoredLine contour_line_next = get_next_contour_line(edge_it); - - if (edge_it->vertex0()->color() >= graph.nodes_count() || edge_it->vertex1()->color() >= graph.nodes_count()) { - enum class Vertex { VERTEX0, VERTEX1 }; - auto append_edge_if_intersects_with_contour = [&graph, &lines_colored, &edge_line, &contour_line](const voronoi_diagram::const_edge_iterator &edge_iterator, const Vertex vertex) { - Point intersection; - Line contour_line_twin = lines_colored[edge_iterator->twin()->cell()->source_index()].line; - if (line_intersection_with_epsilon(contour_line_twin, edge_line, &intersection)) { - const MMU_Graph::Arc &graph_arc = graph.get_border_arc(edge_iterator->twin()->cell()->source_index()); - const size_t to_idx_l = is_point_closer_to_beginning_of_line(contour_line_twin, intersection) ? graph_arc.from_idx : - graph_arc.to_idx; - graph.append_edge(vertex == Vertex::VERTEX0 ? edge_iterator->vertex0()->color() : edge_iterator->vertex1()->color(), to_idx_l); - } else if (line_intersection_with_epsilon(contour_line, edge_line, &intersection)) { - const MMU_Graph::Arc &graph_arc = graph.get_border_arc(edge_iterator->cell()->source_index()); - const size_t to_idx_l = is_point_closer_to_beginning_of_line(contour_line, intersection) ? graph_arc.from_idx : graph_arc.to_idx; - graph.append_edge(vertex == Vertex::VERTEX0 ? edge_iterator->vertex0()->color() : edge_iterator->vertex1()->color(), to_idx_l); - } - mark_processed(edge_iterator); - }; - - if (edge_it->vertex0()->color() < graph.nodes_count() && !graph.is_vertex_on_contour(edge_it->vertex0())) - append_edge_if_intersects_with_contour(edge_it, Vertex::VERTEX0); - - if (edge_it->vertex1()->color() < graph.nodes_count() && !graph.is_vertex_on_contour(edge_it->vertex1())) - append_edge_if_intersects_with_contour(edge_it, Vertex::VERTEX1); - } else if (graph.is_edge_attach_to_contour(edge_it)) { - mark_processed(edge_it); - // Skip edges witch connection two points on a contour - if (graph.is_edge_connecting_two_contour_vertices(edge_it)) - continue; - - const size_t from_idx = edge_it->vertex0()->color(); - const size_t to_idx = edge_it->vertex1()->color(); - if (graph.is_vertex_on_contour(edge_it->vertex0())) { - if (is_point_closer_to_beginning_of_line(contour_line, edge_line.a)) { - if ((!has_same_color(contour_line_prev, colored_line) || force_edge_adding[colored_line.poly_idx]) && points_inside(contour_line_prev.line, contour_line, edge_line.b)) { - graph.append_edge(from_idx, to_idx); - force_edge_adding[colored_line.poly_idx] = false; - } - } else { - if ((!has_same_color(contour_line_next, colored_line) || force_edge_adding[colored_line.poly_idx]) && points_inside(contour_line, contour_line_next.line, edge_line.b)) { - graph.append_edge(from_idx, to_idx); - force_edge_adding[colored_line.poly_idx] = false; - } - } - } else { - assert(graph.is_vertex_on_contour(edge_it->vertex1())); - if (is_point_closer_to_beginning_of_line(contour_line, edge_line.b)) { - if ((!has_same_color(contour_line_prev, colored_line) || force_edge_adding[colored_line.poly_idx]) && points_inside(contour_line_prev.line, contour_line, edge_line.a)) { - graph.append_edge(from_idx, to_idx); - force_edge_adding[colored_line.poly_idx] = false; - } - } else { - if ((!has_same_color(contour_line_next, colored_line) || force_edge_adding[colored_line.poly_idx]) && points_inside(contour_line, contour_line_next.line, edge_line.a)) { - graph.append_edge(from_idx, to_idx); - force_edge_adding[colored_line.poly_idx] = false; - } - } - } - } else if (Point intersection; line_intersection_with_epsilon(contour_line, edge_line, &intersection)) { - mark_processed(edge_it); - Vec2d real_v0_double = graph.nodes[edge_it->vertex0()->color()].point; - Vec2d real_v1_double = graph.nodes[edge_it->vertex1()->color()].point; - Point real_v0 = Point(coord_t(real_v0_double.x()), coord_t(real_v0_double.y())); - Point real_v1 = Point(coord_t(real_v1_double.x()), coord_t(real_v1_double.y())); - - if (is_point_closer_to_beginning_of_line(contour_line, intersection)) { - Line first_part(intersection, real_v0); - Line second_part(intersection, real_v1); - - if (!has_same_color(contour_line_prev, colored_line)) { - if (points_inside(contour_line_prev.line, contour_line, first_part.b)) - graph.append_edge(edge_it->vertex0()->color(), graph.get_border_arc(edge_it->cell()->source_index()).from_idx); - - if (points_inside(contour_line_prev.line, contour_line, second_part.b)) - graph.append_edge(edge_it->vertex1()->color(), graph.get_border_arc(edge_it->cell()->source_index()).from_idx); - } - } else { - const size_t int_point_idx = graph.get_border_arc(edge_it->cell()->source_index()).to_idx; - const Vec2d int_point_double = graph.nodes[int_point_idx].point; - const Point int_point = Point(coord_t(int_point_double.x()), coord_t(int_point_double.y())); - - const Line first_part(int_point, real_v0); - const Line second_part(int_point, real_v1); - - if (!has_same_color(contour_line_next, colored_line)) { - if (points_inside(contour_line, contour_line_next.line, first_part.b)) - graph.append_edge(edge_it->vertex0()->color(), int_point_idx); - - if (points_inside(contour_line, contour_line_next.line, second_part.b)) - graph.append_edge(edge_it->vertex1()->color(), int_point_idx); - } - } - } - } - } - - for (auto edge_it = vd.edges().begin(); edge_it != vd.edges().end(); ++edge_it) { - // Skip second half-edge and processed edges - if (edge_it->cell()->source_index() > edge_it->twin()->cell()->source_index() || edge_it->color()) - continue; - - if (edge_it->is_finite() && !bool(edge_it->color()) && edge_it->vertex0()->color() < graph.nodes_count() && - edge_it->vertex1()->color() < graph.nodes_count()) { - // Skip cases, when the edge is between two same vertices, which is in cases two near vertices were merged together. - if (edge_it->vertex0()->color() == edge_it->vertex1()->color()) - continue; - - size_t from_idx = edge_it->vertex0()->color(); - size_t to_idx = edge_it->vertex1()->color(); - graph.append_edge(from_idx, to_idx); - } - mark_processed(edge_it); - } - - graph.remove_nodes_with_one_arc(); - return graph; -} - -static inline Polygon to_polygon(const std::vector &lines) -{ - Polygon poly_out; - poly_out.points.reserve(lines.size()); - for (const Linef &line : lines) - poly_out.points.emplace_back(mk_point(line.a)); - return poly_out; -} - -// Returns list of polygons and assigned colors. -// It iterates through all nodes on the border between two different colors, and from this point, -// start selection always left most edges for every node to construct CCW polygons. -// Assumes that graph is planar (without self-intersection edges) -static std::vector extract_colored_segments(const MMU_Graph &graph, const size_t num_extruders) -{ - std::vector used_arcs(graph.arcs.size(), false); - // When there is no next arc, then is returned original_arc or edge with is marked as used - auto get_next = [&graph, &used_arcs](const Linef &process_line, const MMU_Graph::Arc &original_arc) -> const MMU_Graph::Arc & { - std::vector> sorted_arcs; - for (const size_t &arc_idx : graph.nodes[original_arc.to_idx].arc_idxs) { - const MMU_Graph::Arc &arc = graph.arcs[arc_idx]; - if (graph.nodes[arc.to_idx].point == process_line.a || used_arcs[arc_idx]) - continue; - - assert(original_arc.to_idx == arc.from_idx); - Vec2d process_line_vec_n = (process_line.a - process_line.b).normalized(); - Vec2d neighbour_line_vec_n = (graph.nodes[arc.to_idx].point - graph.nodes[arc.from_idx].point).normalized(); - - double angle = ::acos(std::clamp(neighbour_line_vec_n.dot(process_line_vec_n), -1.0, 1.0)); - if (Slic3r::cross2(neighbour_line_vec_n, process_line_vec_n) < 0.0) - angle = 2.0 * (double) PI - angle; - - sorted_arcs.emplace_back(&arc, angle); - } - - std::sort(sorted_arcs.begin(), sorted_arcs.end(), - [](std::pair &l, std::pair &r) -> bool { return l.second < r.second; }); - - // Try to return left most edge witch is unused - for (auto &sorted_arc : sorted_arcs) - if (size_t arc_idx = sorted_arc.first - &graph.arcs.front(); !used_arcs[arc_idx]) - return *sorted_arc.first; - - if (sorted_arcs.empty()) - return original_arc; - - return *(sorted_arcs.front().first); - }; - - auto all_arc_used = [&used_arcs](const MMU_Graph::Node &node) -> bool { - return std::all_of(node.arc_idxs.cbegin(), node.arc_idxs.cend(), [&used_arcs](const size_t &arc_idx) -> bool { return used_arcs[arc_idx]; }); - }; - - std::vector expolygons_segments(num_extruders + 1); - for (size_t node_idx = 0; node_idx < graph.all_border_points; ++node_idx) { - const MMU_Graph::Node &node = graph.nodes[node_idx]; - - for (const size_t &arc_idx : node.arc_idxs) { - const MMU_Graph::Arc &arc = graph.arcs[arc_idx]; - if (arc.type == MMU_Graph::ARC_TYPE::NON_BORDER || used_arcs[arc_idx]) - continue; - - Linef process_line(node.point, graph.nodes[arc.to_idx].point); - used_arcs[arc_idx] = true; - - std::vector face_lines; - face_lines.emplace_back(process_line); - Vec2d start_p = process_line.a; - - Linef p_vec = process_line; - const MMU_Graph::Arc *p_arc = &arc; - do { - const MMU_Graph::Arc &next = get_next(p_vec, *p_arc); - size_t next_arc_idx = &next - &graph.arcs.front(); - face_lines.emplace_back(graph.nodes[next.from_idx].point, graph.nodes[next.to_idx].point); - if (used_arcs[next_arc_idx]) - break; - - used_arcs[next_arc_idx] = true; - p_vec = Linef(graph.nodes[next.from_idx].point, graph.nodes[next.to_idx].point); - p_arc = &next; - } while (graph.nodes[p_arc->to_idx].point != start_p || !all_arc_used(graph.nodes[p_arc->to_idx])); - - if (Polygon poly = to_polygon(face_lines); poly.is_counter_clockwise() && poly.is_valid()) - expolygons_segments[arc.color].emplace_back(std::move(poly)); - } - } - return expolygons_segments; + return mk_vector_vec2d(&edge).norm(); } // Used in remove_multiple_edges_in_vertices() // Returns length of edge with is connected to contour. To this length is include other edges with follows it if they are almost straight (with the // tolerance of 15) And also if node between two subsequent edges is connected only to these two edges. -static inline double compute_edge_length(const MMU_Graph &graph, const size_t start_idx, const size_t &start_arc_idx) +static inline double calc_total_edge_length(const VD::edge_type &starting_edge) { - assert(start_arc_idx < graph.arcs.size()); - std::vector used_arcs(graph.arcs.size(), false); - - used_arcs[start_arc_idx] = true; - const MMU_Graph::Arc *arc = &graph.arcs[start_arc_idx]; - size_t idx = start_idx; - double line_total_length = (graph.nodes[arc->to_idx].point - graph.nodes[idx].point).norm(); - while (graph.nodes[arc->to_idx].arc_idxs.size() == 2) { - bool found = false; - for (const size_t &arc_idx : graph.nodes[arc->to_idx].arc_idxs) { - if (const MMU_Graph::Arc &arc_n = graph.arcs[arc_idx]; arc_n.type == MMU_Graph::ARC_TYPE::NON_BORDER && !used_arcs[arc_idx] && arc_n.to_idx != idx) { - Linef first_line(graph.nodes[idx].point, graph.nodes[arc->to_idx].point); - Linef second_line(graph.nodes[arc->to_idx].point, graph.nodes[arc_n.to_idx].point); - - Vec2d first_line_vec = (first_line.a - first_line.b); - Vec2d second_line_vec = (second_line.b - second_line.a); - Vec2d first_line_vec_n = first_line_vec.normalized(); - Vec2d second_line_vec_n = second_line_vec.normalized(); - double angle = ::acos(std::clamp(first_line_vec_n.dot(second_line_vec_n), -1.0, 1.0)); - if (Slic3r::cross2(first_line_vec_n, second_line_vec_n) < 0.0) - angle = 2.0 * (double) PI - angle; - - if (std::abs(angle - PI) >= (PI / 12)) - continue; - - idx = arc->to_idx; - arc = &arc_n; - - line_total_length += (graph.nodes[arc->to_idx].point - graph.nodes[idx].point).norm(); - used_arcs[arc_idx] = true; - found = true; - break; - } - } - if (!found) + double total_edge_length = edge_length(starting_edge); + const VD::edge_type *prev = &starting_edge; + do { + if (prev->is_finite() && non_deleted_edge_count(*prev->vertex1()) > 2) break; - } - return line_total_length; + bool found_next_edge = false; + const VD::edge_type *current = prev->next(); + do { + if (current->color() == VD_ANNOTATION::DELETED) + continue; + + Vec2d first_line_vec_n = mk_flipped_vector_vec2d(prev).normalized(); + Vec2d second_line_vec_n = mk_vector_vec2d(current).normalized(); + double angle = ::acos(std::clamp(first_line_vec_n.dot(second_line_vec_n), -1.0, 1.0)); + if (Slic3r::cross2(first_line_vec_n, second_line_vec_n) < 0.0) + angle = 2.0 * (double) PI - angle; + + if (std::abs(angle - PI) >= (PI / 12)) + continue; + + prev = current; + found_next_edge = true; + total_edge_length += edge_length(*current); + + break; + } while (current = current->prev()->twin(), current != prev->next()); + + if (!found_next_edge) + break; + + } while (prev != &starting_edge); + + return total_edge_length; } -// Used for fixing double Voronoi edges for concave parts of the polygon. -static void remove_multiple_edges_in_vertices(MMU_Graph &graph, const std::vector> &color_poly) +// When a Voronoi vertex has more than one Voronoi edge (for example, in concave parts of a polygon), +// we leave just one Voronoi edge in the Voronoi vertex. +// This Voronoi edge is selected based on a heuristic. +static void remove_multiple_edges_in_vertex(const VD::vertex_type &vertex) { + if (non_deleted_edge_count(vertex) <= 1) + return; + + std::vector> edges_to_check; + const VD::edge_type *edge = vertex.incident_edge(); + do { + if (edge->color() == VD_ANNOTATION::DELETED) + continue; + + edges_to_check.emplace_back(edge, calc_total_edge_length(*edge)); + } while (edge = edge->prev()->twin(), edge != vertex.incident_edge()); + + std::sort(edges_to_check.begin(), edges_to_check.end(), [](const auto &l, const auto &r) -> bool { + return l.second > r.second; + }); + + while (edges_to_check.size() > 1) { + const VD::edge_type &edge_to_check = *edges_to_check.back().first; + edge_to_check.color(VD_ANNOTATION::DELETED); + edge_to_check.twin()->color(VD_ANNOTATION::DELETED); + + if (const VD::vertex_type &vertex_to_delete = *edge_to_check.vertex1(); can_vertex_be_deleted(vertex_to_delete)) + delete_vertex_deep(vertex_to_delete); + + edges_to_check.pop_back(); + } +} + +// Returns list of ExPolygons for each extruder + 1 for default unpainted regions. +// It iterates through all nodes on the border between two different colors, and from this point, +// start selection always left most edges for every node to construct CCW polygons. +static std::vector extract_colored_segments(const std::vector &colored_polygons, + const size_t num_extruders, + const size_t layer_idx) { - std::vector>> colored_segments = get_all_segments(color_poly); - for (const std::vector> &colored_segment_p : colored_segments) { - size_t poly_idx = &colored_segment_p - &colored_segments.front(); - for (const std::pair &colored_segment : colored_segment_p) { - size_t first_idx = graph.get_global_index(poly_idx, colored_segment.first); - size_t second_idx = graph.get_global_index(poly_idx, (colored_segment.second + 1) % graph.polygon_sizes[poly_idx]); - Linef seg_line(graph.nodes[first_idx].point, graph.nodes[second_idx].point); + const ColoredLines colored_lines = to_lines(colored_polygons); + const BoundingBox bbox = get_extents(colored_polygons); - if (graph.nodes[first_idx].arc_idxs.size() >= 3) { - std::vector> arc_to_check; - for (const size_t &arc_idx : graph.nodes[first_idx].arc_idxs) { - MMU_Graph::Arc &n_arc = graph.arcs[arc_idx]; - if (n_arc.type == MMU_Graph::ARC_TYPE::NON_BORDER) { - double total_len = compute_edge_length(graph, first_idx, arc_idx); - arc_to_check.emplace_back(&n_arc, total_len); - } - } - std::sort(arc_to_check.begin(), arc_to_check.end(), - [](std::pair &l, std::pair &r) -> bool { return l.second > r.second; }); + auto get_next_contour_line = [&colored_polygons](const ColoredLine &line) -> const ColoredLine & { + size_t contour_line_size = colored_polygons[line.poly_idx].size(); + size_t contour_next_idx = (line.local_line_idx + 1) % contour_line_size; + return colored_polygons[line.poly_idx][contour_next_idx]; + }; - while (arc_to_check.size() > 1) { - graph.remove_edge(first_idx, arc_to_check.back().first->to_idx); - arc_to_check.pop_back(); - } - } + Voronoi::VD vd; + vd.construct_voronoi(colored_lines.begin(), colored_lines.end()); + + // First, mark each Voronoi vertex on the input polygon to prevent it from being deleted later. + for (const Voronoi::VD::cell_type &cell : vd.cells()) { + if (cell.is_degenerate() || !cell.contains_segment()) + continue; + + if (const Geometry::SegmentCellRange cell_range = Geometry::VoronoiUtils::compute_segment_cell_range(cell, colored_lines.begin(), colored_lines.end()); cell_range.is_valid()) + cell_range.edge_begin->vertex0()->color(VD_ANNOTATION::VERTEX_ON_CONTOUR); + } + + // Second, remove all Voronoi vertices that are outside the bounding box of input polygons. + // Such Voronoi vertices are definitely not inside of input polygons, so we don't care about them. + for (const Voronoi::VD::vertex_type &vertex : vd.vertices()) { + if (vertex.color() == VD_ANNOTATION::DELETED || vertex.color() == VD_ANNOTATION::VERTEX_ON_CONTOUR) + continue; + + if (!Geometry::VoronoiUtils::is_in_range(vertex) || !bbox.contains(Geometry::VoronoiUtils::to_point(vertex).cast())) + delete_vertex_deep(vertex); + } + + // Third, remove all Voronoi edges that are infinite. + for (const Voronoi::VD::edge_type &edge : vd.edges()) { + if (edge.color() != VD_ANNOTATION::DELETED && edge.is_infinite()) { + edge.color(VD_ANNOTATION::DELETED); + edge.twin()->color(VD_ANNOTATION::DELETED); + + if (edge.vertex0() != nullptr && can_vertex_be_deleted(*edge.vertex0())) + delete_vertex_deep(*edge.vertex0()); + + if (edge.vertex1() != nullptr && can_vertex_be_deleted(*edge.vertex1())) + delete_vertex_deep(*edge.vertex1()); } } + + // Fourth, remove all edges that point outward from the input polygon. + for (Voronoi::VD::cell_type cell : vd.cells()) { + if (cell.is_degenerate() || !cell.contains_segment()) + continue; + + if (const Geometry::SegmentCellRange cell_range = Geometry::VoronoiUtils::compute_segment_cell_range(cell, colored_lines.begin(), colored_lines.end()); cell_range.is_valid()) { + const ColoredLine ¤t_line = Geometry::VoronoiUtils::get_source_segment(cell, colored_lines.begin(), colored_lines.end()); + const ColoredLine &next_line = get_next_contour_line(current_line); + + const VD::edge_type *edge = cell_range.edge_begin; + do { + if (edge->color() == VD_ANNOTATION::DELETED) + continue; + + if (!points_inside(current_line.line, next_line.line, Geometry::VoronoiUtils::to_point(edge->vertex1()).cast())) { + edge->color(VD_ANNOTATION::DELETED); + edge->twin()->color(VD_ANNOTATION::DELETED); + delete_vertex_deep(*edge->vertex1()); + } + } while (edge = edge->prev()->twin(), edge != cell_range.edge_begin); + } + } + + // Fifth, if a Voronoi vertex has more than one Voronoi edge, remove all but one of them based on heuristics. + for (const Voronoi::VD::vertex_type &vertex : vd.vertices()) { + if (vertex.color() == VD_ANNOTATION::VERTEX_ON_CONTOUR) + remove_multiple_edges_in_vertex(vertex); + } + +#ifdef MM_SEGMENTATION_DEBUG_GRAPH + { + static int iRun = 0; + export_graph_to_svg(debug_out_path("mm-graph-%d-%d.svg", layer_idx, iRun++), vd, colored_polygons); + } +#endif // MM_SEGMENTATION_DEBUG_GRAPH + + // Sixth, extract the colored segments from the annotated Voronoi diagram. + std::vector segmented_expolygons_per_extruder(num_extruders + 1); + for (const Voronoi::VD::cell_type &cell : vd.cells()) { + if (cell.is_degenerate() || !cell.contains_segment()) + continue; + + if (const Geometry::SegmentCellRange cell_range = Geometry::VoronoiUtils::compute_segment_cell_range(cell, colored_lines.begin(), colored_lines.end()); cell_range.is_valid()) { + if (cell_range.edge_begin->vertex0()->color() != VD_ANNOTATION::VERTEX_ON_CONTOUR) + continue; + + const ColoredLine source_segment = Geometry::VoronoiUtils::get_source_segment(cell, colored_lines.begin(), colored_lines.end()); + + Polygon segmented_polygon; + segmented_polygon.points.emplace_back(source_segment.line.b); + + // We have ensured that each segmented_polygon have to start at edge_begin->vertex0() and end at edge_end->vertex1(). + const VD::edge_type *edge = cell_range.edge_begin; + do { + if (edge->color() == VD_ANNOTATION::DELETED) + continue; + + const VD::vertex_type &next_vertex = *edge->vertex1(); + segmented_polygon.points.emplace_back(Geometry::VoronoiUtils::to_point(next_vertex).cast()); + edge->color(VD_ANNOTATION::DELETED); + + if (next_vertex.color() == VD_ANNOTATION::VERTEX_ON_CONTOUR || next_vertex.color() == VD_ANNOTATION::DELETED) { + assert(next_vertex.color() == VD_ANNOTATION::VERTEX_ON_CONTOUR); + break; + } + + edge = edge->twin(); + } while (edge = edge->twin()->next(), edge != cell_range.edge_begin); + + if (edge->vertex1() != cell_range.edge_end->vertex1()) + continue; + + cell_range.edge_begin->vertex0()->color(VD_ANNOTATION::DELETED); + segmented_expolygons_per_extruder[source_segment.color].emplace_back(std::move(segmented_polygon)); + } + } + + // Merge all polygons together for each extruder + for (auto &segmented_expolygons : segmented_expolygons_per_extruder) + segmented_expolygons = union_ex(segmented_expolygons); + + return segmented_expolygons_per_extruder; } static void cut_segmented_layers(const std::vector &input_expolygons, @@ -1255,7 +832,7 @@ static void cut_segmented_layers(const std::vector &input_exp const float interlocking_depth, const std::function &throw_on_cancel_callback) { - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - cutting segmented layers in parallel - begin"; + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - cutting segmented layers in parallel - begin"; const float interlocking_cut_width = interlocking_depth > 0.f ? std::max(cut_width - interlocking_depth, 0.f) : 0.f; tbb::parallel_for(tbb::blocked_range(0, segmented_regions.size()),[&segmented_regions, &input_expolygons, &cut_width, &interlocking_cut_width, &throw_on_cancel_callback](const tbb::blocked_range& range) { for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) { @@ -1271,7 +848,7 @@ static void cut_segmented_layers(const std::vector &input_exp } } }); // end of parallel_for - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - cutting segmented layers in parallel - end"; + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - cutting segmented layers in parallel - end"; } static bool is_volume_sinking(const indexed_triangle_set &its, const Transform3d &trafo) @@ -1282,12 +859,10 @@ static bool is_volume_sinking(const indexed_triangle_set &its, const Transform3d return false; } -//#define MMU_SEGMENTATION_DEBUG_TOP_BOTTOM - -// Returns MMU segmentation of top and bottom layers based on painting in MMU segmentation gizmo -static inline std::vector> mmu_segmentation_top_and_bottom_layers(const PrintObject &print_object, - const std::vector &input_expolygons, - const std::function &throw_on_cancel_callback) +// Returns MM segmentation of top and bottom layers based on painting in MM segmentation gizmo +static inline std::vector> mm_segmentation_top_and_bottom_layers(const PrintObject &print_object, + const std::vector &input_expolygons, + const std::function &throw_on_cancel_callback) { const size_t num_extruders = print_object.print()->config().nozzle_diameter.size() + 1; const size_t num_layers = input_expolygons.size(); @@ -1310,22 +885,22 @@ static inline std::vector> mmu_segmentation_top_and_bott std::vector zs = zs_from_layers(layers); Transform3d object_trafo = print_object.trafo_centered(); -#ifdef MMU_SEGMENTATION_DEBUG_TOP_BOTTOM +#ifdef MM_SEGMENTATION_DEBUG_TOP_BOTTOM static int iRun = 0; -#endif // NDEBUG +#endif // MM_SEGMENTATION_DEBUG_TOP_BOTTOM if (max_top_layers > 0 || max_bottom_layers > 0) { for (const ModelVolume *mv : print_object.model_object()->volumes) if (mv->is_model_part()) { const Transform3d volume_trafo = object_trafo * mv->get_matrix(); for (size_t extruder_idx = 0; extruder_idx < num_extruders; ++ extruder_idx) { - const indexed_triangle_set painted = mv->mmu_segmentation_facets.get_facets_strict(*mv, EnforcerBlockerType(extruder_idx)); -#ifdef MMU_SEGMENTATION_DEBUG_TOP_BOTTOM + const indexed_triangle_set painted = mv->mm_segmentation_facets.get_facets_strict(*mv, EnforcerBlockerType(extruder_idx)); +#ifdef MM_SEGMENTATION_DEBUG_TOP_BOTTOM { static int iRun = 0; its_write_obj(painted, debug_out_path("mm-painted-patch-%d-%d.obj", iRun ++, extruder_idx).c_str()); } -#endif // MMU_SEGMENTATION_DEBUG_TOP_BOTTOM +#endif // MM_SEGMENTATION_DEBUG_TOP_BOTTOM if (! painted.indices.empty()) { std::vector top, bottom; if (!zs.empty() && is_volume_sinking(painted, volume_trafo)) { @@ -1380,7 +955,7 @@ static inline std::vector> mmu_segmentation_top_and_bott filter_out_small_polygons(top_raw, Slic3r::sqr(scale_(0.1f))); filter_out_small_polygons(bottom_raw, Slic3r::sqr(scale_(0.1f))); -#ifdef MMU_SEGMENTATION_DEBUG_TOP_BOTTOM +#ifdef MM_SEGMENTATION_DEBUG_TOP_BOTTOM { const char* colors[] = { "aqua", "black", "blue", "fuchsia", "gray", "green", "lime", "maroon", "navy", "olive", "purple", "red", "silver", "teal", "yellow" }; static int iRun = 0; @@ -1402,7 +977,7 @@ static inline std::vector> mmu_segmentation_top_and_bott } ++ iRun; } -#endif // MMU_SEGMENTATION_DEBUG_TOP_BOTTOM +#endif // MM_SEGMENTATION_DEBUG_TOP_BOTTOM std::vector> triangles_by_color_bottom(num_extruders); std::vector> triangles_by_color_top(num_extruders); @@ -1533,7 +1108,7 @@ static std::vector> merge_segmented_layers( segmented_regions_merged.assign(num_layers, std::vector(num_extruders)); assert(num_extruders + 1 == top_and_bottom_layers.size()); - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - merging segmented layers in parallel - begin"; + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - merging segmented layers in parallel - begin"; tbb::parallel_for(tbb::blocked_range(0, num_layers), [&segmented_regions, &top_and_bottom_layers, &segmented_regions_merged, &num_extruders, &throw_on_cancel_callback](const tbb::blocked_range &range) { for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) { assert(segmented_regions[layer_idx].size() == num_extruders + 1); @@ -1560,12 +1135,12 @@ static std::vector> merge_segmented_layers( } } }); // end of parallel_for - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - merging segmented layers in parallel - end"; + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - merging segmented layers in parallel - end"; return segmented_regions_merged; } -#ifdef MMU_SEGMENTATION_DEBUG_REGIONS +#ifdef MM_SEGMENTATION_DEBUG_REGIONS static void export_regions_to_svg(const std::string &path, const std::vector ®ions, const ExPolygons &lslices) { const std::vector colors = {"blue", "cyan", "red", "orange", "magenta", "pink", "purple", "yellow"}; @@ -1577,35 +1152,15 @@ static void export_regions_to_svg(const std::string &path, const std::vector= 0 && extrude_idx < int(colors.size())) - svg.draw(by_extruder, colors[extrude_idx], stroke_width); + if (extrude_idx < int(colors.size())) + svg.draw(by_extruder, colors[extrude_idx]); else - svg.draw(by_extruder, "black", stroke_width); + svg.draw(by_extruder, "black"); } } -#endif // MMU_SEGMENTATION_DEBUG_REGIONS +#endif // MM_SEGMENTATION_DEBUG_REGIONS -#ifdef MMU_SEGMENTATION_DEBUG_GRAPH -static void export_graph_to_svg(const std::string &path, const MMU_Graph &graph, const ExPolygons &lslices) -{ - const std::vector colors = {"blue", "cyan", "red", "orange", "magenta", "pink", "purple", "green", "yellow"}; - coordf_t stroke_width = scale_(0.05); - BoundingBox bbox = get_extents(lslices); - bbox.offset(scale_(1.)); - ::Slic3r::SVG svg(path.c_str(), bbox); - for (const MMU_Graph::Node &node : graph.nodes) - for (const size_t &arc_idx : node.arc_idxs) { - const MMU_Graph::Arc &arc = graph.arcs[arc_idx]; - Line arc_line(mk_point(node.point), mk_point(graph.nodes[arc.to_idx].point)); - if (arc.type == MMU_Graph::ARC_TYPE::BORDER && arc.color >= 0 && arc.color < int(colors.size())) - svg.draw(arc_line, colors[arc.color], stroke_width); - else - svg.draw(arc_line, "black", stroke_width); - } -} -#endif // MMU_SEGMENTATION_DEBUG_GRAPH - -#ifdef MMU_SEGMENTATION_DEBUG_INPUT +#ifdef MM_SEGMENTATION_DEBUG_INPUT void export_processed_input_expolygons_to_svg(const std::string &path, const LayerRegionPtrs ®ions, const ExPolygons &processed_input_expolygons) { coordf_t stroke_width = scale_(0.05); @@ -1615,13 +1170,14 @@ void export_processed_input_expolygons_to_svg(const std::string &path, const Lay ::Slic3r::SVG svg(path.c_str(), bbox); for (LayerRegion *region : regions) - svg.draw_outline(region->slices.surfaces, "blue", "cyan", stroke_width); + for (const Surface &surface : region->slices()) + svg.draw_outline(surface, "blue", "cyan", stroke_width); svg.draw_outline(processed_input_expolygons, "red", "pink", stroke_width); } -#endif // MMU_SEGMENTATION_DEBUG_INPUT +#endif // MM_SEGMENTATION_DEBUG_INPUT -#ifdef MMU_SEGMENTATION_DEBUG_PAINTED_LINES +#ifdef MM_SEGMENTATION_DEBUG_PAINTED_LINES static void export_painted_lines_to_svg(const std::string &path, const std::vector> &all_painted_lines, const ExPolygons &lslices) { const std::vector colors = {"blue", "cyan", "red", "orange", "magenta", "pink", "purple", "yellow"}; @@ -1637,10 +1193,10 @@ static void export_painted_lines_to_svg(const std::string &path, const std::vect for (const PaintedLine &painted_line : painted_lines) svg.draw(painted_line.projected_line, painted_line.color < int(colors.size()) ? colors[painted_line.color] : "black", stroke_width); } -#endif // MMU_SEGMENTATION_DEBUG_PAINTED_LINES +#endif // MM_SEGMENTATION_DEBUG_PAINTED_LINES -#ifdef MMU_SEGMENTATION_DEBUG_COLORIZED_POLYGONS -static void export_colorized_polygons_to_svg(const std::string &path, const std::vector> &colorized_polygons, const ExPolygons &lslices) +#ifdef MM_SEGMENTATION_DEBUG_COLORIZED_POLYGONS +static void export_colorized_polygons_to_svg(const std::string &path, const std::vector &colorized_polygons, const ExPolygons &lslices) { const std::vector colors = {"blue", "cyan", "red", "orange", "magenta", "pink", "purple", "green", "yellow"}; coordf_t stroke_width = scale_(0.05); @@ -1648,19 +1204,19 @@ static void export_colorized_polygons_to_svg(const std::string &path, const std: bbox.offset(scale_(1.)); ::Slic3r::SVG svg(path.c_str(), bbox); - for (const std::vector &colorized_polygon : colorized_polygons) + for (const ColoredLines &colorized_polygon : colorized_polygons) for (const ColoredLine &colorized_line : colorized_polygon) svg.draw(colorized_line.line, colorized_line.color < int(colors.size())? colors[colorized_line.color] : "black", stroke_width); } -#endif // MMU_SEGMENTATION_DEBUG_COLORIZED_POLYGONS +#endif // MM_SEGMENTATION_DEBUG_COLORIZED_POLYGONS // Check if all ColoredLine representing a single layer uses the same color. -static bool has_layer_only_one_color(const std::vector> &colored_polygons) +static bool has_layer_only_one_color(const std::vector &colored_polygons) { assert(!colored_polygons.empty()); assert(!colored_polygons.front().empty()); int first_line_color = colored_polygons.front().front().color; - for (const std::vector &colored_polygon : colored_polygons) + for (const ColoredLines &colored_polygon : colored_polygons) for (const ColoredLine &colored_line : colored_polygon) if (first_line_color != colored_line.color) return false; @@ -1682,8 +1238,12 @@ std::vector> multi_material_segmentation_by_painting(con throw_on_cancel_callback(); +#ifdef MM_SEGMENTATION_DEBUG + static int iRun = 0; +#endif // MM_SEGMENTATION_DEBUG + // Merge all regions and remove small holes - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - slices preparation in parallel - begin"; + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - slices preparation in parallel - begin"; tbb::parallel_for(tbb::blocked_range(0, num_layers), [&layers, &input_expolygons, &throw_on_cancel_callback](const tbb::blocked_range &range) { for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) { throw_on_cancel_callback(); @@ -1705,15 +1265,12 @@ std::vector> multi_material_segmentation_by_painting(con // Calling expolygons_simplify fixed these issues. input_expolygons[layer_idx] = remove_duplicates(expolygons_simplify(offset_ex(ex_polygons, -10.f * float(SCALED_EPSILON)), 5 * SCALED_EPSILON), scaled(0.01), PI/6); -#ifdef MMU_SEGMENTATION_DEBUG_INPUT - { - static int iRun = 0; - export_processed_input_expolygons_to_svg(debug_out_path("mm-input-%d-%d.svg", layer_idx, iRun++), layers[layer_idx]->regions(), input_expolygons[layer_idx]); - } -#endif // MMU_SEGMENTATION_DEBUG_INPUT +#ifdef MM_SEGMENTATION_DEBUG_INPUT + export_processed_input_expolygons_to_svg(debug_out_path("mm-input-%d-%d.svg", layer_idx, iRun), layers[layer_idx]->regions(), input_expolygons[layer_idx]); +#endif // MM_SEGMENTATION_DEBUG_INPUT } }); // end of parallel_for - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - slices preparation in parallel - end"; + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - slices preparation in parallel - end"; std::vector layer_bboxes(num_layers); for (size_t layer_idx = 0; layer_idx < num_layers; ++layer_idx) { @@ -1736,12 +1293,12 @@ std::vector> multi_material_segmentation_by_painting(con edge_grids[layer_idx].create(input_expolygons[layer_idx], coord_t(scale_(10.))); } - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - projection of painted triangles - begin"; + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - projection of painted triangles - begin"; for (const ModelVolume *mv : print_object.model_object()->volumes) { tbb::parallel_for(tbb::blocked_range(1, num_extruders + 1), [&mv, &print_object, &layers, &edge_grids, &painted_lines, &painted_lines_mutex, &input_expolygons, &throw_on_cancel_callback](const tbb::blocked_range &range) { for (size_t extruder_idx = range.begin(); extruder_idx < range.end(); ++extruder_idx) { throw_on_cancel_callback(); - const indexed_triangle_set custom_facets = mv->mmu_segmentation_facets.get_facets(*mv, EnforcerBlockerType(extruder_idx)); + const indexed_triangle_set custom_facets = mv->mm_segmentation_facets.get_facets(*mv, EnforcerBlockerType(extruder_idx)); if (!mv->is_model_part() || custom_facets.indices.empty()) continue; @@ -1817,39 +1374,30 @@ std::vector> multi_material_segmentation_by_painting(con } }); // end of parallel_for } - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - projection of painted triangles - end"; - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - painted layers count: " + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - projection of painted triangles - end"; + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - painted layers count: " << std::count_if(painted_lines.begin(), painted_lines.end(), [](const std::vector &pl) { return !pl.empty(); }); - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - layers segmentation in parallel - begin"; + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - layers segmentation in parallel - begin"; tbb::parallel_for(tbb::blocked_range(0, num_layers), [&edge_grids, &input_expolygons, &painted_lines, &segmented_regions, &num_extruders, &throw_on_cancel_callback](const tbb::blocked_range &range) { for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) { throw_on_cancel_callback(); if (!painted_lines[layer_idx].empty()) { -#ifdef MMU_SEGMENTATION_DEBUG_PAINTED_LINES - { - static int iRun = 0; - export_painted_lines_to_svg(debug_out_path("mm-painted-lines-%d-%d.svg", layer_idx, iRun++), {painted_lines[layer_idx]}, input_expolygons[layer_idx]); - } -#endif // MMU_SEGMENTATION_DEBUG_PAINTED_LINES +#ifdef MM_SEGMENTATION_DEBUG_PAINTED_LINES + export_painted_lines_to_svg(debug_out_path("mm-painted-lines-%d-%d.svg", layer_idx, iRun), {painted_lines[layer_idx]}, input_expolygons[layer_idx]); +#endif // MM_SEGMENTATION_DEBUG_PAINTED_LINES std::vector> post_processed_painted_lines = post_process_painted_lines(edge_grids[layer_idx].contours(), std::move(painted_lines[layer_idx])); -#ifdef MMU_SEGMENTATION_DEBUG_PAINTED_LINES - { - static int iRun = 0; - export_painted_lines_to_svg(debug_out_path("mm-painted-lines-post-processed-%d-%d.svg", layer_idx, iRun++), post_processed_painted_lines, input_expolygons[layer_idx]); - } -#endif // MMU_SEGMENTATION_DEBUG_PAINTED_LINES +#ifdef MM_SEGMENTATION_DEBUG_PAINTED_LINES + export_painted_lines_to_svg(debug_out_path("mm-painted-lines-post-processed-%d-%d.svg", layer_idx, iRun), post_processed_painted_lines, input_expolygons[layer_idx]); +#endif // MM_SEGMENTATION_DEBUG_PAINTED_LINES - std::vector> color_poly = colorize_contours(edge_grids[layer_idx].contours(), post_processed_painted_lines); + std::vector color_poly = colorize_contours(edge_grids[layer_idx].contours(), post_processed_painted_lines); -#ifdef MMU_SEGMENTATION_DEBUG_COLORIZED_POLYGONS - { - static int iRun = 0; - export_colorized_polygons_to_svg(debug_out_path("mm-colorized_polygons-%d-%d.svg", layer_idx, iRun++), color_poly, input_expolygons[layer_idx]); - } -#endif // MMU_SEGMENTATION_DEBUG_COLORIZED_POLYGONS +#ifdef MM_SEGMENTATION_DEBUG_COLORIZED_POLYGONS + export_colorized_polygons_to_svg(debug_out_path("mm-colorized_polygons-%d-%d.svg", layer_idx, iRun), color_poly, input_expolygons[layer_idx]); +#endif // MM_SEGMENTATION_DEBUG_COLORIZED_POLYGONS assert(!color_poly.empty()); assert(!color_poly.front().empty()); @@ -1857,30 +1405,16 @@ std::vector> multi_material_segmentation_by_painting(con // If the whole layer is painted using the same color, it is not needed to construct a Voronoi diagram for the segmentation of this layer. segmented_regions[layer_idx][size_t(color_poly.front().front().color)] = input_expolygons[layer_idx]; } else { - MMU_Graph graph = build_graph(layer_idx, color_poly); - remove_multiple_edges_in_vertices(graph, color_poly); - graph.remove_nodes_with_one_arc(); - -#ifdef MMU_SEGMENTATION_DEBUG_GRAPH - { - static int iRun = 0; - export_graph_to_svg(debug_out_path("mm-graph-final-%d-%d.svg", layer_idx, iRun++), graph, input_expolygons[layer_idx]); - } -#endif // MMU_SEGMENTATION_DEBUG_GRAPH - - segmented_regions[layer_idx] = extract_colored_segments(graph, num_extruders); + segmented_regions[layer_idx] = extract_colored_segments(color_poly, num_extruders, layer_idx); } -#ifdef MMU_SEGMENTATION_DEBUG_REGIONS - { - static int iRun = 0; - export_regions_to_svg(debug_out_path("mm-regions-sides-%d-%d.svg", layer_idx, iRun++), segmented_regions[layer_idx], input_expolygons[layer_idx]); - } -#endif // MMU_SEGMENTATION_DEBUG_REGIONS +#ifdef MM_SEGMENTATION_DEBUG_REGIONS + export_regions_to_svg(debug_out_path("mm-regions-sides-%d-%d.svg", layer_idx, iRun), segmented_regions[layer_idx], input_expolygons[layer_idx]); +#endif // MM_SEGMENTATION_DEBUG_REGIONS } } }); // end of parallel_for - BOOST_LOG_TRIVIAL(debug) << "MMU segmentation - layers segmentation in parallel - end"; + BOOST_LOG_TRIVIAL(debug) << "MM segmentation - layers segmentation in parallel - end"; throw_on_cancel_callback(); if (auto max_width = print_object.config().mmu_segmented_region_max_width, interlocking_depth = print_object.config().mmu_segmented_region_interlocking_depth; max_width > 0.f) { @@ -1889,19 +1423,20 @@ std::vector> multi_material_segmentation_by_painting(con } // The first index is extruder number (includes default extruder), and the second one is layer number - std::vector> top_and_bottom_layers = mmu_segmentation_top_and_bottom_layers(print_object, input_expolygons, throw_on_cancel_callback); + std::vector> top_and_bottom_layers = mm_segmentation_top_and_bottom_layers(print_object, input_expolygons, throw_on_cancel_callback); throw_on_cancel_callback(); std::vector> segmented_regions_merged = merge_segmented_layers(segmented_regions, std::move(top_and_bottom_layers), num_extruders, throw_on_cancel_callback); throw_on_cancel_callback(); -#ifdef MMU_SEGMENTATION_DEBUG_REGIONS - { - static int iRun = 0; - for (size_t layer_idx = 0; layer_idx < print_object.layers().size(); ++layer_idx) - export_regions_to_svg(debug_out_path("mm-regions-merged-%d-%d.svg", layer_idx, iRun++), segmented_regions_merged[layer_idx], input_expolygons[layer_idx]); - } -#endif // MMU_SEGMENTATION_DEBUG_REGIONS +#ifdef MM_SEGMENTATION_DEBUG_REGIONS + for (size_t layer_idx = 0; layer_idx < print_object.layers().size(); ++layer_idx) + export_regions_to_svg(debug_out_path("mm-regions-merged-%d-%d.svg", layer_idx, iRun), segmented_regions_merged[layer_idx], input_expolygons[layer_idx]); +#endif // MM_SEGMENTATION_DEBUG_REGIONS + +#ifdef MM_SEGMENTATION_DEBUG + ++iRun; +#endif // MM_SEGMENTATION_DEBUG return segmented_regions_merged; } diff --git a/src/libslic3r/PrintApply.cpp b/src/libslic3r/PrintApply.cpp index 5f100ab4bd..1ac2c72304 100644 --- a/src/libslic3r/PrintApply.cpp +++ b/src/libslic3r/PrintApply.cpp @@ -78,8 +78,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); + assert(mv_dst.mm_segmentation_facets.id() == mv_src.mm_segmentation_facets.id()); + mv_dst.mm_segmentation_facets.assign(mv_src.mm_segmentation_facets); //FIXME what to do with the materials? // mv_dst.m_material_id = mv_src.m_material_id; ++ i_src; @@ -1374,7 +1374,7 @@ Print::ApplyStatus Print::apply(const Model &model, DynamicPrintConfig new_full_ std::vector painting_extruders; if (const auto &volumes = print_object.model_object()->volumes; num_extruders > 1 && - std::find_if(volumes.begin(), volumes.end(), [](const ModelVolume *v) { return ! v->mmu_segmentation_facets.empty(); }) != volumes.end()) { + std::find_if(volumes.begin(), volumes.end(), [](const ModelVolume *v) { return ! v->mm_segmentation_facets.empty(); }) != volumes.end()) { //FIXME be more specific! Don't enumerate extruders that are not used for painting! painting_extruders.assign(num_extruders, 0); std::iota(painting_extruders.begin(), painting_extruders.end(), 1); diff --git a/src/libslic3r/PrintObjectSlice.cpp b/src/libslic3r/PrintObjectSlice.cpp index 3da6e3aa3d..d285cab41b 100644 --- a/src/libslic3r/PrintObjectSlice.cpp +++ b/src/libslic3r/PrintObjectSlice.cpp @@ -728,7 +728,7 @@ void PrintObject::slice_volumes() // Is any ModelVolume MMU painted? if (const auto& volumes = this->model_object()->volumes; m_print->config().nozzle_diameter.size() > 1 && - std::find_if(volumes.begin(), volumes.end(), [](const ModelVolume* v) { return !v->mmu_segmentation_facets.empty(); }) != volumes.end()) { + std::find_if(volumes.begin(), volumes.end(), [](const ModelVolume* v) { return !v->mm_segmentation_facets.empty(); }) != volumes.end()) { // If XY Size compensation is also enabled, notify the user that XY Size compensation // would not be used because the object is multi-material painted. diff --git a/src/slic3r/GUI/GLCanvas3D.cpp b/src/slic3r/GUI/GLCanvas3D.cpp index bba3c602fa..bcaa4a0cd2 100644 --- a/src/slic3r/GUI/GLCanvas3D.cpp +++ b/src/slic3r/GUI/GLCanvas3D.cpp @@ -4922,7 +4922,7 @@ void GLCanvas3D::_render_thumbnail_internal(ThumbnailData& thumbnail_data, const for (GLVolume *vol : visible_volumes) { const int obj_idx = vol->object_idx(); const int vol_idx = vol->volume_idx(); - const bool render_as_painted = is_enabled_painted_thumbnail && obj_idx >= 0 && vol_idx >= 0 && !model_objects[obj_idx]->volumes[vol_idx]->mmu_segmentation_facets.empty(); + const bool render_as_painted = is_enabled_painted_thumbnail && obj_idx >= 0 && vol_idx >= 0 && !model_objects[obj_idx]->volumes[vol_idx]->mm_segmentation_facets.empty(); GLShaderProgram* shader = wxGetApp().get_shader(render_as_painted ? "mm_gouraud" : "gouraud_light"); if (shader == nullptr) continue; @@ -4958,7 +4958,7 @@ void GLCanvas3D::_render_thumbnail_internal(ThumbnailData& thumbnail_data, const const ModelVolume& model_volume = *model_objects[obj_idx]->volumes[vol_idx]; const size_t extruder_idx = get_extruder_color_idx(model_volume, extruders_count); TriangleSelectorMmGui ts(model_volume.mesh(), extruders_colors, extruders_colors[extruder_idx]); - ts.deserialize(model_volume.mmu_segmentation_facets.get_data(), true); + ts.deserialize(model_volume.mm_segmentation_facets.get_data(), true); ts.request_update_render_data(); ts.render(nullptr, model_matrix); diff --git a/src/slic3r/GUI/GUI_ObjectList.cpp b/src/slic3r/GUI/GUI_ObjectList.cpp index db8e372e92..313787682d 100644 --- a/src/slic3r/GUI/GUI_ObjectList.cpp +++ b/src/slic3r/GUI/GUI_ObjectList.cpp @@ -1905,7 +1905,7 @@ void ObjectList::del_info_item(const int obj_idx, InfoItemType type) cnv->get_gizmos_manager().reset_all_states(); Plater::TakeSnapshot(plater, _L("Remove Multi Material painting")); for (ModelVolume* mv : (*m_objects)[obj_idx]->volumes) - mv->mmu_segmentation_facets.reset(); + mv->mm_segmentation_facets.reset(); break; case InfoItemType::Sinking: @@ -2897,7 +2897,7 @@ void ObjectList::update_info_items(size_t obj_idx, wxDataViewItemArray* selectio [type](const ModelVolume *mv) { return !(type == InfoItemType::CustomSupports ? mv->supported_facets.empty() : type == InfoItemType::CustomSeam ? mv->seam_facets.empty() : - mv->mmu_segmentation_facets.empty()); + mv->mm_segmentation_facets.empty()); }); break; diff --git a/src/slic3r/GUI/GUI_Preview.cpp b/src/slic3r/GUI/GUI_Preview.cpp index 4fa9140d0d..b2d62445a1 100644 --- a/src/slic3r/GUI/GUI_Preview.cpp +++ b/src/slic3r/GUI/GUI_Preview.cpp @@ -648,7 +648,7 @@ void Preview::update_layers_slider_mode() if ((volume->config.has("extruder") && volume->config.option("extruder")->getInt() != 0 && // extruder isn't default volume->config.option("extruder")->getInt() != extruder) || - !volume->mmu_segmentation_facets.empty()) + !volume->mm_segmentation_facets.empty()) return false; for (const auto& range : object->layer_config_ranges) diff --git a/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp b/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp index 7f4d4c28d6..b6c72c0b44 100644 --- a/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp +++ b/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp @@ -517,7 +517,7 @@ void GLGizmoMmuSegmentation::update_model_object() const if (! mv->is_model_part()) continue; ++idx; - updated |= mv->mmu_segmentation_facets.set(*m_triangle_selectors[idx].get()); + updated |= mv->mm_segmentation_facets.set(*m_triangle_selectors[idx].get()); } if (updated) { @@ -547,7 +547,7 @@ void GLGizmoMmuSegmentation::init_model_triangle_selectors() size_t extruder_idx = get_extruder_color_idx(*mv, extruders_count); m_triangle_selectors.emplace_back(std::make_unique(*mesh, m_modified_extruders_colors, m_original_extruders_colors[extruder_idx])); // Reset of TriangleSelector is done inside TriangleSelectorMmGUI's constructor, so we don't need it to perform it again in deserialize(). - m_triangle_selectors.back()->deserialize(mv->mmu_segmentation_facets.get_data(), false); + m_triangle_selectors.back()->deserialize(mv->mm_segmentation_facets.get_data(), false); m_triangle_selectors.back()->request_update_render_data(); } m_original_volumes_extruder_idxs = get_extruder_id_for_volumes(*mo); diff --git a/src/slic3r/GUI/Plater.cpp b/src/slic3r/GUI/Plater.cpp index dcb5a52491..2d00674c08 100644 --- a/src/slic3r/GUI/Plater.cpp +++ b/src/slic3r/GUI/Plater.cpp @@ -3702,7 +3702,7 @@ bool Plater::priv::replace_volume_with_stl(int object_idx, int volume_idx, const // We need to make sure that the painted data point to existing triangles. 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); + new_volume->mm_segmentation_facets.assign(old_volume->mm_segmentation_facets); } std::swap(old_model_object->volumes[volume_idx], old_model_object->volumes.back()); old_model_object->delete_volume(old_model_object->volumes.size() - 1); @@ -7918,10 +7918,10 @@ void Plater::clear_before_change_mesh(int obj_idx, const std::string ¬ificati // 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() || ! mv->mmu_segmentation_facets.empty(); + paint_removed |= ! mv->supported_facets.empty() || ! mv->seam_facets.empty() || ! mv->mm_segmentation_facets.empty(); mv->supported_facets.reset(); mv->seam_facets.reset(); - mv->mmu_segmentation_facets.reset(); + mv->mm_segmentation_facets.reset(); } if (paint_removed) { // snapshot_time is captured by copy so the lambda knows where to undo/redo to.