Wie wiederhole ich über Gesichter in CGAL

Question

Ich versuche, CGAL zu verwenden, um einige Delaunay Triangulation zu tun. Ich habe eines der CGAL-Samples verwendet, um eine Triangulation zu berechnen, die ein Höhenfeldattribut enthält.

Das Problem, das ich habe, ist, dass ich keine Ahnung habe, wie man die resultierende Triangulation erhält. Ich habe herausgefunden, wie man den facebook_iterator bekommt, aber ich weiß nicht, was ich von da an machen soll. Was ich mir erhoffe ist ein Index in die Punktmatrix für jeden der 3 Punkte auf jedem Dreieck.

Ich habe Probleme durch alle verschachtelten Vorlagen waten:

#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

Hier ist ein Beispiel von Google. Finite_faces_iterator wurde 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; 
    } 

Dies tut nicht was Sie wollen, aber gibt Ihnen ein Beispiel dafür, was mit einem Iterator gemacht werden kann.

Answer 2

Wenn Sie ein wirklich erweiterten Beispiel wollen, wie genau das zu tun, was Sie wollen, werfen Sie einen Blick auf die Quelle zu den X-Plane Landschaft Tools von hier: http://scenery.x-plane.com/code.php

Durch erweiterte Beispiel, meine ich ein paar Hunderttausend Zeilen, aber es gibt fast alles, was CGAL mit Delaunay-Triangulationen und erweiterten Attributen tun kann.

Answer 3

Sie können Delaunay::triangle verwenden, um von einer Fläche (Iterator) in das entsprechende Dreieck zu konvertieren. Dies wird unter CGAL getestet 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

Ein Scheitelpunkt eines Dreiecks kann mit dt.triangle zugegriffen werden (es) [idx], wobei es eine Gesichter Iterator und idx Scheitelnummer ist (0 ,1 oder 2). Im folgenden Beispiel ist ein Scheitelpunkt ein Point_2-Objekt. Auf seine kartesischen Koordinaten kann mit den Methoden x() und y() zugegriffen werden.

#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

Nun, ich hatte gerade ein ähnliches Problem, wo ich viel recherchiert habe (hauptsächlich weil ich keine Ahnung von C++ hatte). Ich wollte in der Lage sein, Dreiecke nach ihrer Integer-Repräsentation zu drucken. Hier ist es, wie es aussieht:

#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; 
    } 

} 

kompilieren es mit (wenn mesh_implicit_function Quelle, Objektdatei und ausführbar):

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