/home/ann2.ext/paccaulf/projsem2/ContourActif/lib/enriched_polyhedron.h

Aller à la documentation de ce fichier.

//                                                                       //
//  Class: Enriched_polyhedron                                           //
//                                                                       //

#ifndef _ENRICHED_POLYHEDRON_H
#define _ENRICHED_POLYHEDRON_H

// CGAL stuff
#include <CGAL/Cartesian.h>
#include <CGAL/HalfedgeDS_vector.h>
#include <CGAL/Polyhedron_3.h>

// STL stuff
#include <list>

template <class kernel, class items>
class Enriched_polyhedron : public CGAL::Polyhedron_3<kernel,items,CGAL::HalfedgeDS_vector>
{
public :
  typedef typename kernel::FT FT;
  typedef typename kernel::Point_3 Point;
  typedef typename kernel::Vector_3 Vector;

  typedef typename CGAL::Polyhedron_3<kernel,items,CGAL::HalfedgeDS_vector> base;
  typedef typename base::Facet Facet;
  typedef typename base::Vertex Vertex;
  typedef typename base::Facet_handle Facet_handle;
  typedef typename base::Vertex_handle Vertex_handle;
  typedef typename base::Halfedge_handle Halfedge_handle;
  typedef typename base::Facet_iterator Facet_iterator;
  typedef typename base::Halfedge_iterator Halfedge_iterator;
  typedef typename base::Vertex_iterator Vertex_iterator;
  typedef typename base::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator;
  typedef typename base::Halfedge_around_facet_circulator  Halfedge_around_facet_circulator;

public :

// life cycle
Enriched_polyhedron() 
{
};
virtual ~Enriched_polyhedron() 
{
};


// normals (per facet, then per vertex)
void compute_normals_per_facet()
{
        for(Facet_iterator pFacet = facets_begin(); pFacet  != facets_end(); pFacet++)
                compute_facet_normal(pFacet);
};
void compute_normals_per_vertex()
{
        for(Vertex_iterator pVertex = vertices_begin(); pVertex != vertices_end(); pVertex++)
                compute_vertex_normal(pVertex);
};
void compute_normals()
{
        compute_normals_per_facet();
        compute_normals_per_vertex();
};


// set index for all vertices
void set_index_vertices()
{
        long index = 0;
        for(Vertex_iterator pVertex = vertices_begin(); pVertex != vertices_end(); pVertex++)
                pVertex->tag(index++);
};

// set index for all edges
void set_index_edges()
{
        long index = 0;
        for(Halfedge_iterator pHalfedge = halfedges_begin(); pHalfedge != halfedges_end(); pHalfedge++)
                pHalfedge->tag(-1);
        for(Halfedge_iterator pHalfedge = halfedges_begin(); pHalfedge != halfedges_end(); pHalfedge++)
        {
                if(pHalfedge->opposite()->tag() == -1) pHalfedge->tag(index);
                else pHalfedge->tag(pHalfedge->opposite()->tag());
                index++;
        }
};

void compute_facet_normal(Facet_handle pFacet)
{
        typename Facet::Normal_3 sum = CGAL::NULL_VECTOR;
        typename Facet::Halfedge_around_facet_circulator h = pFacet->facet_begin();
        do {
                typename Facet::Normal_3 normal = CGAL::cross_product(
                        h->next()->vertex()->point() - h->vertex()->point(),
                        h->next()->next()->vertex()->point() - h->next()->vertex()->point());
                double sqnorm = normal * normal;
                if(sqnorm != 0)
                normal = normal / (float)std::sqrt(sqnorm);
                sum = sum + normal;
        } while(++h != pFacet->facet_begin());

        float sqnorm = sum * sum;
        if(sqnorm != 0.0)
                pFacet->normal() = sum / std::sqrt(sqnorm);
        else
        {
                pFacet->normal() = CGAL::NULL_VECTOR;
                std::cout << "degenerate face" << std::endl;
        }
};

void compute_vertex_normal(Vertex_handle pVertex)
{
        typename Vertex::Normal_3 normal = CGAL::NULL_VECTOR;
        typename Vertex::Halfedge_around_vertex_circulator pHalfedge = pVertex->vertex_begin();
        typename Vertex::Halfedge_around_vertex_circulator begin = pHalfedge;
        CGAL_For_all(pHalfedge,begin) 
                if(!pHalfedge->is_border())
                normal = normal + pHalfedge->facet()->normal();
        float sqnorm = normal * normal;
        if(sqnorm != 0.0f)
                pVertex->normal() = normal / (float)std::sqrt(sqnorm);
        else
                pVertex->normal() = CGAL::NULL_VECTOR;
};

};


#endif

---