Создайте поверхностную сетку с помощью Делоне CGAL в трехмерном пространстве с точками в качестве входных данных.

Я хочу создать поверхностную сетку с использованием CGAL Delaunay в трехмерном пространстве с точками в качестве входных данных.

Прямо сейчас у меня есть рабочая версия 3D Delaunay от CGAL, но теперь я хочу вернуть только поверхность из этого результата. Я нашел это:

Surface_mesh_complex
// test vector
std::vector<glm::vec3> l_Vec = { glm::vec3( -10,-10,-10 ), glm::vec3( -10,-10,10 ),glm::vec3( -10,10,-10 ),glm::vec3( -10,10,10 ),glm::vec3( 0,0,0 ), glm::vec3( 10,-10,-10 ), glm::vec3( 10,-10,10 ),glm::vec3( 10,10,-10 ),glm::vec3( 10,10,10 ) };
clsDelaunay3D l_Delaunay;
l_Delaunay.Triangulate( l_Vec );
SurfaceMesh sm( l_Delaunay.GetTriangulation( ) );
// what to do next?
in_triangulation_3<Delaunay>

Предположительно, я мог бы ввести свой задержанный результат в вышеупомянутый конструктор Surface Mesh, но я не знаю, куда двигаться дальше.

Я также читал о реконструкции поверхности Пуассона, но я хочу, чтобы мои точки ввода также присутствовали в моем выводе; Мне просто нужны треугольники из результата делоне.

main.cpp

// test vector
std::vector<glm::vec3> l_Vec = { glm::vec3( -10,-10,-10 ), glm::vec3( -10,-10,10 ),glm::vec3( -10,10,-10 ),glm::vec3( -10,10,10 ),glm::vec3( 0,0,0 ), glm::vec3( 10,-10,-10 ), glm::vec3( 10,-10,10 ),glm::vec3( 10,10,-10 ),glm::vec3( 10,10,10 ) };
clsDelaunay3D l_Delaunay;
l_Delaunay.Triangulate( l_Vec );
SurfaceMesh sm( l_Delaunay.GetTriangulation( ) );
// what to do next?

clsDelaunay3D.h

#pragma once
#include "stdafx_CGAL.h"
#include "stdafx.h"

namespace GenerationLib
{
template<class GT, class Vb = CGAL::Triangulation_vertex_base_3<GT>>
class My_vertex_base : public Vb
{
public:
    typedef typename Vb::Vertex_handle  Vertex_handle;
    typedef typename Vb::Point          Point;
    typedef typename Vb::Cell_handle    Cell_handle;

    template<class TDS2>
    struct Rebind_TDS
    {
        typedef typename Vb::template Rebind_TDS<TDS2>::Other   Vb2;
        typedef My_vertex_base<GT, Vb2>                         Other;
    };

    My_vertex_base( )
    {
    }

    My_vertex_base( const Point&p ) : Vb( p )
    {
    }

    My_vertex_base( const Point&p, Cell_handle c ) : Vb( p, c )
    {
    }

    Vertex_handle vh;
    Cell_handle ch;
};

typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef CGAL::Triangulation_data_structure_3<My_vertex_base<K>> Tds;
typedef CGAL::Delaunay_triangulation_3<K, Tds> Delaunay;
typedef Delaunay::Vertex_handle Vertex_handle;
typedef Delaunay::Point Point;

typedef CGAL::Surface_mesh_complex_2_in_triangulation_3<Delaunay> SurfaceMesh;

class clsDelaunay3D
{
public:
    clsDelaunay3D( );
    ~clsDelaunay3D( );
    void Init( );
    void AddPoint( glm::vec3 Position );
    void Triangulate( std::vector<glm::vec3> Points );
    Delaunay::All_vertices_iterator GetAllVerticesIteratorBegin( );
    Delaunay::All_vertices_iterator GetAllVerticesIteratorEnd( );
    Delaunay::Finite_vertices_iterator GetOuterVerticesIteratorBegin( );
    Delaunay::Finite_vertices_iterator GetOuterVerticesIteratorEnd( );

    Delaunay::All_edges_iterator GetAllEdgesIteratorBegin( );
    Delaunay::All_edges_iterator GetAllEdgesIteratorEnd( );
    Delaunay::Finite_edges_iterator GetOuterEdgesIteratorBegin( );
    Delaunay::Finite_edges_iterator GetOuterEdgesIteratorEnd( );

    Delaunay::All_facets_iterator GetAllFacetsIteratorBegin( );
    Delaunay::All_facets_iterator GetAllFacetsIteratorEnd( );
    Delaunay::Finite_facets_iterator GetOuterFacetsIteratorBegin( );
    Delaunay::Finite_facets_iterator GetOuterFacetsIteratorEnd( );

