int main( )
{
//construct two non-intersecting nested polygons
Polygon_2 polygon1;
polygon1.push_back(Point(0,0));
polygon1.push_back(Point(2,0));
polygon1.push_back(Point(2,2));
polygon1.push_back(Point(0,2));
Polygon_2 polygon2;
polygon2.push_back(Point(0.5,0.5));
polygon2.push_back(Point(1.5,0.5));
polygon2.push_back(Point(1.5,1.5));
polygon2.push_back(Point(0.5,1.5));
//Insert the polygons into a constrained triangulation
CDT cdt;
cdt.insert_constraint(polygon1.vertices_begin(), polygon1.vertices_end(), true);
cdt.insert_constraint(polygon2.vertices_begin(), polygon2.vertices_end(), true);
//Mark facets that are inside the domain bounded by the polygon
mark_domains(cdt);
int count=0;
for (CDT::Finite_faces_iterator fit=cdt.finite_faces_begin();
fit!=cdt.finite_faces_end();++fit)
{
if ( fit->info().in_domain() ) ++count;
}
std::cout << "There are " << count << " facets in the domain." << std::endl;
return 0;
}
void cdt2_to_face_graph(const CDT& cdt, TriangleMesh& tm, int constant_coordinate_index, double constant_coordinate)
{
typedef typename boost::graph_traits<Polyhedron>::vertex_descriptor vertex_descriptor;
typedef std::map<typename CDT::Vertex_handle, vertex_descriptor> Map;
Map descriptors;
for (typename CDT::Finite_faces_iterator fit=cdt.finite_faces_begin(),
fit_end=cdt.finite_faces_end();
fit!=fit_end; ++fit)
{
if (!fit->is_in_domain()) continue;
CGAL::cpp11::array<vertex_descriptor,3> vds;
for(int i=0; i<3; ++i)
{
typename Map::iterator it;
bool insert_ok;
boost::tie(it,insert_ok) =
descriptors.insert(std::make_pair(fit->vertex(i),vertex_descriptor()));
if (insert_ok){
const Kernel::Point_3& pt=fit->vertex(i)->point();
double coords[3] = {pt[0], pt[1], pt[2]};
coords[constant_coordinate_index]=constant_coordinate;
it->second = add_vertex(Kernel::Point_3(coords[0],coords[1],coords[2]), tm);
}
vds[i]=it->second;
}
CGAL::Euler::add_face(vds, tm);
}
}
void FixedPlaneMesh::TrianglatePolygon(const double3& normal, std::vector<Point3D>& pts, ListOfvertices& results)
{
if (pts.size() < 3)
return ;
if (pts.size() ==3)
{
VertexInfo vi1(pts[0], normal, mColor);
VertexInfo vi2(pts[1], normal, mColor);
VertexInfo vi3(pts[2], normal, mColor);
results.push_back(vi1);
results.push_back(vi2);
results.push_back(vi3);
return ;
}
typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef CGAL::Triangulation_vertex_base_2<K> Vb;
typedef CGAL::Constrained_triangulation_face_base_2<K> Fb;
typedef CGAL::Triangulation_data_structure_2<Vb,Fb> TDS;
//typedef CGAL::Exact_predicates_tag Itag;
typedef CGAL::Constrained_Delaunay_triangulation_2<K, TDS, CGAL::No_intersection_tag> CDT;
vec3<double> origin = pts[0];
vec3<double> N = normal;
vec3<double> U = normalize(pts[1] - origin);
vec3<double> V = cross(N, U);
CDT cdt;
CDT::Vertex_handle vh1, vh2, vh3;
vec3<double> v0 = PosToLocal(U, V, N, origin, pts[0]);
CDT::Point p0(v0.x, v0.y);
vh1 = vh3 = cdt.insert(p0);
for ( int i = 1; i< pts.size() ; i++)
{
vec3<double> v1 = PosToLocal(U, V, N, origin, pts[i]);
CDT::Point p1(v1.x, v1.y);
vh2 = cdt.insert(p1);
cdt.insert_constraint(vh1, vh2);
vh1 = vh2;
}
cdt.insert_constraint(vh2, vh3);
int count = cdt.number_of_faces() ;
results.reserve(count*3);
for (CDT::Finite_faces_iterator fit = cdt.finite_faces_begin();
fit != cdt.finite_faces_end(); ++fit)
{
vec2<double> v0(fit->vertex(2)->point().x(),fit->vertex(2)->point().y() );
vec2<double> v1(fit->vertex(1)->point().x(),fit->vertex(1)->point().y() );
vec2<double> v2(fit->vertex(0)->point().x(),fit->vertex(0)->point().y() );
if (IsEqual(cross(v0- v2, v1-v2), (double)0., (double)EPSF ))
continue; //
vec3<double > p0(v0, 0.0);
vec3<double > p1(v1, 0.0);
vec3<double > p2(v2, 0.0);
p0 = PosToGlobal(U, V, N, origin, p0);
p1 = PosToGlobal(U, V, N, origin, p1);
p2 = PosToGlobal(U, V, N, origin, p2);
VertexInfo vi1(p0, N, mColor);
VertexInfo vi2(p1, N, mColor);
VertexInfo vi3(p2, N, mColor);
results.push_back(vi1);
results.push_back(vi2);
results.push_back(vi3);
}
}
void triangulate(const Polygon_2& polygon,
Cut_iter cuts_begin, Cut_iter cuts_end,
const boost::unordered_map<Point_3, boost::unordered_set<Segment_3_undirected> >& point2edges,
Out_iter triangles)
{
typedef CGAL::Triangulation_vertex_base_2<Kernel> Vb;
typedef CGAL::Triangulation_vertex_base_with_info_2<Point_3, Kernel, Vb> Info;
typedef CGAL::Constrained_triangulation_face_base_2<Kernel> Fb;
typedef CGAL::Triangulation_data_structure_2<Info,Fb> TDS;
typedef CGAL::Exact_predicates_tag Itag;
typedef CGAL::Constrained_Delaunay_triangulation_2<Kernel, TDS, Itag> CDT;
typedef CDT::Vertex_handle Vertex_handle;
static log4cplus::Logger logger = log4cplus::Logger::getInstance("polygon_utils");
Polygon_2 p(polygon);
LOG4CPLUS_TRACE(logger, "Triangulating " << pp(p));
if (p.size() < 3) return;
bool vertical = is_vertical(p);
if (vertical)
{
LOG4CPLUS_TRACE(logger, "Polygon is vertical. Rotating.");
p = yz_swap_neg(p);
}
bool reverse = !p.is_counterclockwise_oriented();
if (reverse)
p.reverse_orientation();
CDT cdt;
boost::unordered_map<Point_3, Vertex_handle> point2handle;
for (Polygon_2::Vertex_iterator it = p.vertices_begin(); it != p.vertices_end(); ++it)
{
Vertex_handle h = cdt.insert(*it);
point2handle[*it] = h;
h->info() = *it;//it->z();
}
Polygon_2::Vertex_circulator start = p.vertices_circulator();
Polygon_2::Vertex_circulator c = start;
Polygon_2::Vertex_circulator n = c;
++n;
do
{
Vertex_handle ch = point2handle[*c];//cdt.insert(*c);
Vertex_handle nh = point2handle[*n];//cdt.insert(*n);
// ch->info() = c->z();
// nh->info() = n->z();
// cdt.insert_constraint(*c, *n);
cdt.insert_constraint(ch, nh);
++c;
++n;
} while (c != start);
for (Cut_iter c_it = cuts_begin; c_it != cuts_end; ++c_it)
{
Polyline_2 cut = *c_it;
LOG4CPLUS_TRACE(logger, "Adding cut: " << pp(cut));
if (vertical)
cut = yz_swap_neg(cut);
for (Polyline_2::const_iterator c = cut.begin(); c != cut.end(); ++c)
{
Polyline_2::const_iterator n = c;
++n;
if (n != cut.end())
{
const Point_3& cp = *c;
const Point_3& np = *n;
if (point2handle.find(cp) == point2handle.end())
{
Vertex_handle h = cdt.insert(cp);
point2handle[cp] = h;
h->info() = cp;//cp.z();
}
if (point2handle.find(np) == point2handle.end())
{
Vertex_handle h = cdt.insert(np);
point2handle[np] = h;
h->info() = np;//np.z();
}
Vertex_handle ch = point2handle[*c];//cdt.insert(*c);
Vertex_handle nh = point2handle[*n];//cdt.insert(*n);
// ch->info() = c->z();
// nh->info() = n->z();
// cdt.insert_constraint(*c, *n);
cdt.insert_constraint(ch, nh);
LOG4CPLUS_TRACE(logger, " " << pp(Segment_2(*c, *n)));
}
}
}
// Loop through the triangulation and store the vertices of each triangle
for (CDT::Finite_faces_iterator ffi = cdt.finite_faces_begin();
ffi != cdt.finite_faces_end();
++ffi)
{
Triangle t;
Point_3 center = centroid(ffi->vertex(0)->info(), ffi->vertex(1)->info(), ffi->vertex(2)->info());
if (p.has_on_bounded_side(center) &&
is_legal(ffi->vertex(0)->info(), ffi->vertex(1)->info(), ffi->vertex(2)->info(), point2edges))
{
for (int i = 0; i < 3; ++i)
{
int idx = reverse ? 2-i : i;
if (!vertical)
{
// Point_3 p(ffi->vertex(i)->point());
// p = Point_3(p.x(), p.y(), ffi->vertex(i)->info());
Point_3 p(ffi->vertex(i)->info());
t[idx] = p;
}
else
{
// Point_3 p(ffi->vertex(i)->point());
// p = Point_3(p.x(), p.y(), ffi->vertex(i)->info());
Point_3 p(ffi->vertex(i)->info());
t[idx] = yz_swap_pos(p);
}
}
LOG4CPLUS_TRACE(logger, "Adding tile: " << pp_tri(t));
*triangles++ = t;
}
}
}
void triangulate(const Polygon& polygon, Triangle_iter triangles,
const boost::unordered_map<Point_3, boost::unordered_set<Segment_3_undirected> >& point2edges)
{
typedef CGAL::Triangulation_vertex_base_2<Kernel> Vb;
typedef CGAL::Triangulation_vertex_base_with_info_2<bool, Kernel, Vb> Info;
typedef CGAL::Constrained_triangulation_face_base_2<Kernel> Fb;
typedef CGAL::Triangulation_data_structure_2<Info,Fb> TDS;
typedef CGAL::Exact_predicates_tag Itag;
typedef CGAL::Constrained_Delaunay_triangulation_2<Kernel, TDS, Itag> CDT;
static log4cplus::Logger tlogger = log4cplus::Logger::getInstance("polygon_utils");
LOG4CPLUS_TRACE(tlogger, "Triangulating " << pp(polygon));
if (polygon.size() < 3) return;
Polygon p = polygon;
bool vertical = is_vertical(p);
if (vertical)
{
LOG4CPLUS_TRACE(tlogger, "Polygon is vertical. Rotating.");
p = yz_swap_neg(p);
}
bool reverse = !p.is_counterclockwise_oriented();
// THIS IS BAD, BAD, BAD!
{
typename Polygon::Vertex_circulator start = p.vertices_circulator();
typename Polygon::Vertex_circulator c = start;
typename Polygon::Vertex_circulator n = c;
typename Polygon::Vertex_circulator prev = c;
++n;
--prev;
Polygon_2 newp;
do
{
if (!CGAL::collinear(*prev, *c, *n))
newp.push_back(*c);
++prev;
++c;
++n;
} while (c != start);
p = newp;
}
CDT cdt;
typename Polygon::Vertex_circulator start = p.vertices_circulator();
typename Polygon::Vertex_circulator c = start;
typename Polygon::Vertex_circulator n = c;
do
{
cdt.insert_constraint(*c, *n);
++c;
++n;
} while (c != start);
// Loop through the triangulation and store the vertices of each triangle
for (CDT::Finite_faces_iterator ffi = cdt.finite_faces_begin();
ffi != cdt.finite_faces_end();
++ffi)
{
Triangle t;
Point_3 center = centroid(ffi->vertex(0)->point(), ffi->vertex(1)->point(), ffi->vertex(2)->point());
if (p.has_on_bounded_side(center) &&
is_legal(ffi->vertex(0)->point(), ffi->vertex(1)->point(), ffi->vertex(2)->point(), point2edges))
{
for (int i = 0; i < 3; ++i)
{
int idx = reverse ? 2-i : i;
if (!vertical)
t[idx] = ffi->vertex(i)->point();
else
t[idx] = yz_swap_pos(ffi->vertex(i)->point());
}
LOG4CPLUS_TRACE(tlogger, "Adding tile: " << pp_tri(t));
*triangles = t;
++triangles;
}
}
}
void convert_to_dealii_format(CDT &cdt, dealii::Triangulation<2> &triangulation)
{
std::vector<dealii::Point<2> > vertex_in_grid;
std::vector<dealii::CellData<2> > cell_in_grid;
for(auto fit = cdt.finite_faces_begin(); fit != cdt.finite_faces_end(); ++fit)
{
CDT::Triangle trg = cdt.triangle(fit);
// location of points on the triangle
//
// 2
// / \
// / \
// / \
// / \
// 5 / \ 4
// /\ /\
// / \ / \
// / \ / \
// / \ / \
// / 6 \
// / | \
// / | \
// / | \
// 0___________________________1
// 3
//
dealii::Point<2> p[7] =
{
dealii::Point<2>(trg[0].x(), trg[0].y()),
dealii::Point<2>(trg[1].x(), trg[1].y()),
dealii::Point<2>(trg[2].x(), trg[2].y()),
(p[0] + p[1]) / 2.0,
(p[1] + p[2]) / 2.0,
(p[2] + p[0]) / 2.0,
(p[0] + p[1] + p[2]) / 3.0
};
struct IndexPoint { u32 index; bool point_already_exist = false; };
IndexPoint index_point[7];
FOR(i, 0, 7)
FOR(j, 0, vertex_in_grid.size())
if (p[i].distance (vertex_in_grid[j]) < 1.e-10)
{
index_point[i].index = j;
index_point[i].point_already_exist = true;
};
FOR(i, 0, 7)
if (not index_point[i].point_already_exist)
{
vertex_in_grid .push_back (p[i]);
index_point[i].index = vertex_in_grid.size() - 1;
index_point[i].point_already_exist = true;
};
u8 mat_id = fit->is_in_domain() ? 0 : 1;
auto add_cell = [&cell_in_grid, &index_point, mat_id] (arr<st, 4> &&indx)
{
cell_in_grid .push_back (dealii::CellData<2>{
index_point[indx[0]].index,
index_point[indx[1]].index,
index_point[indx[2]].index,
index_point[indx[3]].index,
{.material_id = mat_id}});
};
int main() {
//construct two non-intersecting nested polygons
Polygon_2 polygon1;
polygon1.push_back(Point_2(0.0, 0.0));
polygon1.push_back(Point_2(2.0, 0.0));
polygon1.push_back(Point_2(1.7, 1.0));
polygon1.push_back(Point_2(2.0, 2.0));
polygon1.push_back(Point_2(0.0, 2.0));
Polygon_2 polygon2;
polygon2.push_back(Point_2(0.5, 0.5));
polygon2.push_back(Point_2(1.5, 0.5));
polygon2.push_back(Point_2(1.5, 1.5));
polygon2.push_back(Point_2(0.5, 1.5));
//Insert the polyons into a constrained triangulation
CDT cdt;
insert_polygon(cdt, polygon1);
insert_polygon(cdt, polygon2);
//Extract point and provide the an index
std::vector< triangulation_point > points ;
for ( CDT::Vertex_iterator it = cdt.vertices_begin(); it != cdt.vertices_end(); ++it ){
it->info() = points.size() ;
points.push_back( it->point() );
}
//Mark facets that are inside the domain bounded by the polygon
mark_domains(cdt);
//
int count = 0;
for (CDT::Finite_faces_iterator fit = cdt.finite_faces_begin(); fit != cdt.finite_faces_end(); ++fit) {
if (fit->info().in_domain()){
++count;
}
}
/*
* export
*/
std::ofstream ofs("polygon_triangulation2.obj");
if ( ! ofs.good() ){
std::cout << "can't open file" << std::endl;
return 1 ;
}
//-- print vertices
ofs << "# " << points.size() << " vertices"<< std::endl ;
for ( size_t i = 0; i < points.size(); i++ ){
ofs << "v " << points[i] << " 0.0" << std::endl;
}
//-- print faces
ofs << "# " << cdt.number_of_faces() << " faces"<< std::endl ;
// warning : Delaunay_triangulation_2::All_faces_iterator iterator over infinite faces
for ( CDT::Finite_faces_iterator it = cdt.finite_faces_begin(); it != cdt.finite_faces_end(); ++it )
{
//ignore holes
if ( ! it->info().in_domain() ){
continue ;
}
size_t ia = it->vertex(0)->info();
size_t ib = it->vertex(1)->info();
size_t ic = it->vertex(2)->info();
assert( it->is_valid() );
//assert ( ia < cdt.number_of_vertices() || ib < tri.number_of_vertices() || ic < tri.number_of_vertices() ) ;
ofs << "f " << ( ia + 1 ) << " " << ( ib + 1 ) << " " << ( ic + 1 ) << std::endl;
}
return 0;
}
int main()
{
typedef viennagrid::plc_2d_mesh mesh_type;
mesh_type mesh;
typedef viennagrid::result_of::point<mesh_type>::type point_type;
typedef viennagrid::result_of::element<mesh_type, viennagrid::vertex_tag>::type vertex_type;
typedef viennagrid::result_of::handle<mesh_type, viennagrid::vertex_tag>::type vertex_handle_type;
typedef viennagrid::result_of::element<mesh_type, viennagrid::line_tag>::type line_type;
typedef viennagrid::result_of::handle<mesh_type, viennagrid::line_tag>::type line_handle_type;
typedef viennagrid::result_of::element<mesh_type, viennagrid::plc_tag>::type plc_type;
typedef viennagrid::result_of::handle<mesh_type, viennagrid::plc_tag>::type plc_handle_type;
plc_handle_type plc_handle;
{
std::vector<vertex_handle_type> v;
v.push_back( viennagrid::make_vertex( mesh, point_type(0, 0) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(10, 0) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(20, 10) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(20, 20) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(10, 20) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(0, 10) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(5, 5) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(10, 10) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(12, 10) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(10, 12) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(8, 10) ) );
v.push_back( viennagrid::make_vertex( mesh, point_type(15, 15) ) );
std::vector<line_handle_type> lines;
{
std::vector<vertex_handle_type>::iterator start = v.begin();
std::vector<vertex_handle_type>::iterator end = v.begin() + 7;
std::vector<vertex_handle_type>::iterator it1 = start;
std::vector<vertex_handle_type>::iterator it2 = it1; ++it2;
for (; it2 != end; ++it1, ++it2)
lines.push_back( viennagrid::make_line(mesh, *it1, *it2) );
lines.push_back( viennagrid::make_line(mesh, *it1, *start) );
}
{
std::vector<vertex_handle_type>::iterator start = v.begin() + 7;
std::vector<vertex_handle_type>::iterator end = v.begin() + 10;
std::vector<vertex_handle_type>::iterator it1 = start;
std::vector<vertex_handle_type>::iterator it2 = it1; ++it2;
for (; it2 != end; ++it1, ++it2)
lines.push_back( viennagrid::make_line(mesh, *it1, *it2) );
lines.push_back( viennagrid::make_line(mesh, *it1, *start) );
}
lines.push_back( viennagrid::make_element<line_type>( mesh, v.begin() + 9, v.begin() + 11 ) );
vertex_handle_type point = v[11];
std::vector<point_type> hole_points;
hole_points.push_back( point_type(10.5, 10.5) );
plc_handle = viennagrid::make_plc( mesh,
lines.begin(), lines.end(),
&point, &point + 1,
hole_points.begin(), hole_points.end()
);
}
plc_type & plc = viennagrid::dereference_handle(mesh, plc_handle);
typedef viennagrid::result_of::element_range<plc_type, viennagrid::vertex_tag>::type vertex_range_type;
typedef viennagrid::result_of::iterator<vertex_range_type>::type vertex_range_iterator;
typedef viennagrid::result_of::element_range<plc_type, viennagrid::line_tag>::type line_range_type;
typedef viennagrid::result_of::iterator<line_range_type>::type line_range_iterator;
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef CGAL::Triangulation_vertex_base_2<Kernel> VertexBase;
typedef CGAL::Delaunay_mesh_face_base_2<Kernel> FaceBase;
typedef CGAL::Triangulation_data_structure_2<VertexBase, FaceBase> Triangulation_structure;
typedef CGAL::Constrained_Delaunay_triangulation_2<Kernel, Triangulation_structure> CDT;
typedef CGAL::Delaunay_mesh_size_criteria_2<CDT> Criteria;
typedef CDT::Vertex_handle Vertex_handle;
typedef CDT::Point Point;
CDT cdt;
std::map<vertex_handle_type, Vertex_handle> vertex_handle_map;
vertex_range_type vertices = viennagrid::elements<viennagrid::vertex_tag>(plc);
for (vertex_range_iterator it = vertices.begin(); it != vertices.end(); ++it)
{
vertex_handle_type const & vtx_handle = it.handle();
vertex_type const & vtx = *it;
point_type const & vgrid_point = viennagrid::point( mesh, vtx );
Vertex_handle handle = cdt.insert( Point(vgrid_point[0], vgrid_point[1]) );
vertex_handle_map[vtx_handle] = handle;
}
line_range_type lines = viennagrid::elements<viennagrid::line_tag>(plc);
for (line_range_iterator it = lines.begin(); it != lines.end(); ++it)
{
line_type & line = *it;
vertex_handle_type vgrid_v0 = viennagrid::elements<viennagrid::vertex_tag>(line).handle_at(0);
vertex_handle_type vgrid_v1 = viennagrid::elements<viennagrid::vertex_tag>(line).handle_at(1);
Vertex_handle cgal_v0 = vertex_handle_map[vgrid_v0];
Vertex_handle cgal_v1 = vertex_handle_map[vgrid_v1];
cdt.insert_constraint(cgal_v0, cgal_v1);
}
std::vector<point_type> & vgrid_list_of_holes = viennagrid::hole_points(plc);
std::list<Point> cgal_list_of_holes;
for (std::vector<point_type>::iterator it = vgrid_list_of_holes.begin(); it != vgrid_list_of_holes.end(); ++it)
cgal_list_of_holes.push_back( Point( (*it)[0], (*it)[1] ) );
CGAL::refine_Delaunay_mesh_2(cdt, cgal_list_of_holes.begin(), cgal_list_of_holes.end(), Criteria());
std::cout << "Number of vertices: " << cdt.number_of_vertices() << std::endl;
std::cout << "Number of finite faces: " << cdt.number_of_faces() << std::endl;
typedef viennagrid::triangular_2d_mesh triangle_mesh_type;
triangle_mesh_type triangle_mesh;
typedef viennagrid::result_of::point<triangle_mesh_type>::type triangle_point_type;
typedef viennagrid::result_of::element<triangle_mesh_type, viennagrid::vertex_tag>::type triangle_vertex_type;
typedef viennagrid::result_of::handle<triangle_mesh_type, viennagrid::vertex_tag>::type triangle_vertex_handle_type;
typedef viennagrid::result_of::element<triangle_mesh_type, viennagrid::line_tag>::type triangle_line_type;
typedef viennagrid::result_of::handle<triangle_mesh_type, viennagrid::line_tag>::type triangle_line_handle_type;
typedef viennagrid::result_of::element<triangle_mesh_type, viennagrid::triangle_tag>::type triangle_triangle_type;
typedef viennagrid::result_of::handle<triangle_mesh_type, viennagrid::triangle_tag>::type triangle_triangle__handle_type;
std::map<Point, triangle_vertex_handle_type> points;
int mesh_faces_counter = 0;
for(CDT::Finite_faces_iterator fit = cdt.finite_faces_begin(); fit != cdt.finite_faces_end(); ++fit)
{
if(fit->is_in_domain())
{
typedef CDT::Triangle Triangle;
Triangle tri = cdt.triangle(fit);
triangle_vertex_handle_type vgrid_vtx[3];
for (int i = 0; i < 3; ++i)
{
std::map<Point, triangle_vertex_handle_type>::iterator pit = points.find( tri[i] );
if (pit == points.end())
{
vgrid_vtx[i] = viennagrid::make_vertex( triangle_mesh, triangle_point_type(tri[i].x(), tri[i].y()) );
points[ tri[i] ] = vgrid_vtx[i];
}
else
vgrid_vtx[i] = pit->second;
}
viennagrid::make_element<triangle_triangle_type>( triangle_mesh, vgrid_vtx, vgrid_vtx+3 );
std::cout << tri << std::endl;
++mesh_faces_counter;
}
}
std::cout << "Number of faces in the mesh mesh: " << mesh_faces_counter << std::endl;
std::copy( viennagrid::elements<triangle_triangle_type>(triangle_mesh).begin(), viennagrid::elements<triangle_triangle_type>(triangle_mesh).end(), std::ostream_iterator<triangle_triangle_type>(std::cout, "\n") );
viennagrid::io::vtk_writer<triangle_mesh_type> vtk_writer;
vtk_writer(triangle_mesh, "test");
}
