Comment utiliser une classe autre qu'un point CGAL_3 pour le traitement d'un ensemble de points?

Question

J'ai un tableau de points qui a été chargé par une bibliothèque externe, Assimp, dans sa propre classe aiVector3D (qui n'a pas de fonctions d'accesseur de composant, juste un accès public aux variables membres), et je veux traiter ces points en utilisant la bibliothèque de CGAL pour la bibliothèque. Comme j'ai des dizaines de millions de ces points (et pourrait un jour être des milliards), je ne veux pas créer un nouveau tableau de CGAL Point_3 si je peux l'aider.

Le documentation dit:

Les utilisateurs de ce paquet peuvent utiliser d'autres types pour représenter les positions et Normales si elles mettent en œuvre les cartes de propriété correspondantes.

qui semble impliquer que je peux obtenir ce que je veux en créant une carte de propriété qui mappe aiVector3D-Point_3, mais après avoir lu les deux documents de son et Boost CGAL ce n'est pas clair pour moi comment j'aller à ce sujet.

Ai-je raison de penser que c'est la voie à suivre? Si oui, comment puis-je le faire?

Answer 1

Si oui ou non ce qui est plus ou moins efficace (pour un sens de l'efficacité), voici ce que je suis venu avec la carte aiVector3D-CGAL::Point_3 (en utilisant un noyau CGAL::Simple_cartesian<double>), y compris les transformations.

template <typename T> 
struct AItoP { 
    AItoP(const aiScene* scene, const aiNode* node) : 
      _scene(scene), 
      _node(node), 
      _mesh(0) 
    { 
     _mesh = _scene->mMeshes[node->mMeshes[0]]; 
     _xform = _node->mTransformation * _scene->mRootNode->mTransformation; 
    } 

    T operator()(const size_t& x) const { 
     aiVector3t<double> v(_mesh->mVertices[x].x, _mesh->mVertices[x].y, _mesh->mVertices[x].z); 
     v *= _xform; 

     return T(v.x, v.y, v.z); 
    } 
private: 
    const aiScene* _scene; 
    const aiNode* _node; 
    const aiMesh* _mesh; 
    aiMatrix4x4t<double> _xform; 
}; 

...

#include <boost/property_map/function_property_map.hpp> 

void my_processing_function() { 
    std::vector<std::size_t> indices(mesh->mNumVertices); 
    for(std::size_t i = 0; i < mesh->mNumVertices; ++i){ 
     indices[i] = i; 
    } 

    double cell_size = 0.05; 
    std::vector<std::size_t>::iterator end; 
    end = CGAL::grid_simplify_point_set(indices.begin(), 
      indices.end(), 
      make_function_property_map<const size_t&, Point, AItoP<Point> >(AItoP<Point>(_scene, node)), 
      cell_size); 
}