Cómo iterar sobre las caras en CGAL

Question

Estoy intentando usar CGAL para hacer algo de triangulación de Delaunay. Usé una de las muestras de CGAL para calcular una triangulación que incluye un atributo de campo de altura.

El problema que tengo es que no tengo idea de cómo obtener la triangulación resultante. Descubrí cómo obtener el face_iterator, pero no sé qué hacer desde allí. Lo que espero obtener es un índice en la matriz de puntos para cada uno de los 3 puntos en cada triángulo.

Tengo problemas para vadear a través de todas las plantillas anidadas:

#include <CGAL/Exact_predicates_inexact_constructions_kernel.h> 
#include <CGAL/Triangulation_euclidean_traits_xy_3.h> 
#include <CGAL/Delaunay_triangulation_2.h> 

typedef CGAL::Exact_predicates_inexact_constructions_kernel K; 
typedef CGAL::Triangulation_euclidean_traits_xy_3<K> Gt; 
typedef CGAL::Delaunay_triangulation_2<Gt> Delaunay; 
typedef K::Point_3 Point; 

int main() 
{ 
    //initialize the points with some trivial data 
    std::vector<Point> pts; 
    pts.push_back(Point(1., 2., 3.)); 
    pts.push_back(Point(2., 2., 3.)); 
    pts.push_back(Point(1., 3., 3.)); 
    pts.push_back(Point(4., 2., 3.));  

    //create a delaunay triangulation 
    Delaunay dt; 
    dt.insert(pts.begin(), pts.end()); 

    //iterate through the faces 
    Delaunay::Finite_faces_iterator it; 
    for (it = dt.finite_faces_begin(); it != dt.finite_faces_end(); it++) 
    { 
     //What do I do here?? 
    } 

    return 0; 
} 

Answer 1

Aquí se muestra un ejemplo de Google. Finite_faces_iterator fue typedefed.

Interval_skip_list isl; 
    for(Finite_faces_iterator fh = dt.finite_faces_begin(); 
     fh != dt.finite_faces_end(); 
     ++fh){ 
    isl.insert(Interval(fh)); 
    } 
    std::list<Interval> level; 
    isl.find_intervals(50, std::back_inserter(level)); 
    for(std::list<Interval>::iterator it = level.begin(); 
     it != level.end(); 
     ++it){ 
    std::cout << dt.triangle(it->face_handle()) << std::endl; 
    } 

Esto no hace lo que quiere, pero le da un ejemplo de lo que se puede hacer con un iterador.

Answer 2

Si quieres un ejemplo muy extendido de la forma de hacer exactamente lo que quiere, echar un vistazo a la fuente de las herramientas paisaje X-Plane desde aquí: http://scenery.x-plane.com/code.php

Por ejemplo extendido, me refiero a un par de cientos de miles de líneas, pero hay usos de casi todo lo que CGAL puede hacer con las triangulaciones de Delaunay y los atributos extendidos allí.

Answer 3

Puede usar Delaunay::triangle para convertir desde una cara (iterador) al triángulo correspondiente. Esto se probó bajo CGAL 3,8:

// points.cin contains point pairs, e.g., 
// 3 5 
// 0 0 
// 1 9 
// ... 
#include <CGAL/Exact_predicates_exact_constructions_kernel.h> 
#include <CGAL/Delaunay_triangulation_2.h> 
#include <fstream> 

typedef CGAL::Exact_predicates_exact_constructions_kernel K; 
typedef CGAL::Delaunay_triangulation_2<K> Delaunay; 
typedef K::Point_2 Point; 

int main() 
{ 
    std::ifstream in("points.cin"); 
    std::istream_iterator<Point> begin(in); 
    std::istream_iterator<Point> end; 

    Delaunay dt; 
    dt.insert(begin, end); 

    Delaunay::Finite_faces_iterator it; 
    for (it = dt.finite_faces_begin(); it != dt.finite_faces_end(); it++) 
    { 
    std::cout << dt.triangle(it) << std::endl; 
    } 

    return 0; 
} 

Answer 4

Un vértice de un triángulo se puede acceder usando dt.triangle (it) [idx], donde que es un iterador de caras y idx es el número de vértices (0 ,1 o 2). En el siguiente ejemplo, un vértice es un objeto Point_2, se puede acceder a sus coordenadas cartesianas usando los métodos x() y y().

#include <CGAL/Exact_predicates_inexact_constructions_kernel.h> 
#include <CGAL/Triangulation_euclidean_traits_2.h> 
#include <CGAL/Delaunay_triangulation_2.h> 

typedef CGAL::Exact_predicates_inexact_constructions_kernel K; 
typedef CGAL::Triangulation_euclidean_traits_2<K> Gt; 
typedef CGAL::Delaunay_triangulation_2<Gt> Delaunay; 

typedef K::Point_2 Point_2; 
typedef std::vector<Point_2> Points; 

