Boundary::Ptr Boundary::extract_surface_boundary_raw(
MatrixFr& vertices, MatrixIr& faces) {
VectorF flattened_vertices = Eigen::Map<VectorF>(vertices.data(),
vertices.rows() * vertices.cols());
VectorI flattened_faces = Eigen::Map<VectorI>(faces.data(),
faces.rows() * faces.cols());
VectorI voxels = VectorI::Zero(0);
MeshFactory factory;
Mesh::Ptr mesh = factory.load_data(flattened_vertices, flattened_faces,
voxels, vertices.cols(), faces.cols(), 0).create();
return extract_surface_boundary(*mesh);
}
SelfIntersection::SelfIntersection(
const MatrixFr& vertices, const MatrixIr& faces)
: m_faces(faces) {
const size_t num_vertices = vertices.rows();
const size_t dim = vertices.cols();
const size_t num_faces = faces.rows();
const size_t vertex_per_face = faces.cols();
if (dim != 3) {
throw NotImplementedError(
"Self intersection check only support 3D");
}
if (vertex_per_face != 3) {
throw NotImplementedError(
"Self intersection check only works with triangles");
}
m_points.resize(num_vertices);
for (size_t i=0; i<num_vertices; i++) {
m_points[i] = Point_3(
vertices(i,0),
vertices(i,1),
vertices(i,2));
}
}
CarveMeshPtr create_mesh(const MatrixFr& vertices, const MatrixIr& faces) {
const size_t num_vertices = vertices.rows();
const size_t num_faces = faces.rows();
if (vertices.cols() != 3) {
throw NotImplementedError("Only 3D mesh is supported.");
}
if (faces.cols() != 3) {
throw NotImplementedError("Only triangle mesh is supported.");
}
std::vector<CarveVector> points;
for (size_t i=0; i<num_vertices; i++) {
const auto& v = vertices.row(i);
CarveVector p;
p.v[0] = v[0];
p.v[1] = v[1];
p.v[2] = v[2];
points.push_back(p);
}
std::vector<int> raw_faces;
raw_faces.reserve(num_faces * 4);
for (size_t i=0; i<num_faces; i++) {
raw_faces.push_back(3);
raw_faces.push_back(faces(i,0));
raw_faces.push_back(faces(i,1));
raw_faces.push_back(faces(i,2));
}
return CarveMeshPtr(new CarveMesh(points, num_faces, raw_faces));
}
GeoMeshPtr GeogramMeshUtils::raw_to_geomesh(
const MatrixFr& vertices, const MatrixIr& faces) {
const size_t dim = vertices.cols();
const size_t vertex_per_face = faces.cols();
const size_t num_vertices = vertices.rows();
const size_t num_faces = faces.rows();
if (vertex_per_face != 3) {
throw NotImplementedError("Converting non-triangle mesh to "
"Geogram mesh is not yet implemented");
}
auto geo_mesh = std::make_shared<GeoMesh>(dim, false);
geo_mesh->vertices.clear();
geo_mesh->vertices.create_vertices(num_vertices);
geo_mesh->facets.clear();
geo_mesh->facets.create_triangles(num_faces);
for (size_t i=0; i<num_vertices; i++) {
auto& p = geo_mesh->vertices.point(i);
for (size_t j=0; j<dim; j++) {
p[j] = vertices(i,j);
}
}
for (size_t i=0; i<num_faces; i++) {
geo_mesh->facets.set_vertex(i, 0, faces(i,0));
geo_mesh->facets.set_vertex(i, 1, faces(i,1));
geo_mesh->facets.set_vertex(i, 2, faces(i,2));
}
return geo_mesh;
}
void save_mesh(const std::string& filename,
const MatrixFr& vertices, const MatrixIr& faces) {
auto flattened_vertices = MatrixUtils::flatten<VectorF>(vertices);
auto flattened_faces = MatrixUtils::flatten<VectorI>(faces);
VectorI voxels = VectorI::Zero(0);
MeshWriter::Ptr writer = MeshWriter::create(filename);
writer->write(flattened_vertices, flattened_faces, voxels,
vertices.cols(), faces.cols(), 0);
}
void InflatorEngine::save_mesh(const std::string& filename,
const MatrixFr& vertices, const MatrixIr& faces, VectorF debug) {
VectorF flattened_vertices(vertices.rows() * vertices.cols());
std::copy(vertices.data(), vertices.data() + vertices.rows() *
vertices.cols(), flattened_vertices.data());
VectorI flattened_faces(faces.rows() * faces.cols());
std::copy(faces.data(), faces.data() + faces.rows() * faces.cols(),
flattened_faces.data());
VectorI voxels = VectorI::Zero(0);
Mesh::Ptr mesh = MeshFactory().load_data(
flattened_vertices, flattened_faces, voxels,
vertices.cols(), faces.cols(), 0).create_shared();
mesh->add_attribute("debug");
mesh->set_attribute("debug", debug);
MeshWriter::Ptr writer = MeshWriter::create(filename);
writer->with_attribute("debug");
writer->write_mesh(*mesh);
}
BoundaryRemesher::BoundaryRemesher(const MatrixFr& vertices, const MatrixIr& faces)
: m_vertices(vertices), m_faces(faces) {
if (vertices.cols() != 3) {
throw NotImplementedError(
"Only 3D meshes are supported for remeshing");
}
if (faces.cols() != 3) {
throw NotImplementedError(
"Only triangle meshes are supported for remeshing");
}
assert_faces_are_valid(m_faces);
}
Boundary::Ptr Boundary::extract_volume_boundary_raw(
MatrixFr& vertices, MatrixIr& voxels) {
VectorF flattened_vertices = Eigen::Map<VectorF>(vertices.data(),
vertices.rows() * vertices.cols());
VectorI faces = VectorI::Zero(0);
VectorI flattened_voxels = Eigen::Map<VectorI>(voxels.data(),
voxels.rows() * voxels.cols());
size_t vertex_per_voxel = voxels.cols();
size_t vertex_per_face=0;
if (vertex_per_voxel == 4) vertex_per_face = 3;
else if (vertex_per_voxel == 8) vertex_per_face = 4;
else {
throw RuntimeError("Unknown voxel type.");
}
MeshFactory factory;
Mesh::Ptr mesh = factory.load_data(flattened_vertices, faces,
flattened_voxels, vertices.cols(), vertex_per_face,
vertex_per_voxel).create();
return extract_volume_boundary(*mesh);
}
void reorientate_triangles(const MatrixFr& vertices, MatrixIr& faces,
const VectorF& n) {
assert(vertices.cols() == 3);
assert(faces.cols() == 3);
const VectorI& f = faces.row(0);
const Vector3F& v0 = vertices.row(f[0]);
const Vector3F& v1 = vertices.row(f[1]);
const Vector3F& v2 = vertices.row(f[2]);
Float projected_area = (v1-v0).cross(v2-v0).dot(n);
if (projected_area < 0) {
faces.col(2).swap(faces.col(1));
}
}
EdgeMap compute_edge_map(const MatrixIr& faces) {
assert(faces.cols() == 3);
EdgeMap result;
const size_t num_faces = faces.rows();
for (size_t i=0; i<num_faces; i++) {
const Vector3I& f = faces.row(i);
Triplet e0(f[1], f[2]);
Triplet e1(f[2], f[0]);
Triplet e2(f[0], f[1]);
result.insert(e0, i);
result.insert(e1, i);
result.insert(e2, i);
}
return result;
}