update libslic3r

src/libslic3r/TriangleSelector.cpp

@@ -166,6 +166,24 @@ void TriangleSelector::Triangle::set_division(int sides_to_split, int special_si
     this->special_side_idx = char(special_side_idx);
 }
 
+void TriangleSelector::Triangle::select_by_seed_fill()
+{
+    assert(!is_split());
+    m_selected_by_seed_fill = true;
+}
+
+void TriangleSelector::Triangle::unselect_by_seed_fill()
+{
+    assert(!is_split());
+    m_selected_by_seed_fill = false;
+}
+
+bool TriangleSelector::Triangle::is_selected_by_seed_fill() const
+{
+    assert(!is_split());
+    return m_selected_by_seed_fill;
+}
+
 inline bool is_point_inside_triangle(const Vec3f &pt, const Vec3f &p1, const Vec3f &p2, const Vec3f &p3)
 {
     // Real-time collision detection, Ericson, Chapter 3.4
@@ -476,6 +494,20 @@ void TriangleSelector::append_touching_edges(int itriangle, int vertexi, int ver
         process_subtriangle(touching.second, Partition::Second);
 }
 
+void TriangleSelector::append_touching_its(int itriangle, indexed_triangle_set &its) const
+{
+    if (itriangle == -1)
+        return;
+    auto& idxs= m_triangles[itriangle].verts_idxs;
+    its.indices.emplace_back(stl_triangle_vertex_indices(idxs[0], idxs[1], idxs[2]));
+    if (its.vertices.empty()) {
+        its.vertices.reserve(m_vertices.size());
+        for (int i = 0; i < m_vertices.size(); i++) {
+            its.vertices.emplace_back(m_vertices[i].v);
+        }
+    }
+}
+
 // QDS: add seed_fill_angle parameter
 void TriangleSelector::bucket_fill_select_triangles(const Vec3f& hit, int facet_start, const ClippingPlane &clp, float seed_fill_angle, bool propagate, bool force_reselection)
 {
@@ -1600,7 +1632,61 @@ std::vector<Vec2i> TriangleSelector::get_seed_fill_contour() const {
     return edges_out;
 }
 
-void TriangleSelector::get_seed_fill_contour_recursive(const int facet_idx, const Vec3i &neighbors, const Vec3i &neighbors_propagated, std::vector<Vec2i> &edges_out) const {
+indexed_triangle_set TriangleSelector::get_seed_fill_mesh(int &state) const
+{
+    indexed_triangle_set its;
+    std::set<int>        face_idx_set;
+    for (int facet_idx = 0; facet_idx < this->m_orig_size_indices; ++facet_idx) {
+        const Vec3i neighbors = m_neighbors[facet_idx];
+        this->get_seed_fill_its_recursive(facet_idx, neighbors, neighbors, face_idx_set, its, state);
+    }
+    return its;
+}
+
+void TriangleSelector::get_seed_fill_its_recursive(
+    int facet_idx, const Vec3i &neighbors, const Vec3i &neighbors_propagated, std::set<int> &idx_set, indexed_triangle_set &its, int &state) const
+{
+    assert(facet_idx != -1 && facet_idx < int(m_triangles.size()));
+    assert(this->verify_triangle_neighbors(m_triangles[facet_idx], neighbors));
+    const Triangle *tr = &m_triangles[facet_idx];
+    if (!tr->valid())
+        return;
+
+    if (tr->is_split()) {
+        int num_of_children = tr->number_of_split_sides() + 1;
+        if (num_of_children != 1) {
+            for (int i = 0; i < num_of_children; ++i) {
+                assert(i < int(tr->children.size()));
+                assert(tr->children[i] < int(m_triangles.size()));
+                // Recursion, deep first search over the children of this triangle.
+                // All children of this triangle were created by splitting a single source triangle of the original mesh.
+                const Vec3i child_neighbors = this->child_neighbors(*tr, neighbors, i);
+                this->get_seed_fill_its_recursive(tr->children[i], child_neighbors, this->child_neighbors_propagated(*tr, neighbors_propagated, i, child_neighbors), idx_set, its,
+                                                  state);
+            }
+        }
+    } else if (tr->is_selected_by_seed_fill()) {
+        auto select_state =  m_triangles[facet_idx].get_state();
+        if (state < 0) {
+            state = (int) select_state;
+        }
+        if (idx_set.find(facet_idx) == idx_set.end()) {
+            idx_set.insert(facet_idx);
+            append_touching_its(facet_idx, its);
+            for (int i = 0; i < 3; i++) {
+                if (select_state == m_triangles[neighbors(i)].get_state()) {
+                    if (idx_set.find(neighbors(i)) == idx_set.end()) {
+                        idx_set.insert(neighbors(i));
+                        append_touching_its(neighbors(i), its);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void TriangleSelector::get_seed_fill_contour_recursive(const int facet_idx, const Vec3i &neighbors, const Vec3i &neighbors_propagated, std::vector<Vec2i> &edges_out) const
+{
     assert(facet_idx != -1 && facet_idx < int(m_triangles.size()));
     assert(this->verify_triangle_neighbors(m_triangles[facet_idx], neighbors));
     const Triangle *tr = &m_triangles[facet_idx];