static void visit(int k,
tree_vertex_t *vertices,
si32 tag)
{
int i;
tree_vertex_t *v;
push_vertex(vertices + k);
while (!vertex_stack_empty()) {
v = pop_vertex();
if (!v->visited) {
v->tag = tag;
v->visited = 1;
for (i = 0; i < v->nadjacent; i++) {
push_vertex(vertices + vertex_index(v->adjacent[i]));
}
} /* i */
} /* while */
}
void operator()() const
{
//-------------------------------------------------------
// Test default constructed c3t3
//-------------------------------------------------------
C3t3 c3t3;
Tr& tr = c3t3.triangulation();
assert(c3t3.cells_in_complex_begin() == c3t3.cells_in_complex_end());
assert(c3t3.facets_in_complex_begin() == c3t3.facets_in_complex_end());
assert(c3t3.edges_in_complex_begin() == c3t3.edges_in_complex_end());
assert(c3t3.vertices_in_complex_begin() == c3t3.vertices_in_complex_end());
assert(c3t3.number_of_cells_in_complex() == 0);
assert(c3t3.number_of_facets_in_complex() == 0);
assert(c3t3.number_of_edges_in_complex() == 0);
assert(c3t3.number_of_vertices_in_complex() == 0);
//-------------------------------------------------------
// Data generation : fill a triangulation with 4 vertices
//-------------------------------------------------------
Weighted_point p1(0,0,0);
Weighted_point p2(1,0,0);
Weighted_point p3(0,1,0);
Weighted_point p4(0,0,1);
Vertex_handle vp1 = tr.insert(p1);
Vertex_handle vp2 = tr.insert(p2);
Vertex_handle vp3 = tr.insert(p3);
Vertex_handle vp4 = tr.insert(p4);
Corner_index corner_index (1);
Corner_index corner_index_bis (2);
Curve_index curve_index (1);
Curve_index curve_index_bis (2);
Index vertex_index (curve_index);
//-------------------------------------------------------
// Add edge to c3t3 and verify
//-------------------------------------------------------
std::cerr << "\tNumber of edges in c3t3: "
<< c3t3.number_of_edges_in_complex() << std::endl;
std::cerr << "\tNumber of corners in c3t3: "
<< c3t3.number_of_vertices_in_complex() << std::endl;
std::cerr << "Insert one edge in c3t3" << std::endl;
Edge e = *(tr.finite_edges_begin());
const Vertex_handle& ev1 = e.first->vertex(e.second);
const Vertex_handle& ev2 = e.first->vertex(e.third);
c3t3.add_to_complex(e,curve_index);
std::cerr << "\tNumber of edges in c3t3: "
<< c3t3.number_of_edges_in_complex() << std::endl;
std::cerr << "\tNumber of corners in c3t3: "
<< c3t3.number_of_vertices_in_complex() << std::endl;
assert(e == *(c3t3.edges_in_complex_begin()));
assert(c3t3.number_of_edges_in_complex() == 1);
assert(c3t3.number_of_edges_in_complex() == size_type(std::distance(c3t3.edges_in_complex_begin(),
c3t3.edges_in_complex_end())));
assert(c3t3.is_in_complex(e));
assert(c3t3.is_in_complex(ev1, ev2));
assert(c3t3.curve_index(e) == curve_index);
//-------------------------------------------------------
// Remove cell from c3t3 and verify
//-------------------------------------------------------
std::cerr << "Remove edge from c3t3" << std::endl;
c3t3.remove_from_complex(ev1, ev2);
std::cerr << "\tNumber of edges in c3t3: "
<< c3t3.number_of_edges_in_complex() << std::endl;
std::cerr << "\tNumber of corners in c3t3: "
<< c3t3.number_of_vertices_in_complex() << std::endl;
assert(c3t3.number_of_edges_in_complex() == 0);
assert(! c3t3.is_in_complex(e));
assert(! c3t3.is_in_complex(ev1, ev2));
assert(c3t3.curve_index(e) == Curve_index());
assert(c3t3.curve_index(ev1, ev2) == Curve_index());
//-------------------------------------------------------
// Add corner to c3t3 and verify
//-------------------------------------------------------
std::cerr << "Insert one corner in c3t3" << std::endl;
Vertex_handle v = ++tr.finite_vertices_begin();
c3t3.add_to_complex(v,corner_index);
std::cerr << "\tNumber of edges in c3t3: "
<< c3t3.number_of_edges_in_complex() << std::endl;
std::cerr << "\tNumber of corners in c3t3: "
<< c3t3.number_of_vertices_in_complex() << std::endl;
assert(Vertex_handle(c3t3.vertices_in_complex_begin()) == v);
assert(c3t3.number_of_vertices_in_complex() == 1);
assert(c3t3.number_of_vertices_in_complex() == size_type(std::distance(c3t3.vertices_in_complex_begin(),
c3t3.vertices_in_complex_end())));
assert(c3t3.is_in_complex(v));
assert(c3t3.corner_index(v) == corner_index);
//-------------------------------------------------------
// Remove corner from c3t3 and verify
//-------------------------------------------------------
std::cerr << "Remove corner from c3t3" << std::endl;
c3t3.remove_from_complex(v);
std::cerr << "\tNumber of edges in c3t3: "
<< c3t3.number_of_edges_in_complex() << std::endl;
std::cerr << "\tNumber of corners in c3t3: "
<< c3t3.number_of_vertices_in_complex() << std::endl;
assert(c3t3.vertices_in_complex_begin() == c3t3.vertices_in_complex_begin());
assert(c3t3.number_of_vertices_in_complex() == 0);
assert(!c3t3.is_in_complex(v));
assert(c3t3.corner_index(v) == Corner_index());
//-------------------------------------------------------
// Add 1 curve segment (3 edges + 2 corners) to c3t3 and verify
//-------------------------------------------------------
std::cerr << "Insert 1 curve segment (3 edges + 2 corners) in c3t3" << std::endl;
c3t3.add_to_complex(vp1,vp2,curve_index);
c3t3.add_to_complex(vp2,vp3,curve_index);
c3t3.add_to_complex(vp3,vp4,curve_index);
c3t3.add_to_complex(vp1,corner_index);
c3t3.add_to_complex(vp4,corner_index);
c3t3.set_dimension(vp1,0);
c3t3.set_dimension(vp2,1);
c3t3.set_dimension(vp3,1);
c3t3.set_dimension(vp4,0);
std::cerr << "\tNumber of edges in c3t3: "
<< c3t3.number_of_edges_in_complex() << std::endl;
std::cerr << "\tNumber of corners in c3t3: "
<< c3t3.number_of_vertices_in_complex() << std::endl;
assert(c3t3.number_of_edges_in_complex() == 3);
assert(c3t3.number_of_edges_in_complex() == size_type(std::distance(c3t3.edges_in_complex_begin(),
c3t3.edges_in_complex_end())));
assert(c3t3.number_of_vertices_in_complex() == 2);
assert(c3t3.number_of_vertices_in_complex() == size_type(std::distance(c3t3.vertices_in_complex_begin(),
c3t3.vertices_in_complex_end())));
// -----------------------------------
// Test iterators
// The goal here is to test operators and conversion on iterator type
// -----------------------------------
typename C3t3::Vertices_in_complex_iterator vit = c3t3.vertices_in_complex_begin();
v = vit;
typename C3t3::Triangulation::Vertex& tv1 = *v;
typename C3t3::Triangulation::Vertex& tv2 = *vit;
assert( ( v == vp1 && vit->point() == p1 )
|| ( v == vp4 && vit->point() == p4 ) );
assert ( tv1.in_dimension() == tv2.in_dimension() );
//-------------------------------------------------------
// Check adjacencies
//-------------------------------------------------------
std::vector<std::pair<Vertex_handle,Curve_index> > incident_vertices;
c3t3.adjacent_vertices_in_complex(vp1,std::back_inserter(incident_vertices));
assert(incident_vertices.size() == 1);
assert(incident_vertices.front().first == vp2);
incident_vertices.clear();
c3t3.adjacent_vertices_in_complex(vp3,std::back_inserter(incident_vertices));
assert(incident_vertices.size() == 2);
assert( (incident_vertices.front().first == vp2 && incident_vertices.back().first == vp4)
|| (incident_vertices.front().first == vp4 && incident_vertices.back().first == vp2));
//-------------------------------------------------------
// Create c3t3_bis
//-------------------------------------------------------
std::cout << "Insert 6 points in c3t3_bis, add 1 corner and 1 edge to c3t3_bis\n";
std::vector<Weighted_point> points;
points.push_back(Weighted_point(10,11,12));
points.push_back(Weighted_point(11,13,10));
points.push_back(Weighted_point(7,4,6));
points.push_back(Weighted_point(5,2,14));
points.push_back(Weighted_point(1,2,3));
points.push_back(Weighted_point(3,9,13));
C3t3 c3t3_bis;
c3t3_bis.triangulation().insert(points.begin(),points.end());
Edge e_bis = *(c3t3_bis.triangulation().finite_edges_begin());
c3t3_bis.add_to_complex(e_bis,curve_index_bis);
Vertex_handle v_bis = ++c3t3_bis.triangulation().finite_vertices_begin();
c3t3_bis.add_to_complex(v_bis,corner_index_bis);
std::cerr << "\tNumber of edges in c3t3_bis: "
<< c3t3_bis.number_of_edges_in_complex() << std::endl;
std::cerr << "\tNumber of corners in c3t3_bis: "
<< c3t3_bis.number_of_vertices_in_complex() << std::endl;
std::cout << "\tNumber of vertices in c3t3_bis triangulation: "
<< c3t3_bis.triangulation().number_of_vertices() << std::endl;
//-------------------------------------------------------
// Swap c3t3 and c3t3_bis
//-------------------------------------------------------
std::cout << "Swap c3t3 and c3t3_bis\n";
typedef typename C3t3::size_type size_type;
size_type c3t3_edge_nb = c3t3.number_of_edges_in_complex();
size_type c3t3_corner_nb = c3t3.number_of_vertices_in_complex();
size_type c3t3_vertex_nb = c3t3.triangulation().number_of_vertices();
size_type c3t3_bis_edge_nb = c3t3_bis.number_of_edges_in_complex();
size_type c3t3_bis_corner_nb = c3t3_bis.number_of_vertices_in_complex();
size_type c3t3_bis_vertex_nb = c3t3_bis.triangulation().number_of_vertices();
c3t3.swap(c3t3_bis);
std::cerr << "\tNumber of edges in c3t3: "
<< c3t3.number_of_edges_in_complex() << std::endl;
std::cerr << "\tNumber of corners in c3t3: "
<< c3t3.number_of_vertices_in_complex() << std::endl;
std::cout << "\tNumber of vertices in c3t3: "
<< c3t3.triangulation().number_of_vertices() << std::endl;
std::cerr << "\tNumber of edges in c3t3_bis: "
<< c3t3_bis.number_of_edges_in_complex() << std::endl;
std::cerr << "\tNumber of corners in c3t3_bis: "
<< c3t3_bis.number_of_vertices_in_complex() << std::endl;
std::cout << "\tNumber of vertices in c3t3_bis: "
<< c3t3_bis.triangulation().number_of_vertices() << std::endl;
assert(c3t3_edge_nb == c3t3_bis.number_of_edges_in_complex());
assert(c3t3_corner_nb == c3t3_bis.number_of_vertices_in_complex());
assert(c3t3_vertex_nb == c3t3_bis.triangulation().number_of_vertices());
assert(c3t3_bis_edge_nb == c3t3.number_of_edges_in_complex());
assert(c3t3_bis_corner_nb == c3t3.number_of_vertices_in_complex());
assert(c3t3_bis_vertex_nb == c3t3.triangulation().number_of_vertices());
// reset
c3t3.swap(c3t3_bis);
//-------------------------------------------------------
// Test edge iterators
//-------------------------------------------------------
std::cout << "Test edge iterators\n";
const Edge& edge_to_modify = *(c3t3.edges_in_complex_begin());
c3t3.remove_from_complex(edge_to_modify);
c3t3.add_to_complex(edge_to_modify,curve_index_bis);
typename C3t3::Edges_in_complex_iterator curve_eit =
c3t3.edges_in_complex_begin(curve_index);
typename C3t3::Edges_in_complex_iterator curve_eit_bis =
c3t3.edges_in_complex_begin(curve_index_bis);
typename C3t3::Edges_in_complex_iterator eend =
c3t3.edges_in_complex_end();
std::cout << "\tNumber of edges of index '" << curve_index << "': "
<< std::distance(curve_eit,eend) << std::endl;
std::cout << "\tNumber of edges of index '" << curve_index_bis << "': "
<< std::distance(curve_eit_bis,eend) << std::endl;
assert ( std::distance(curve_eit,eend) == 2 );
assert ( std::distance(curve_eit_bis,eend) == 1 );
assert ( c3t3.curve_index(*curve_eit) == curve_index );
assert ( c3t3.curve_index(*curve_eit_bis) == curve_index_bis );
//-------------------------------------------------------
// Test vertex iterators
//-------------------------------------------------------
std::cout << "Test vertex iterators\n";
const Vertex_handle& vertex_to_modify = c3t3.vertices_in_complex_begin();
c3t3.remove_from_complex(vertex_to_modify);
c3t3.add_to_complex(vertex_to_modify,corner_index_bis);
typename C3t3::Vertices_in_complex_iterator corner_vit =
c3t3.vertices_in_complex_begin(corner_index);
typename C3t3::Vertices_in_complex_iterator corner_vit_bis =
c3t3.vertices_in_complex_begin(corner_index_bis);
typename C3t3::Vertices_in_complex_iterator vend =
c3t3.vertices_in_complex_end();
std::cout << "\tNumber of vertices of index '" << corner_index << "': "
<< std::distance(corner_vit,vend) << std::endl;
std::cout << "\tNumber of vertices of index '" << corner_index_bis << "': "
<< std::distance(corner_vit_bis,vend) << std::endl;
assert ( std::distance(corner_vit,vend) == 1 );
assert ( std::distance(corner_vit_bis,vend) == 1 );
assert ( c3t3.corner_index(corner_vit) == corner_index );
assert ( c3t3.corner_index(corner_vit_bis) == corner_index_bis );
}
