439 lines
14 KiB
C++
439 lines
14 KiB
C++
#include "Exception.hpp"
|
|
#include "MeshBoolean.hpp"
|
|
#include "libslic3r/TriangleMesh.hpp"
|
|
#include "libslic3r/TryCatchSignal.hpp"
|
|
#undef PI
|
|
|
|
// Include igl first. It defines "L" macro which then clashes with our localization
|
|
#include <igl/copyleft/cgal/mesh_boolean.h>
|
|
#undef L
|
|
|
|
// CGAL headers
|
|
#include <CGAL/Polygon_mesh_processing/corefinement.h>
|
|
#include <CGAL/Exact_integer.h>
|
|
#include <CGAL/Surface_mesh.h>
|
|
#include <CGAL/Polygon_mesh_processing/orient_polygon_soup.h>
|
|
#include <CGAL/Polygon_mesh_processing/repair.h>
|
|
#include <CGAL/Polygon_mesh_processing/remesh.h>
|
|
#include <CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h>
|
|
#include <CGAL/Polygon_mesh_processing/orientation.h>
|
|
// BBS: for segment
|
|
#include <CGAL/mesh_segmentation.h>
|
|
#include <CGAL/property_map.h>
|
|
#include <CGAL/boost/graph/copy_face_graph.h>
|
|
#include <CGAL/boost/graph/Face_filtered_graph.h>
|
|
|
|
namespace Slic3r {
|
|
namespace MeshBoolean {
|
|
|
|
using MapMatrixXfUnaligned = Eigen::Map<const Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor | Eigen::DontAlign>>;
|
|
using MapMatrixXiUnaligned = Eigen::Map<const Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor | Eigen::DontAlign>>;
|
|
|
|
TriangleMesh eigen_to_triangle_mesh(const EigenMesh &emesh)
|
|
{
|
|
auto &VC = emesh.first; auto &FC = emesh.second;
|
|
|
|
indexed_triangle_set its;
|
|
its.vertices.reserve(size_t(VC.rows()));
|
|
its.indices.reserve(size_t(FC.rows()));
|
|
|
|
for (Eigen::Index i = 0; i < VC.rows(); ++i)
|
|
its.vertices.emplace_back(VC.row(i).cast<float>());
|
|
|
|
for (Eigen::Index i = 0; i < FC.rows(); ++i)
|
|
its.indices.emplace_back(FC.row(i));
|
|
|
|
return TriangleMesh { std::move(its) };
|
|
}
|
|
|
|
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<double>();
|
|
|
|
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<EpicKernel::Point_3>;
|
|
using _EpecMesh = CGAL::Surface_mesh<EpecKernel::Point_3>;
|
|
|
|
struct CGALMesh {
|
|
_EpicMesh m;
|
|
CGALMesh() = default;
|
|
CGALMesh(const _EpicMesh& _m) :m(_m) {}
|
|
};
|
|
|
|
// /////////////////////////////////////////////////////////////////////////////
|
|
// Converions from and to CGAL mesh
|
|
// /////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<class _Mesh> void triangle_mesh_to_cgal(const TriangleMesh& M, _Mesh& out)
|
|
{
|
|
using Index3 = std::array<size_t, 3>;
|
|
|
|
if (M.empty()) return;
|
|
|
|
std::vector<typename _Mesh::Point> points;
|
|
std::vector<Index3> 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<size_t>();
|
|
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
|
|
throw Slic3r::RuntimeError("Mesh not watertight");
|
|
}
|
|
|
|
template<class _Mesh>
|
|
void triangle_mesh_to_cgal(const std::vector<stl_vertex> & V,
|
|
const std::vector<stl_triangle_vertex_indices> &F,
|
|
_Mesh &out)
|
|
{
|
|
if (F.empty()) return;
|
|
|
|
size_t vertices_count = V.size();
|
|
size_t edges_count = (F.size()* 3) / 2;
|
|
size_t faces_count = F.size();
|
|
out.reserve(vertices_count, edges_count, faces_count);
|
|
|
|
for (auto &v : V)
|
|
out.add_vertex(typename _Mesh::Point{v.x(), v.y(), v.z()});
|
|
|
|
using VI = typename _Mesh::Vertex_index;
|
|
for (auto &f : F)
|
|
out.add_face(VI(f(0)), VI(f(1)), VI(f(2)));
|
|
}
|
|
|
|
inline Vec3f to_vec3f(const _EpicMesh::Point& v)
|
|
{
|
|
return { float(v.x()), float(v.y()), float(v.z()) };
|
|
}
|
|
|
|
inline Vec3f to_vec3f(const _EpecMesh::Point& v)
|
|
{
|
|
CGAL::Cartesian_converter<EpecKernel, EpicKernel> cvt;
|
|
auto iv = cvt(v);
|
|
return { float(iv.x()), float(iv.y()), float(iv.z()) };
|
|
}
|
|
|
|
template<class _Mesh> TriangleMesh cgal_to_triangle_mesh(const _Mesh &cgalmesh)
|
|
{
|
|
indexed_triangle_set its;
|
|
its.vertices.reserve(cgalmesh.num_vertices());
|
|
its.indices.reserve(cgalmesh.num_faces());
|
|
|
|
const auto &faces = cgalmesh.faces();
|
|
const auto &vertices = cgalmesh.vertices();
|
|
int vsize = int(vertices.size());
|
|
|
|
for (auto &vi : vertices) {
|
|
auto &v = cgalmesh.point(vi); // Don't ask...
|
|
its.vertices.emplace_back(to_vec3f(v));
|
|
}
|
|
|
|
for (auto &face : faces) {
|
|
auto vtc = cgalmesh.vertices_around_face(cgalmesh.halfedge(face));
|
|
|
|
int i = 0;
|
|
Vec3i facet;
|
|
for (auto v : vtc) {
|
|
int iv = v;
|
|
if (i > 2 || iv < 0 || iv >= vsize) { i = 0; break; }
|
|
facet(i++) = iv;
|
|
}
|
|
|
|
if (i == 3)
|
|
its.indices.emplace_back(facet);
|
|
}
|
|
|
|
return TriangleMesh(std::move(its));
|
|
}
|
|
|
|
std::unique_ptr<CGALMesh, CGALMeshDeleter>
|
|
triangle_mesh_to_cgal(const std::vector<stl_vertex> &V,
|
|
const std::vector<stl_triangle_vertex_indices> &F)
|
|
{
|
|
std::unique_ptr<CGALMesh, CGALMeshDeleter> out(new CGALMesh{});
|
|
triangle_mesh_to_cgal(V, F, 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<class Op> void _cgal_do(Op &&op, CGALMesh &A, CGALMesh &B)
|
|
{
|
|
bool success = false;
|
|
bool hw_fail = false;
|
|
try {
|
|
CGALMesh result;
|
|
try_catch_signal({SIGSEGV, SIGFPE}, [&success, &A, &B, &result, &op] {
|
|
success = op(A, B, result);
|
|
}, [&] { hw_fail = true; });
|
|
A = std::move(result); // In-place operation does not work
|
|
} catch (...) {
|
|
success = false;
|
|
}
|
|
|
|
if (hw_fail)
|
|
throw Slic3r::HardCrash("CGAL mesh boolean operation crashed.");
|
|
|
|
if (! success)
|
|
throw Slic3r::RuntimeError("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); }
|
|
// BBS
|
|
void segment(CGALMesh& src, std::vector<CGALMesh>& dst, double smoothing_alpha = 0.5, int segment_number=5)
|
|
{
|
|
typedef boost::graph_traits<_EpicMesh>::face_descriptor face_descriptor;
|
|
typedef _EpicMesh::Property_map<face_descriptor, double> Facet_double_map;
|
|
typedef CGAL::Face_filtered_graph<_EpicMesh> Filtered_graph;
|
|
|
|
_EpicMesh mesh = src.m;
|
|
Facet_double_map sdf_property_map;
|
|
|
|
sdf_property_map = mesh.add_property_map<face_descriptor, double>("f:sdf").first;
|
|
|
|
CGAL::sdf_values(mesh, sdf_property_map);
|
|
|
|
// create a property-map for segment-ids
|
|
typedef _EpicMesh::Property_map<face_descriptor, std::size_t> Facet_int_map;
|
|
Facet_int_map segment_property_map = mesh.add_property_map<face_descriptor, std::size_t>("f:sid").first;;
|
|
// segment the mesh using default parameters for number of levels, and smoothing lambda
|
|
// Any other scalar values can be used instead of using SDF values computed using the CGAL function
|
|
std::size_t number_of_segments = CGAL::segmentation_from_sdf_values(mesh, sdf_property_map, segment_property_map, segment_number, smoothing_alpha);
|
|
//print area of each segment and then put it in a Mesh and print it in an OFF file
|
|
Filtered_graph segment_mesh(mesh);
|
|
_EpicMesh mesh_merged;
|
|
for (std::size_t id = 0; id < number_of_segments; ++id)
|
|
{
|
|
segment_mesh.set_selected_faces(id, segment_property_map);
|
|
//std::cout << "Segment " << id << "'s area is : " << CGAL::Polygon_mesh_processing::area(segment_mesh) << std::endl;
|
|
_EpicMesh out;
|
|
CGAL::copy_face_graph(segment_mesh, out);
|
|
|
|
//std::ostringstream oss;
|
|
//oss << "Segment_" << id << ".off";
|
|
//std::ofstream os(oss.str().data());
|
|
//os << out;
|
|
|
|
// fill holes
|
|
typedef boost::graph_traits<_EpicMesh>::halfedge_descriptor halfedge_descriptor;
|
|
typedef boost::graph_traits<_EpicMesh>::vertex_descriptor vertex_descriptor;
|
|
std::vector<halfedge_descriptor> border_cycles;
|
|
CGAL::Polygon_mesh_processing::extract_boundary_cycles(out, std::back_inserter(border_cycles));
|
|
for (halfedge_descriptor h : border_cycles)
|
|
{
|
|
std::vector<face_descriptor> patch_facets;
|
|
#if 0
|
|
std::vector<vertex_descriptor> patch_vertices;
|
|
CGAL::Polygon_mesh_processing::triangulate_and_refine_hole(out, h, std::back_inserter(patch_facets),
|
|
std::back_inserter(patch_vertices));
|
|
std::cout << "* Number of facets in constructed patch: " << patch_facets.size() << std::endl;
|
|
std::cout << " Number of vertices in constructed patch: " << patch_vertices.size() << std::endl;
|
|
#else
|
|
CGAL::Polygon_mesh_processing::triangulate_hole(out, h, std::back_inserter(patch_facets));
|
|
#endif
|
|
}
|
|
|
|
//if (id > 2) {
|
|
// mesh_merged.join(out);
|
|
//}
|
|
//else
|
|
{
|
|
dst.emplace_back(std::move(CGALMesh(out)));
|
|
}
|
|
}
|
|
//if (mesh_merged.is_empty() == false) {
|
|
// CGAL::Polygon_mesh_processing::stitch_borders(mesh_merged);
|
|
// dst.emplace_back(std::move(CGALMesh(mesh_merged)));
|
|
//}
|
|
}
|
|
|
|
std::vector<TriangleMesh> segment(const TriangleMesh& src, double smoothing_alpha, int segment_number)
|
|
{
|
|
CGALMesh in_cgal_mesh;
|
|
MeshBoolean::cgal::triangle_mesh_to_cgal(src, in_cgal_mesh.m);
|
|
std::vector<CGALMesh> out_cgal_meshes;
|
|
segment(in_cgal_mesh, out_cgal_meshes, smoothing_alpha, segment_number);
|
|
|
|
std::vector<TriangleMesh> out_meshes;
|
|
for (auto& outf_cgal_mesh: out_cgal_meshes)
|
|
{
|
|
out_meshes.emplace_back(std::move(cgal_to_triangle_mesh(outf_cgal_mesh.m)));
|
|
}
|
|
|
|
return out_meshes;
|
|
}
|
|
|
|
void merge(std::vector<_EpicMesh>& srcs, _EpicMesh& dst)
|
|
{
|
|
_EpicMesh mesh_merged;
|
|
for (size_t i = 0; i < srcs.size(); i++)
|
|
{
|
|
mesh_merged.join(srcs[i]);
|
|
}
|
|
if (mesh_merged.is_empty() == false) {
|
|
CGAL::Polygon_mesh_processing::stitch_borders(mesh_merged);
|
|
dst = std::move(mesh_merged);
|
|
}
|
|
}
|
|
|
|
TriangleMesh merge(std::vector<TriangleMesh> meshes)
|
|
{
|
|
std::vector<_EpicMesh> srcs(meshes.size());
|
|
for (size_t i = 0; i < meshes.size(); i++)
|
|
{
|
|
MeshBoolean::cgal::triangle_mesh_to_cgal(meshes[i], srcs[i]);
|
|
}
|
|
_EpicMesh dst;
|
|
merge(srcs, dst);
|
|
return cgal_to_triangle_mesh(dst);
|
|
}
|
|
|
|
// /////////////////////////////////////////////////////////////////////////////
|
|
// Now the public functions for TriangleMesh input:
|
|
// /////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<class Op> void _mesh_boolean_do(Op &&op, TriangleMesh &A, const TriangleMesh &B)
|
|
{
|
|
CGALMesh meshA;
|
|
CGALMesh meshB;
|
|
triangle_mesh_to_cgal(A.its.vertices, A.its.indices, meshA.m);
|
|
triangle_mesh_to_cgal(B.its.vertices, B.its.indices, 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.its.vertices, mesh.its.indices, cgalm.m);
|
|
return CGALProc::does_self_intersect(cgalm.m);
|
|
}
|
|
|
|
void CGALMeshDeleter::operator()(CGALMesh *ptr) { delete ptr; }
|
|
|
|
bool does_bound_a_volume(const CGALMesh &mesh)
|
|
{
|
|
return CGALProc::does_bound_a_volume(mesh.m);
|
|
}
|
|
|
|
bool empty(const CGALMesh &mesh)
|
|
{
|
|
return mesh.m.is_empty();
|
|
}
|
|
|
|
} // namespace cgal
|
|
|
|
} // namespace MeshBoolean
|
|
} // namespace Slic3r
|