int main() 
{ 
    Points points; 
    points.push_back(Point_2(0,0)); 
    points.push_back(Point_2(0,7)); 
    points.push_back(Point_2(7,0)); 
    points.push_back(Point_2(7,7)); 

    Delaunay dt(points.begin(), points.end()); 

    // Print Cartesian coordinates of vertices of triangles in 2D Delaunay triangulation 
    for (Delaunay::Finite_faces_iterator it = dt.finite_faces_begin(); it != dt.finite_faces_end(); it++) 
    { 
     std::cout << " " << dt.triangle(it)[0].x() << " " << dt.triangle(it)[0].y() << " "; 
     std::cout << " " << dt.triangle(it)[1].x() << " " << dt.triangle(it)[1].y() << " "; 
     std::cout << " " << dt.triangle(it)[2].x() << " " << dt.triangle(it)[2].y() << " "; 
     std::cout << std::endl << "-------------------" << std::endl; 
    } 
    return 0; 
} 

Answer 5

Bueno, yo sólo tenía un problema similar en el que hizo un gran trabajo de investigación (sobre todo porque no tenía ningún conocimiento de C++). Quería poder imprimir triángulos por su representación entera de vértice. Aquí es como se ve:

#include <CGAL/Surface_mesh_default_triangulation_3.h> 
#include <CGAL/Complex_2_in_triangulation_3.h> 
#include <CGAL/make_surface_mesh.h> 
#include <CGAL/Implicit_surface_3.h> 

// This is the file where you can look for an example of iterating, geting basic vertex positions, outputing triangles 
// #include <CGAL/IO/Complex_2_in_triangulation_3_file_writer.h> 

// default triangulation for Surface_mesher 
typedef CGAL::Surface_mesh_default_triangulation_3 Tr; 

// c2t3 
typedef CGAL::Complex_2_in_triangulation_3<Tr> C2t3; 

typedef Tr::Geom_traits GT; 
typedef GT::Sphere_3 Sphere_3; 
typedef GT::Point_3 Point_3; 
typedef GT::FT FT; 

typedef FT (*Function)(Point_3); 

typedef CGAL::Implicit_surface_3<GT, Function> Surface_3; 

// This already have been defined 
//typedef typename C2t3::Triangulation Tr; 
typedef typename Tr::Vertex_handle Vertex_handle; 
typedef typename Tr::Finite_vertices_iterator Finite_vertices_iterator; 
typedef typename Tr::Finite_facets_iterator Finite_facets_iterator; 

typedef typename Tr::Point Point; 


FT sphere_function (Point_3 p) { 
    const FT x = p.x(); 
    const FT y = p.y(); 
    const FT z = p.z(); 

    //const FT x2=p.x()*p.x(), y2=p.y()*p.y(), z2=p.z()*p.z(); 
    const FT a = 2; 
    const FT b = 1; 
    const FT c = 1.5; 
    return x*x/a/a + y*y/b/b + z*z/c/c -1; 
} 

int main() { 
    Tr tr;   // 3D-Delaunay triangulation 
    C2t3 c2t3 (tr); // 2D-complex in 3D-Delaunay triangulation 

    // defining the surface 
    Surface_3 surface(sphere_function,    // pointer to function 
        Sphere_3(CGAL::ORIGIN, 2.)); // bounding sphere 
    // Note that "2." above is the *squared* radius of the bounding sphere! 

    // defining meshing criteria 
    CGAL::Surface_mesh_default_criteria_3<Tr> criteria(30., // angular bound 
                0.1, // radius bound 
                0.1); // distance bound 
    // meshing surface 
    CGAL::make_surface_mesh(c2t3, surface, criteria, CGAL::Non_manifold_tag()); 

    std::cout << "Final number of points: " << tr.number_of_vertices() << "\n"; 

    // Here should be the main code 

    Tr& tr2 = c2t3.triangulation(); 

    std::map<Vertex_handle, int> V; 
    int inum = 0; 
    Finite_vertices_iterator vit = tr2.finite_vertices_begin(); 
    while(vit != tr2.finite_vertices_end()) { 

    // making an integer representation of vertex pointers 
    V[vit] = inum++; 

    // obtaining vertex positions from vertex pointer vit 
    Point p = static_cast<Point>(vit->point()); 
    std::cout << p.x() << " " << p.y() << " " << p.z() << std::endl; 

    ++vit; 
    } 

    Finite_facets_iterator fit = tr2.finite_facets_begin(); 

    while (fit != tr2.finite_facets_end()) { 

    typename Tr::Cell_handle cell = fit->first; 
    const int& index = fit->second; 

    int index1 = V[cell->vertex(tr.vertex_triple_index(index, 0))]; 
    int index2 = V[cell->vertex(tr.vertex_triple_index(index, 1))]; 
    int index3 = V[cell->vertex(tr.vertex_triple_index(index, 2))]; 

    std::cout << index1 << " " << index2 << " " << index3 << std::endl; 
    ++fit; 
    } 

} 

compilar con (si es mesh_implicit_function fuente, archivo de objeto y ejecutable):

c++ -DCGAL_USE_GMP -DCGAL_USE_MPFR -DCGAL_USE_ZLIB -frounding-math -o mesh_an_implicit_function.cpp.o -c mesh_an_implicit_function.cpp 
c++ mesh_an_implicit_function.cpp.o -o mesh_an_implicit_function -lmpfr -lgmp -lCGAL -lboost_thread