int main ()
{
// Construct the arrangement containing two intersecting triangles.
Arrangement_2 arr;
Face_index_observer obs (arr);
Segment_2 s1 (Point_2(4, 1), Point_2(7, 6));
Segment_2 s2 (Point_2(1, 6), Point_2(7, 6));
Segment_2 s3 (Point_2(4, 1), Point_2(1, 6));
Segment_2 s4 (Point_2(1, 3), Point_2(7, 3));
Segment_2 s5 (Point_2(1, 3), Point_2(4, 8));
Segment_2 s6 (Point_2(4, 8), Point_2(7, 3));
insert_non_intersecting_curve (arr, s1);
insert_non_intersecting_curve (arr, s2);
insert_non_intersecting_curve (arr, s3);
insert (arr, s4);
insert (arr, s5);
insert (arr, s6);
// Go over all arrangement faces and print the index of each face and it
// outer boundary. The face index is stored in its data field in our case.
Arrangement_2::Face_const_iterator fit;
Arrangement_2::Ccb_halfedge_const_circulator curr;
std::cout << arr.number_of_faces() << " faces:" << std::endl;
for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) {
std::cout << "Face no. " << fit->data() << ": ";
if (fit->is_unbounded())
std::cout << "Unbounded." << std::endl;
else {
curr = fit->outer_ccb();
std::cout << curr->source()->point();
do {
std::cout << " --> " << curr->target()->point();
++curr;
} while (curr != fit->outer_ccb());
std::cout << std::endl;
}
}
return 0;
}
int main ()
{
Arrangement_2 arr;
// Construct an arrangement of seven intersecting line segments.
insert (arr, Segment_2 (Point_2 (1, 1), Point_2 (7, 1)));
insert (arr, Segment_2 (Point_2 (1, 1), Point_2 (3, 7)));
insert (arr, Segment_2 (Point_2 (1, 4), Point_2 (7, 1)));
insert (arr, Segment_2 (Point_2 (2, 2), Point_2 (9, 3)));
insert (arr, Segment_2 (Point_2 (2, 2), Point_2 (4, 4)));
insert (arr, Segment_2 (Point_2 (7, 1), Point_2 (9, 3)));
insert (arr, Segment_2 (Point_2 (3, 7), Point_2 (9, 3)));
// Create a mapping of the arrangement faces to indices.
CGAL::Arr_face_index_map<Arrangement_2> index_map (arr);
// Perform breadth-first search from the unbounded face, and use the BFS
// visitor to associate each arrangement face with its discover time.
Discover_time_bfs_visitor<CGAL::Arr_face_index_map<Arrangement_2> >
bfs_visitor (index_map);
Arrangement_2::Face_handle uf = arr.unbounded_face();
boost::breadth_first_search (Dual_arrangement_2 (arr), uf,
boost::vertex_index_map (index_map).
visitor (bfs_visitor));
// Print the results:
Arrangement_2::Face_iterator fit;
for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit)
{
std::cout << "Discover time " << fit->data() << " for ";
if (fit != uf)
{
std::cout << "face ";
print_ccb<Arrangement_2> (fit->outer_ccb());
}
else
std::cout << "the unbounded face." << std::endl;
}
return (0);
}
void
arrangement::compute_pointInCells(Arrangement_2 &arr, std::vector<std::vector<double> > &points)
{
Walk_pl walk_pl(arr);
int cpt = 0;
for (Arrangement_2::Face_iterator face = arr.faces_begin(); face != arr.faces_end(); ++face)
{
if (face->is_unbounded())
face->set_data(-1);
else
{
// set data to each face
face->set_data(cpt++);
// find a point in this face
Arrangement_2::Ccb_halfedge_circulator previous = face->outer_ccb();
Arrangement_2::Ccb_halfedge_circulator first_edge = face->outer_ccb();
Arrangement_2::Ccb_halfedge_circulator edge = face->outer_ccb();
++edge;
do
{
std::vector<double> p1 = getPointMiddle(previous);
std::vector<double> p2 = getPointMiddle(edge);
std::vector<double> m;
m.push_back((p1[0]+p2[0])/2);
m.push_back((p1[1]+p2[1])/2);
Rational x_(m[0]);
Rational y_(m[1]);
Conic_point_2 p(x_,y_);
Arrangement_2::Vertex_handle v = insert_point(arr, p, walk_pl);
try
{
if (v->face()->data() == (cpt-1))
{
bool flag = false;
// test if it is not in holes and not in unbounded face
for (int i = 0; i < (int) convolutions_o.size(); ++i)
{
Walk_pl wpl(convolutions_o[i]);
Arrangement_2::Vertex_handle t = insert_point(convolutions_o[i], p, wpl);
if (t->face()->data() == 1)
{
convolutions_o[i].remove_isolated_vertex(t);
break;
}
else if (t->face()->data() == 2 || t->face()->data() == 0)
{
flag = true;
convolutions_o[i].remove_isolated_vertex(t);
break;
}
}
// then continue
if (!flag)
points.push_back(m);
else
{
--cpt;
face->set_data(-1);
}
arr.remove_isolated_vertex(v);
break;
}
arr.remove_isolated_vertex(v);
}
catch (const std::exception exn) {}
previous = edge;
++edge;
} while (edge != first_edge);
}
}
}
