src/MEDMEM/INTERPOLATION/MEDMEM_WrapperNodes.hxx

   1
   2 #ifndef MEDMEM_WRAPPER_NODES_HXX
   3 #define MEDMEM_WRAPPER_NODES_HXX
   4
   5 #ifndef NULL
   6 #define NULL 0
   7 #endif
   8
   9 //////////////////////////////////////////////////////////////////
  10 ///                                                            ///
  11 ///                        DECLARATIONS                        ///
  12 ///                                                            ///
  13 //////////////////////////////////////////////////////////////////
  14
  15 /*********************************************************/
  16 /*                                                       */
  17 /*                Classe Wrapper_Noeud                   */
  18 /*                                                       */
  19 /*********************************************************/
  20
  21 template <int DIMENSION> class Wrapper_Noeud
  22 {
  23 protected :
  24         double * coordonnees;
  25 public :
  26         Wrapper_Noeud():coordonnees(NULL)
  27                 {
  28                 }
  29         Wrapper_Noeud(double * coord):coordonnees(coord)
  30                 {
  31                 }
  32         ~Wrapper_Noeud()
  33                 {
  34                 }
  35         void positionne(double *place)
  36                 {
  37                 coordonnees=place;
  38                 }
  39         const double & operator[] (int i) const
  40                 {
  41                 return coordonnees[i];
  42                 }
  43         double operator[] (int i)
  44                 {
  45                 return coordonnees[i];
  46                 }
  47         friend double DistanceInf(const Wrapper_Noeud<DIMENSION> &A,const Wrapper_Noeud<DIMENSION> &B)
  48                 {
  49                 double max=0;
  50                 double tmp;
  51                 for (int i=0;i<DIMENSION;i++)
  52                         {
  53                         tmp=fabs(A[i]-B[i]);
  54                         if (tmp>max) max=tmp;
  55                         }
  56                 return max;
  57                 }
  58         friend double DistanceL2(const Wrapper_Noeud<DIMENSION> &A,const Wrapper_Noeud<DIMENSION> &B)
  59                 {
  60                 double tmp,somme=0;
  61                 for (int i=0;i<DIMENSION;i++)
  62                         {
  63                         tmp=(A[i]-B[i]);
  64                         somme+=tmp*tmp;
  65                         }
  66                 return sqrt(somme);
  67                 }
  68         friend int operator==(const Wrapper_Noeud<DIMENSION> &A,const Wrapper_Noeud<DIMENSION> &B)
  69                 {
  70                 for (int i=0;i<DIMENSION;i++) if (A[i]!=B[i]) return 1;
  71                 return 0;
  72                 }
  73         friend ostream & operator<<(ostream &os,const Wrapper_Noeud<DIMENSION> &A)
  74                 {
  75                 os<<"( "<<flush;
  76                 for (int i=0;i<DIMENSION;i++) os<<A[i]<<" "<<flush;
  77                 os<<")"<<flush;
  78                 return os;
  79                 }
  80         };
  81
  82 /*********************************************************/
  83 /*                                                       */
  84 /*             Classe Nuage_Wrapper_Noeud                */
  85 /*                                                       */
  86 /*********************************************************/
  87
  88
  89 template <int DIMENSION> class Wrapper_Nuage_Noeud
  90         {
  91         protected :
  92                 int nbr_noeuds;
  93                 double * noeuds;
  94                 Wrapper_Noeud<DIMENSION> show;
  95         public :
  96                 Wrapper_Nuage_Noeud():nbr_noeuds(0),noeuds(NULL) {}
  97                 Wrapper_Nuage_Noeud(int nn, double *n):nbr_noeuds(nn),noeuds(n),show(noeuds) {}
  98                 ~Wrapper_Nuage_Noeud() {}
  99                 Wrapper_Noeud<DIMENSION> & operator [] (int i)
 100                         {
 101                         show.positionne((double *) &noeuds[DIMENSION*i]);
 102                         return show;
 103                         }
 104                 int size() const {return nbr_noeuds;}
 105                 int SIZE() const {return nbr_noeuds;}
 106                 void affiche()
 107                         {
 108                         int i,j;
 109                         for (i=0;i<nbr_noeuds;i++)
 110                                 {
 111                                 cout<<"Noeud "<<i<<" : "<<flush;
 112                                 for (j=0;j<DIMENSION;j++) cout<<noeuds[i*DIMENSION+j]<<" "<<flush;
 113                                 cout<<endl;
 114                                 }
 115                         }
 116         };
 117
 118
 119 #endif