Tester()
: c3t3_()
, c1_(0)
, c2_(1)
, f1_(0)
, f2_(4)
{
Tr& tr = c3t3_.triangulation();
Point_creator creator;
Point p1 = creator(0,0,0);
Point p2 = creator(1,0,0);
Point p3 = creator(0,1,0);
Point p4 = creator(0,0,100);
Point p5 = creator(0,0,-1);
p1_ = creator(0,.5,50);
p2_ = creator(1,1,-1);
tr.insert(p1);
tr.insert(p2);
tr.insert(p3);
tr.insert(p4);
tr.insert(p5);
}
Facet facet_handle(int i=0) const
{
typedef typename Tr::Finite_facets_iterator Iterator;
Iterator it = c3t3_.triangulation().finite_facets_begin();
int j = 0;
while ( j<i && it != c3t3_.triangulation().finite_facets_end() )
{
++it;
++j;
}
if ( it == c3t3_.triangulation().finite_facets_end() )
--it;
return *it;
}
void extract_mesh(const C3t3& c3t3,
MatrixFr& vertices, MatrixIr& faces, MatrixIr& voxels) {
const Tr& tr = c3t3.triangulation();
size_t num_vertices = tr.number_of_vertices();
size_t num_faces = c3t3.number_of_facets_in_complex();
size_t num_voxels = c3t3.number_of_cells_in_complex();
vertices.resize(num_vertices, 3);
faces.resize(num_faces, 3);
voxels.resize(num_voxels, 4);
std::map<Tr::Vertex_handle, int> V;
size_t inum = 0;
for(auto vit = tr.finite_vertices_begin();
vit != tr.finite_vertices_end(); ++vit) {
V[vit] = inum;
const auto& p = vit->point();
vertices.row(inum) = Vector3F(p.x(), p.y(), p.z()).transpose();
assert(inum < num_vertices);
inum++;
}
assert(inum == num_vertices);
size_t face_count = 0;
for(auto fit = c3t3.facets_in_complex_begin();
fit != c3t3.facets_in_complex_end(); ++fit) {
assert(face_count < num_faces);
for (int i=0; i<3; i++) {
if (i != fit->second) {
const auto& vh = (*fit).first->vertex(i);
assert(V.find(vh) != V.end());
const int vid = V[vh];
faces(face_count, i) = vid;
}
}
face_count++;
}
assert(face_count == num_faces);
size_t voxel_count = 0;
for(auto cit = c3t3.cells_in_complex_begin() ;
cit != c3t3.cells_in_complex_end(); ++cit ) {
assert(voxel_count < num_voxels);
for (int i=0; i<4; i++) {
assert(V.find(cit->vertex(i)) != V.end());
const size_t vid = V[cit->vertex(i)];
voxels(voxel_count, i) = vid;
}
voxel_count++;
}
assert(voxel_count == num_voxels);
}
std::vector<int>
create_histogram(const C3t3& c3t3, double& min_value, double& max_value)
{
typedef typename C3t3::Triangulation::Point Point_3;
std::vector<int> histo(181, 0);
min_value = 180.;
max_value = 0.;
for (typename C3t3::Cells_in_complex_iterator cit = c3t3.cells_in_complex_begin();
cit != c3t3.cells_in_complex_end();
++cit)
{
if (!c3t3.is_in_complex(cit))
continue;
#ifdef CGAL_MESH_3_DEMO_DONT_COUNT_TETS_ADJACENT_TO_SHARP_FEATURES_FOR_HISTOGRAM
if (c3t3.in_dimension(cit->vertex(0)) <= 1
|| c3t3.in_dimension(cit->vertex(1)) <= 1
|| c3t3.in_dimension(cit->vertex(2)) <= 1
|| c3t3.in_dimension(cit->vertex(3)) <= 1)
continue;
#endif //CGAL_MESH_3_DEMO_DONT_COUNT_TETS_ADJACENT_TO_SHARP_FEATURES_FOR_HISTOGRAM
const Point_3& p0 = cit->vertex(0)->point();
const Point_3& p1 = cit->vertex(1)->point();
const Point_3& p2 = cit->vertex(2)->point();
const Point_3& p3 = cit->vertex(3)->point();
double a = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p0, p1, p2, p3)));
histo[static_cast<int>(std::floor(a))] += 1;
min_value = (std::min)(min_value, a);
max_value = (std::max)(max_value, a);
a = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p0, p2, p1, p3)));
histo[static_cast<int>(std::floor(a))] += 1;
min_value = (std::min)(min_value, a);
max_value = (std::max)(max_value, a);
a = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p0, p3, p1, p2)));
histo[static_cast<int>(std::floor(a))] += 1;
min_value = (std::min)(min_value, a);
max_value = (std::max)(max_value, a);
a = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p1, p2, p0, p3)));
histo[static_cast<int>(std::floor(a))] += 1;
min_value = (std::min)(min_value, a);
max_value = (std::max)(max_value, a);
a = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p1, p3, p0, p2)));
histo[static_cast<int>(std::floor(a))] += 1;
min_value = (std::min)(min_value, a);
max_value = (std::max)(max_value, a);
a = CGAL::to_double(CGAL::abs(CGAL::Mesh_3::dihedral_angle(p2, p3, p0, p1)));
histo[static_cast<int>(std::floor(a))] += 1;
min_value = (std::min)(min_value, a);
max_value = (std::max)(max_value, a);
}
return histo;
}
bool write_c3t3_to_vtk_xml_file(const C3t3 &c3t3, const std::string &file_name)
{
typedef typename C3t3::Triangulation Tr;
typedef typename C3t3::Cells_in_complex_iterator Cell_iterator;
typedef typename Tr::Finite_vertices_iterator Vertex_iterator;
// Domain
typedef Exact_predicates_inexact_constructions_kernel K;
typedef K::FT FT;
typedef K::Point_3 Point;
// check that file extension is "vtu"
CGAL_assertion(file_name.substr(file_name.length()-4,4) == ".vtu");
// open file
std::ofstream vtk_file(file_name.c_str());
// header
vtk_file << "<VTKFile type=\"UnstructuredGrid\" ";
vtk_file << "version=\"0.1\" ";
vtk_file << "byte_order=\"BigEndian\">" << std::endl;
int indent_size = 2;
std::string indent_unit(indent_size, ' ');
std::string indent = indent_unit;
vtk_file << indent + "<UnstructuredGrid>" << std::endl;
// write mesh
Tr t = c3t3.triangulation();
int num_vertices = t.number_of_vertices();
int num_cells = c3t3.number_of_cells_in_complex();
indent += indent_unit;
vtk_file << indent + "<Piece NumberOfPoints=\"" << num_vertices << "\" ";
vtk_file << "NumberOfCells=\"" << num_cells << "\">" << std::endl;
// Write vertices
indent += indent_unit;
vtk_file << indent + "<Points>" << std::endl;
indent += indent_unit;
vtk_file << indent;
vtk_file << "<DataArray type=\"Float32\" NumberOfComponents=\"3\" Format=\"ascii\">" << std::endl;
std::map<Point, int> V;
int i=0;
indent += indent_unit;
for (Vertex_iterator it=t.finite_vertices_begin(); it != t.finite_vertices_end(); ++it)
{
vtk_file << indent;
vtk_file << it->point().x() << " " << it->point().y() << " " << it->point().z() << std::endl;
V[it->point()] = i;
++i;
}
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << indent + "</DataArray>" << std::endl;
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << indent + "</Points>" << std::endl;
// Write tetrahedra
vtk_file << indent << "<Cells>" << std::endl;
indent += indent_unit;
vtk_file << indent;
vtk_file << "<DataArray type=\"Int32\" Name=\"connectivity\" Format=\"ascii\">";
vtk_file << std::endl;
indent += indent_unit;
Cell_iterator it;
for (it = c3t3.cells_in_complex_begin(); it != c3t3.cells_in_complex_end(); ++it)
{
const typename Tr::Cell c(*it);
const typename Tr::Vertex_handle v0 = c.vertex(0);
const typename Tr::Vertex_handle v1 = c.vertex(1);
const typename Tr::Vertex_handle v2 = c.vertex(2);
const typename Tr::Vertex_handle v3 = c.vertex(3);
vtk_file << indent;
vtk_file << V[v0->point()] << " ";
vtk_file << V[v1->point()] << " ";
vtk_file << V[v2->point()] << " ";
vtk_file << V[v3->point()] << std::endl;
}
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << indent + "</DataArray>" << std::endl;
// offsets
// every element is a four node tetrahedron so all offsets are multiples of 4
vtk_file << indent;
vtk_file << "<DataArray type=\"Int32\" Name=\"offsets\" Format=\"ascii\">";
vtk_file << std::endl;
i = 4;
indent += indent_unit;
for (it = c3t3.cells_in_complex_begin(); it != c3t3.cells_in_complex_end(); ++it)
{
vtk_file << indent << i << std::endl;
i += 4;
}
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << indent + "</DataArray>" << std::endl;
// cell types (type 10 is a 4 node tetrahedron)
vtk_file << indent;
vtk_file << "<DataArray type=\"Int32\" Name=\"types\" Format=\"ascii\">";
vtk_file << std::endl;
indent += indent_unit;
for (it = c3t3.cells_in_complex_begin(); it != c3t3.cells_in_complex_end(); ++it)
{
vtk_file << indent << "10" << std::endl;
}
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << indent + "</DataArray>" << std::endl;
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << indent + "</Cells>" << std::endl;
// cell data
// only subdomain index is written here
vtk_file << indent + "<CellData Scalars=\"scalars\">" << std::endl;
indent += indent_unit;
vtk_file << indent + "<DataArray type=\"Int32\" Name=\"subdomain index\" Format=\"ascii\">" << std::endl;
indent += indent_unit;
for (it = c3t3.cells_in_complex_begin(); it != c3t3.cells_in_complex_end(); ++it)
{
vtk_file << indent << c3t3.subdomain_index(it) << std::endl;
}
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << indent + "</DataArray>" << std::endl;
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << indent + "</CellData>" << std::endl;
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << indent + "</Piece>" << std::endl;
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << indent + "</UnstructuredGrid>" << std::endl;
indent.erase(indent.length()-indent_size, indent_size);
vtk_file << "</VTKFile>" << std::endl;
return true;
}
// Constructor
Optimization_function(C3t3& c3t3, Domain* d, const Exude_parameters& p)
: Base(c3t3,d)
, exude_(NULL)
, p_(p)
, criterion_(p.sliver_bound, c3t3.triangulation()) {}