    Delaunay::All_cells_iterator GetAllCellsIteratorBegin( );
    Delaunay::All_cells_iterator GetAllCellsIteratorEnd( );
    Delaunay::Finite_cells_iterator GetOuterCellsIteratorBegin( );
    Delaunay::Finite_cells_iterator GetOuterCellsIteratorEnd( );

    Delaunay GetTriangulation( );

    void Destroy( );
private:
    Delaunay m_Triangulation;
};
}

clsDelaunay3D.cpp

#pragma once
#include "stdafx_CGAL.h"
#include "stdafx.h"
#include "clsDelaunay3D.h"

namespace GenerationLib
{
clsDelaunay3D::clsDelaunay3D( )
{

}

clsDelaunay3D::~clsDelaunay3D( )
{

}

void clsDelaunay3D::Init( )
{

}

void clsDelaunay3D::AddPoint( glm::vec3 a_Position )
{
    Vertex_handle vertex = m_Triangulation.insert( Point( a_Position.x, a_Position.y, a_Position.z ) );
}

void clsDelaunay3D::Triangulate( std::vector<glm::vec3> a_Points )
{
    std::vector<Point> l_DelPoints;
    for (unsigned int i = 0; i < a_Points.size( ); ++i)
    {
        l_DelPoints.push_back( Point( a_Points[ i ].x, a_Points[ i ].y, a_Points[ i ].z ) );
    }
    m_Triangulation.insert( l_DelPoints.begin( ), l_DelPoints.end( ) );
}

Delaunay::All_vertices_iterator clsDelaunay3D::GetAllVerticesIteratorBegin( )
{
    return m_Triangulation.all_vertices_begin( );
}

Delaunay::All_vertices_iterator clsDelaunay3D::GetAllVerticesIteratorEnd( )
{
    return m_Triangulation.all_vertices_end( );
}

Delaunay::Finite_vertices_iterator clsDelaunay3D::GetOuterVerticesIteratorBegin( )
{
    return m_Triangulation.finite_vertices_begin( );
}

Delaunay::Finite_vertices_iterator clsDelaunay3D::GetOuterVerticesIteratorEnd( )
{
    return m_Triangulation.finite_vertices_end( );
}

Delaunay::All_edges_iterator clsDelaunay3D::GetAllEdgesIteratorBegin( )
{
    return m_Triangulation.all_edges_begin( );
}

Delaunay::All_edges_iterator clsDelaunay3D::GetAllEdgesIteratorEnd( )
{
    return m_Triangulation.all_edges_end( );
}

Delaunay::Finite_edges_iterator clsDelaunay3D::GetOuterEdgesIteratorBegin( )
{
    return m_Triangulation.finite_edges_begin( );
}

Delaunay::Finite_edges_iterator clsDelaunay3D::GetOuterEdgesIteratorEnd( )
{
    return m_Triangulation.finite_edges_end( );
}

Delaunay::All_facets_iterator clsDelaunay3D::GetAllFacetsIteratorBegin( )
{
    return m_Triangulation.all_facets_begin( );
}

Delaunay::All_facets_iterator clsDelaunay3D::GetAllFacetsIteratorEnd( )
{
    return m_Triangulation.all_facets_end( );
}

Delaunay::Finite_facets_iterator clsDelaunay3D::GetOuterFacetsIteratorBegin( )
{
    return m_Triangulation.finite_facets_begin( );
}

Delaunay::Finite_facets_iterator clsDelaunay3D::GetOuterFacetsIteratorEnd( )
{
    return m_Triangulation.finite_facets_end( );
}

Delaunay::All_cells_iterator clsDelaunay3D::GetAllCellsIteratorBegin( )
{
    return m_Triangulation.all_cells_begin( );
}

Delaunay::All_cells_iterator clsDelaunay3D::GetAllCellsIteratorEnd( )
{
    return m_Triangulation.all_cells_end( );
}

Delaunay::Finite_cells_iterator clsDelaunay3D::GetOuterCellsIteratorBegin( )
{
    return m_Triangulation.finite_cells_begin( );
}

Delaunay::Finite_cells_iterator clsDelaunay3D::GetOuterCellsIteratorEnd( )
{
    return m_Triangulation.finite_cells_end( );
}

Delaunay clsDelaunay3D::GetTriangulation( )
{
    return m_Triangulation;
}

void clsDelaunay3D::Destroy( )
{

}
}

Если у кого-то есть лучший способ сделать это, дайте мне знать.