/home/ann2.ext/paccaulf/projsem2/ContourActif/region.h

Aller à la documentation de ce fichier.

#ifndef REGION_H 
#define REGION_H 

#include <assert.h>
#include <vector>


#include <CGAL/Filtered_kernel.h>
#include <CGAL/Intersections.h>


#include "lib/enriched_polyhedron.h"
#include "lib/enriched_kernel.h"
#include "lib/enriched_items.h"


 class Region
{
public:
        typedef Enriched_polyhedron<Enriched_kernel,Enriched_items> Polyhedron ;
        typedef Polyhedron::Vertex Vertex;
        typedef Polyhedron::Vertex_handle Vertex_handle;
        typedef Polyhedron::Vector Vector;
        typedef Polyhedron::Point Point;
        typedef Polyhedron::Facet_handle Facet_handle;
        typedef Polyhedron::Halfedge_handle Halfedge_handle; 
        typedef Polyhedron::Halfedge Halfedge;
        
        typedef Polyhedron::Vertex_iterator Vertex_iterator;
        
        typedef Polyhedron::Edge_iterator Edge_iterator;
        
        typedef Polyhedron::Halfedge_iterator Halfedge_iterator;
        
        typedef Polyhedron::Facet_iterator Facet_iterator;
        
        typedef Polyhedron::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator;
        typedef Polyhedron::Halfedge_around_vertex_const_circulator Halfedge_around_vertex_const_circulator;
        
        typedef Polyhedron::Halfedge_around_facet_circulator Halfedge_around_facet_circulator;
        
/*
        typedef Polyhedron::Line_2 Line_2 ;
        typedef Polyhedron::Point_2  Point_2 ;
        */
        typedef CGAL::Line_2<Enriched_kernel> Line_2 ;
        typedef CGAL::Point_2<Enriched_kernel>  Point_2 ;

private:
        Polyhedron _mesh3D; // notre region locale 3D (obtenue a partir des fonctions de florents)
        
        bool _is_valid;

        Polyhedron _mesh2D;
        
        bool _is_valid2;
        
public:
                // Constructeurs et destructeur
                
                Region() :_mesh3D(), _is_valid(false) {}; 
        
        Region(Polyhedron _mesh) : 
                _mesh3D(_mesh), 
                _is_valid(!_mesh3D.is_closed()), 
                _mesh2D(_mesh), 
                _is_valid2(!_mesh2D.is_closed()) 
          {} ;
        
        ~Region(){ }
        
        
        bool valide3D() { return _is_valid; }
        
        bool valide2D() { return _is_valid2; }
        
        Polyhedron* mesh3D () { return &_mesh3D ; }
        
        Polyhedron* mesh2D () { return &_mesh2D ; }

        // methode qui retourne vrai ssi le sommet passe en param est un sommet de la region local 2D
        bool Un_Sommet_de_la_mesh2D(Vertex_handle pV)
          {
                for(Vertex_iterator pVertex = _mesh2D.vertices_begin(); pVertex != _mesh2D.vertices_end(); pVertex++)
                  {
                        if (pV == pVertex ) return true;
                  }
                
                return false;
          }
        
        // methode qui retourne vrai ssi le sommet passe en param est un sommet de la region local 3D
        bool Un_Sommet_de_la_mesh3D(Vertex_handle pV)
        {
                for(Vertex_iterator pVertex = _mesh3D.vertices_begin(); pVertex != _mesh3D.vertices_end(); pVertex++)
                {
                        if (pV == pVertex ) return true;
                }
                
                return false;
        }
        
        
private: // pour que l'user n'est pas acces a ces methodes      
                
                double Compute_nrj_sommet_sur_mesh (Vertex_handle pV);
    
        
        
        double Compute_nrj_sommet (Vertex_handle pV) ;
    
        
public:
                
                double Nrj_sommet (Vertex_handle pV) 
          {
                        if (Un_Sommet_de_la_mesh2D(pV)) 
                                return Compute_nrj_sommet_sur_mesh (pV);
                        else 
                                return Compute_nrj_sommet(pV);
                        
          }
        
        
        void Compute_Parameterization() ;

        bool isEdge(int i, int j) ;
        
        bool isBorderVertex(Vertex_handle vh) ;

        void Trace2file(char* filename) ;
        
        // Methode qui renvoie un vertexhandle sur un point 2D a partir d'un vertex handle sur 
        // un point 3D
        void vh2Dfrom3D (Vertex_handle& vh) ;
        
        // Methode qui renvoie un vertexhandle sur un point 3D a partir d'un vertex handle sur 
        // un point 2D
    void vh3Dfrom2D(Vertex_handle& vh) ;
        
        bool Appartient_facet(Facet_handle pF, Point p)
        {
                Point_2 pp=Point_2(p[0], p[1]) ;
                
                Halfedge_around_facet_circulator h = pF->facet_begin(); 
                
                if (CGAL::circulator_size(h)!=3) { std::cout << "ERROR in Compute_nrj_sommet: facet must be triangle" << std::endl;  exit(-1);  }
                
                Point p1=h->vertex()->point();
                Point_2 pp1(p1[0], p1[1]) ;
                h++;
                Point p2=h->vertex()->point();
                Point_2 pp2(p2[0], p2[1]) ;
                h++;
                Point p3=h->vertex()->point();
                Point_2 pp3(p3[0], p3[1]) ;
                
                Point_2 ipoint ;
                Line_2 iline ;
                CGAL::Object result = intersection(Line_2(pp1,pp),Line_2(pp2,pp3)) ;
                if (CGAL::assign(ipoint, result))
                {
                        if( are_ordered_along_line( pp2 , ipoint , pp3) ) 
                                return true;
                } else
                        if (CGAL::assign(iline, result))
                        {
                                std::cout << "result ligne" << std::endl ;                              
                                return false;                   
                        } else
                        {
                                std::cout << "result pas d inters" << std::endl ;                               
                                return false;                   
                        }
                
                return false;
                        
        }

        // Methode utiliser pour determiner un point 3D du snake
        // a partir d'un point 2D du snake
        void Point3D_from_2D(Point& p);
        
};

#endif

---