#include "MeshBoolean.hpp" #include "libslic3r/TriangleMesh.hpp" #undef PI // Include igl first. It defines "L" macro which then clashes with our localization #include #undef L // CGAL headers #include #include #include #include #include #include #include #include #include #include namespace Slic3r { namespace MeshBoolean { using MapMatrixXfUnaligned = Eigen::Map>; using MapMatrixXiUnaligned = Eigen::Map>; TriangleMesh eigen_to_triangle_mesh(const EigenMesh &emesh) { auto &VC = emesh.first; auto &FC = emesh.second; Pointf3s points(size_t(VC.rows())); std::vector facets(size_t(FC.rows())); for (Eigen::Index i = 0; i < VC.rows(); ++i) points[size_t(i)] = VC.row(i); for (Eigen::Index i = 0; i < FC.rows(); ++i) facets[size_t(i)] = FC.row(i); TriangleMesh out{points, facets}; out.require_shared_vertices(); return out; } EigenMesh triangle_mesh_to_eigen(const TriangleMesh &mesh) { EigenMesh emesh; emesh.first = MapMatrixXfUnaligned(mesh.its.vertices.front().data(), Eigen::Index(mesh.its.vertices.size()), 3).cast(); emesh.second = MapMatrixXiUnaligned(mesh.its.indices.front().data(), Eigen::Index(mesh.its.indices.size()), 3); return emesh; } void minus(EigenMesh &A, const EigenMesh &B) { auto &[VA, FA] = A; auto &[VB, FB] = B; Eigen::MatrixXd VC; Eigen::MatrixXi FC; igl::MeshBooleanType boolean_type(igl::MESH_BOOLEAN_TYPE_MINUS); igl::copyleft::cgal::mesh_boolean(VA, FA, VB, FB, boolean_type, VC, FC); VA = std::move(VC); FA = std::move(FC); } void minus(TriangleMesh& A, const TriangleMesh& B) { EigenMesh eA = triangle_mesh_to_eigen(A); minus(eA, triangle_mesh_to_eigen(B)); A = eigen_to_triangle_mesh(eA); } void self_union(EigenMesh &A) { EigenMesh result; auto &[V, F] = A; auto &[VC, FC] = result; igl::MeshBooleanType boolean_type(igl::MESH_BOOLEAN_TYPE_UNION); igl::copyleft::cgal::mesh_boolean(V, F, Eigen::MatrixXd(), Eigen::MatrixXi(), boolean_type, VC, FC); A = std::move(result); } void self_union(TriangleMesh& mesh) { auto eM = triangle_mesh_to_eigen(mesh); self_union(eM); mesh = eigen_to_triangle_mesh(eM); } namespace cgal { namespace CGALProc = CGAL::Polygon_mesh_processing; namespace CGALParams = CGAL::Polygon_mesh_processing::parameters; using EpecKernel = CGAL::Exact_predicates_exact_constructions_kernel; using EpicKernel = CGAL::Exact_predicates_inexact_constructions_kernel; using _EpicMesh = CGAL::Surface_mesh; using _EpecMesh = CGAL::Surface_mesh; struct CGALMesh { _EpicMesh m; }; // ///////////////////////////////////////////////////////////////////////////// // Converions from and to CGAL mesh // ///////////////////////////////////////////////////////////////////////////// template void triangle_mesh_to_cgal(const TriangleMesh &M, _Mesh &out) { using Index3 = std::array; if (M.empty()) return; std::vector points; std::vector indices; points.reserve(M.its.vertices.size()); indices.reserve(M.its.indices.size()); for (auto &v : M.its.vertices) points.emplace_back(v.x(), v.y(), v.z()); for (auto &_f : M.its.indices) { auto f = _f.cast(); indices.emplace_back(Index3{f(0), f(1), f(2)}); } CGALProc::orient_polygon_soup(points, indices); CGALProc::polygon_soup_to_polygon_mesh(points, indices, out); // Number the faces because 'orient_to_bound_a_volume' needs a face <--> index map unsigned index = 0; for (auto face : out.faces()) face = CGAL::SM_Face_index(index++); if(CGAL::is_closed(out)) CGALProc::orient_to_bound_a_volume(out); else std::runtime_error("Mesh not watertight"); } inline Vec3d to_vec3d(const _EpicMesh::Point &v) { return {v.x(), v.y(), v.z()}; } inline Vec3d to_vec3d(const _EpecMesh::Point &v) { CGAL::Cartesian_converter cvt; auto iv = cvt(v); return {iv.x(), iv.y(), iv.z()}; } template TriangleMesh cgal_to_triangle_mesh(const _Mesh &cgalmesh) { Pointf3s points; std::vector facets; points.reserve(cgalmesh.num_vertices()); facets.reserve(cgalmesh.num_faces()); for (auto &vi : cgalmesh.vertices()) { auto &v = cgalmesh.point(vi); // Don't ask... points.emplace_back(to_vec3d(v)); } for (auto &face : cgalmesh.faces()) { auto vtc = cgalmesh.vertices_around_face(cgalmesh.halfedge(face)); int i = 0; Vec3crd trface; for (auto v : vtc) trface(i++) = static_cast(v); facets.emplace_back(trface); } TriangleMesh out{points, facets}; out.require_shared_vertices(); return out; } std::unique_ptr triangle_mesh_to_cgal(const TriangleMesh &M) { std::unique_ptr out(new CGALMesh{}); triangle_mesh_to_cgal(M, out->m); return out; } TriangleMesh cgal_to_triangle_mesh(const CGALMesh &cgalmesh) { return cgal_to_triangle_mesh(cgalmesh.m); } // ///////////////////////////////////////////////////////////////////////////// // Boolean operations for CGAL meshes // ///////////////////////////////////////////////////////////////////////////// static bool _cgal_diff(CGALMesh &A, CGALMesh &B, CGALMesh &R) { const auto &p = CGALParams::throw_on_self_intersection(true); return CGALProc::corefine_and_compute_difference(A.m, B.m, R.m, p, p); } static bool _cgal_union(CGALMesh &A, CGALMesh &B, CGALMesh &R) { const auto &p = CGALParams::throw_on_self_intersection(true); return CGALProc::corefine_and_compute_union(A.m, B.m, R.m, p, p); } static bool _cgal_intersection(CGALMesh &A, CGALMesh &B, CGALMesh &R) { const auto &p = CGALParams::throw_on_self_intersection(true); return CGALProc::corefine_and_compute_intersection(A.m, B.m, R.m, p, p); } template void _cgal_do(Op &&op, CGALMesh &A, CGALMesh &B) { bool success = false; try { CGALMesh result; success = op(A, B, result); A = std::move(result); // In-place operation does not work } catch (...) { success = false; } if (! success) throw std::runtime_error("CGAL mesh boolean operation failed."); } void minus(CGALMesh &A, CGALMesh &B) { _cgal_do(_cgal_diff, A, B); } void plus(CGALMesh &A, CGALMesh &B) { _cgal_do(_cgal_union, A, B); } void intersect(CGALMesh &A, CGALMesh &B) { _cgal_do(_cgal_intersection, A, B); } bool does_self_intersect(const CGALMesh &mesh) { return CGALProc::does_self_intersect(mesh.m); } // ///////////////////////////////////////////////////////////////////////////// // Now the public functions for TriangleMesh input: // ///////////////////////////////////////////////////////////////////////////// template void _mesh_boolean_do(Op &&op, TriangleMesh &A, const TriangleMesh &B) { CGALMesh meshA; CGALMesh meshB; triangle_mesh_to_cgal(A, meshA.m); triangle_mesh_to_cgal(B, meshB.m); _cgal_do(op, meshA, meshB); A = cgal_to_triangle_mesh(meshA.m); } void minus(TriangleMesh &A, const TriangleMesh &B) { _mesh_boolean_do(_cgal_diff, A, B); } void plus(TriangleMesh &A, const TriangleMesh &B) { _mesh_boolean_do(_cgal_union, A, B); } void intersect(TriangleMesh &A, const TriangleMesh &B) { _mesh_boolean_do(_cgal_intersection, A, B); } bool does_self_intersect(const TriangleMesh &mesh) { CGALMesh cgalm; triangle_mesh_to_cgal(mesh, cgalm.m); return CGALProc::does_self_intersect(cgalm.m); } void CGALMeshDeleter::operator()(CGALMesh *ptr) { delete ptr; } } // namespace cgal } // namespace MeshBoolean } // namespace Slic3r