outil/src/ot_mathematique.h

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuilli�re et Vincent FRANCOIS
//  D�partement de G�nie M�canique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du d�partement
//  de g�nie m�canique de l'Universit� du Qu�bec �
//  Trois Rivi�res
//  Les librairies ne peuvent �tre utilis�es sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       ot_mathematique.h
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H23
//------------------------------------------------------------
//------------------------------------------------------------
#ifndef _OTMATHEMATIQUE_
#define _OTMATHEMATIQUE_

#ifdef WINDOWS_VERSION
#ifdef BUILT_DLL_OUTIL
#define DLLPORTOUTIL __declspec(dllexport)
#else
#define DLLPORTOUTIL __declspec(dllimport)
#endif
#else
#define DLLPORTOUTIL
#endif

#include "ot_doubleprecision.h"
#include <iostream>
#include <map>
#include <vector>


class DLLPORTOUTIL OT_HISTOGRAMME
{
public:
  OT_HISTOGRAMME(double largeur_colonne);
  ~OT_HISTOGRAMME(void);
  void ajouter_valeur(double x,double val);
  void ajouter_valeur(long i,double val);  
  double get_valeur(double x);  
  int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur,double &borne_min);
  int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur,double &borne_min);
  long get_nb_colonne(void);
  double get_x_min(void);
  double get_x_max(void);
protected:
  bool m_init;
  long m_i_min;
  long m_i_max;
  double m_largeur_colonne;
  std::map<long,double,std::less<unsigned long>> m_map_colonne;
};

class DLLPORTOUTIL OT_QUATERNION
{
public:
  OT_QUATERNION(void);
  OT_QUATERNION(double x,double y,double z,double w);
  OT_QUATERNION(OT_QUATERNION &mdd);
  double get_x(void);
  void change_x(double x);
  double get_y(void);
  void change_y(double y);
  double get_z(void);
  void change_z(double z);
  double get_w(void);
  void change_w(double w);
  
  OT_QUATERNION& operator=(OT_QUATERNION& mdd);
  
protected:
  double valeur[4];
};


class DLLPORTOUTIL OT_VECTEUR_3D
{
public :
    // construction
    OT_VECTEUR_3D(double x,double y,double z);
    OT_VECTEUR_3D(double *xyz);
    OT_VECTEUR_3D(double *xyz1,double *xyz2);
    OT_VECTEUR_3D(void);
    OT_VECTEUR_3D(const OT_VECTEUR_3D& mdd);
    OT_VECTEUR_3D unite(int i);
    // stream string output
    friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);

    // comparison
    bool operator== (const OT_VECTEUR_3D& mdd) const;
    bool operator!= (const OT_VECTEUR_3D& mdd) const;
    bool operator<  (const OT_VECTEUR_3D& mdd) const;
    bool operator<= (const OT_VECTEUR_3D& mdd) const;
    bool operator>  (const OT_VECTEUR_3D& mdd) const;
    bool operator>= (const OT_VECTEUR_3D& mdd) const;
    int compare_valeur (const OT_VECTEUR_3D& mdd) const;

    // coordinate access
    virtual double get_x(void) const ;
    virtual double get_y(void) const ;
    virtual double get_z(void) const ;
    virtual void change_x(double x);
    virtual void change_y(double y);
    virtual void change_z(double z);
    virtual double* get_xyz(void);

    operator const double* () const;
    operator double* ();
    double operator[] (int i) const;
    double& operator[] (int i);
    double operator() (int i) const;
    double & operator() (int i);

// arithmetic operations
    friend OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
    friend OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
    friend double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
    friend OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
    friend OT_VECTEUR_3D operator*(const class OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
    friend OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
    friend OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
    friend OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);

    // arithmetic updates
    OT_VECTEUR_3D& operator+= (const OT_VECTEUR_3D& rkV);
    OT_VECTEUR_3D& operator-= (const OT_VECTEUR_3D& rkV);
    OT_VECTEUR_3D& operator*= (double fScalar);
    OT_VECTEUR_3D& operator/= (double fScalar);

    // vector operations
    virtual double get_longueur(void) const ;
    virtual double get_longueur2(void) const ;
    virtual void norme(void);
    OT_VECTEUR_3D gram_shmidt(const OT_VECTEUR_3D& vint);
    virtual double diff(void);


private:
    double valeur[3];
};

class DLLPORTOUTIL OT_MATRICE_3D
{
public:
    OT_MATRICE_3D(OT_VECTEUR_3D& v1,OT_VECTEUR_3D& v2,OT_VECTEUR_3D& v3);
    OT_MATRICE_3D(void);
    OT_MATRICE_3D(double* t);
    OT_MATRICE_3D(const OT_MATRICE_3D& mdd);

    // stream string output
    friend std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);

    // access to matrix elements
    double operator() (int iLigne, int iCol) const;
    double & operator() (int iLigne, int iCol);
    double valeur(int iLigne, int iCol) const;
    double & valeur(int iLigne, int iCol);
    OT_VECTEUR_3D& get_vecteur1(void);
    OT_VECTEUR_3D& get_vecteur2(void);
    OT_VECTEUR_3D& get_vecteur3(void);
    void change_vecteur1(OT_VECTEUR_3D v);
    void change_vecteur2(OT_VECTEUR_3D v);
    void change_vecteur3(OT_VECTEUR_3D v);
    OT_VECTEUR_3D & operator [](int i);
    // return inverse matrix
    OT_MATRICE_3D inverse() const;
    // assignements methods
    void identite(void);
    double get_determinant();
    void transpose(OT_MATRICE_3D& res) const;
    OT_MATRICE_3D transpose() const;
    friend OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);

private:
    OT_VECTEUR_3D vec[3]; // attention ! vecteurs colonne
    friend OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
};

DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
DLLPORTOUTIL OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
DLLPORTOUTIL OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
DLLPORTOUTIL double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
DLLPORTOUTIL OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
DLLPORTOUTIL OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
DLLPORTOUTIL OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
DLLPORTOUTIL OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
DLLPORTOUTIL OT_MATRICE_3D operator*(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
DLLPORTOUTIL OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
DLLPORTOUTIL OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);


#define ot_vecteur_4d
#ifdef ot_vecteur_4d
class DLLPORTOUTIL OT_VECTEUR_4D
{
public :
    //construction
    OT_VECTEUR_4D(double x,double y,double z,double w);
    OT_VECTEUR_4D(double *xyzw);
    OT_VECTEUR_4D(void) {};
    OT_VECTEUR_4D(const OT_VECTEUR_4D& mdd);
    OT_VECTEUR_4D & operator= (double);

    // stream string output
    friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);

    // comparison
    bool operator== (const OT_VECTEUR_4D& mdd) const;
    bool operator!= (const OT_VECTEUR_4D& mdd) const;
    bool operator<  (const OT_VECTEUR_4D& mdd) const;
    bool operator<= (const OT_VECTEUR_4D& mdd) const;
    bool operator>  (const OT_VECTEUR_4D& mdd) const;
    bool operator>= (const OT_VECTEUR_4D& mdd) const;
   // int compare_valeur (const OT_VECTEUR_4D& mdd) const;

    // coordinate access
    virtual double get_x(void) const ;
    virtual double get_y(void) const ;
    virtual double get_z(void) const ;
    virtual double get_w(void) const ;
    virtual double & x(void);
    virtual double & y(void);
    virtual double & z(void);
    virtual double & w(void);
    virtual void change_x(double x);
    virtual void change_y(double y);
    virtual void change_z(double z);
    virtual void change_w(double w);
    virtual double* get_xyzw(void);
    operator const double* () const;
    operator double* ();
    double operator[] (int i) const;
    double& operator[] (int i);
    double operator() (int i) const;
    double & operator() (int i);

// arithmetic operations
    OT_VECTEUR_4D operator+ (const OT_VECTEUR_4D& rkV);
    OT_VECTEUR_4D operator- (const OT_VECTEUR_4D& rkV);
    double operator* (const OT_VECTEUR_4D & a);

    // arithmetic updates
    OT_VECTEUR_4D& operator+= (const OT_VECTEUR_4D& rkV);
    OT_VECTEUR_4D& operator-= (const OT_VECTEUR_4D& rkV);
    OT_VECTEUR_4D& operator*= (double fScalar);
    OT_VECTEUR_4D& operator/= (double fScalar);

private:
    double valeur[4];
};

DLLPORTOUTIL OT_VECTEUR_4D operator* (const OT_VECTEUR_4D & rkV, const double a);
DLLPORTOUTIL OT_VECTEUR_4D operator* (const double a, const OT_VECTEUR_4D & rkV);
DLLPORTOUTIL OT_VECTEUR_4D operator/ (const OT_VECTEUR_4D & rkV, const double a);
DLLPORTOUTIL OT_VECTEUR_4D operator/ (const double a, const OT_VECTEUR_4D & rkV);
DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
#endif // ot_vecteur_4d


class DLLPORTOUTIL OT_VECTEUR_4DD
{
public :
    //construction
    OT_VECTEUR_4DD(double2 x,double2 y,double2 z,double2 w);
    OT_VECTEUR_4DD(double2 *xyzw);
    OT_VECTEUR_4DD() {};
    OT_VECTEUR_4DD(const OT_VECTEUR_4DD& mdd);
//OT_VECTEUR_4DD & operator= (double2);
    OT_VECTEUR_4DD & operator= (const OT_VECTEUR_4DD&);

    // stream string output
    friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);

    // comparison
    bool operator== (const OT_VECTEUR_4DD& mdd) const;
    bool operator!= (const OT_VECTEUR_4DD& mdd) const;
    bool operator<  (const OT_VECTEUR_4DD& mdd) const;
    bool operator<= (const OT_VECTEUR_4DD& mdd) const;
    bool operator>  (const OT_VECTEUR_4DD& mdd) const;
    bool operator>= (const OT_VECTEUR_4DD& mdd) const;
    int compare_valeur (const OT_VECTEUR_4DD& mdd) const;

    // coordinate access
    virtual double2 get_x(void) const ;
    virtual double2 get_y(void) const ;
    virtual double2 get_z(void) const ;
    virtual double2 get_w(void) const ;
    virtual double2 & x(void);
    virtual double2 & y(void);
    virtual double2 & z(void);
    virtual double2 & w(void);
    virtual void change_x(double2 x);
    virtual void change_y(double2 y);
    virtual void change_z(double2 z);
    virtual void change_w(double2 w);
    virtual double2* get_xyzw(void);
    double2 norme();
    OT_VECTEUR_4DD vecteur_norme() ;
    OT_VECTEUR_4DD vecteur_norme_3d() ;
    operator const double2* () const;
    operator double2* ();
    double2 operator[] (int i) const;
    double2& operator[] (int i);
    double2 operator() (int i) const;
    double2 & operator() (int i);

// arithmetic operations
    OT_VECTEUR_4DD operator+ (const OT_VECTEUR_4DD& rkV);
    OT_VECTEUR_4DD operator- (const OT_VECTEUR_4DD& rkV);
    double2 operator* (const OT_VECTEUR_4DD & a);

    // arithmetic updates
    OT_VECTEUR_4DD& operator+= (const OT_VECTEUR_4DD& rkV);
    OT_VECTEUR_4DD& operator-= (const OT_VECTEUR_4DD& rkV);
    OT_VECTEUR_4DD& operator*= (double2 fScalar);
    OT_VECTEUR_4DD& operator/= (double2 fScalar);
    OT_VECTEUR_4DD  operator^(const OT_VECTEUR_4DD& v2);
    bool est_nul(void);
    bool est_nul_3d(void);


private:
    double2 valeur[4];
};


class DLLPORTOUTIL OT_VECTEUR_3DD
{
public :
    //construction
    OT_VECTEUR_3DD(double2 x,double2 y,double2 z);
    OT_VECTEUR_3DD(double2 *xyzw); 
    OT_VECTEUR_3DD(double2 *xyz1,double2 *xyz2);
    OT_VECTEUR_3DD() {};
    OT_VECTEUR_3DD(const OT_VECTEUR_3DD& mdd);
    OT_VECTEUR_3DD & operator= (const OT_VECTEUR_3DD&);

    // stream string output
    friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3DD & __vec);

    // comparison
    bool operator== (const OT_VECTEUR_3DD& mdd) const;
    bool operator!= (const OT_VECTEUR_3DD& mdd) const;
    bool operator<  (const OT_VECTEUR_3DD& mdd) const;
    bool operator<= (const OT_VECTEUR_3DD& mdd) const;
    bool operator>  (const OT_VECTEUR_3DD& mdd) const;
    bool operator>= (const OT_VECTEUR_3DD& mdd) const;
    int compare_valeur (const OT_VECTEUR_3DD& mdd) const;

    // coordinate access
    virtual double2 get_x(void) const ;
    virtual double2 get_y(void) const ;
    virtual double2 get_z(void) const ;
    virtual double2 & x(void);
    virtual double2 & y(void);
    virtual double2 & z(void);
    virtual void change_x(double2 x);
    virtual void change_y(double2 y);
    virtual void change_z(double2 z);
    virtual double2* get_xyz(void);
    double2 norme();
    OT_VECTEUR_3DD vecteur_norme() ;
    virtual double2 get_longueur(void)  ;
    virtual double2 get_longueur2(void) ;
    operator const double2* () const;
    operator double2* ();
    double2 operator[] (int i) const;
    double2& operator[] (int i);
    double2 operator() (int i) const;
    double2 & operator() (int i);

// arithmetic operations
    OT_VECTEUR_3DD operator+ (const OT_VECTEUR_3DD& rkV);
    OT_VECTEUR_3DD operator- (const OT_VECTEUR_3DD& rkV);
    double2 operator* (const OT_VECTEUR_3DD & a);

    // arithmetic updates
    OT_VECTEUR_3DD& operator+= (const OT_VECTEUR_3DD& rkV);
    OT_VECTEUR_3DD& operator-= (const OT_VECTEUR_3DD& rkV);
    OT_VECTEUR_3DD& operator*= (double2 fScalar);
    OT_VECTEUR_3DD& operator/= (double2 fScalar);
    OT_VECTEUR_3DD  operator&(const OT_VECTEUR_3DD& v2);


private:
    double2 valeur[3];
};


DLLPORTOUTIL OT_VECTEUR_4DD operator* (const OT_VECTEUR_4DD & rkV, const double2 a);
DLLPORTOUTIL OT_VECTEUR_4DD operator* (const double2 a, const OT_VECTEUR_4DD & rkV);
DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const OT_VECTEUR_4DD & rkV, const double2 a);
DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const double2 a, const OT_VECTEUR_4DD & rkV);
DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
DLLPORTOUTIL OT_VECTEUR_3DD operator* (const OT_VECTEUR_3DD & rkV, const double2 a);
DLLPORTOUTIL OT_VECTEUR_3DD operator* (const double2 a, const OT_VECTEUR_3DD & rkV);
DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const OT_VECTEUR_3DD & rkV, const double2 a);
DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const double2 a, const OT_VECTEUR_3DD & rkV);
DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);


class DLLPORTOUTIL OPERATEUR
{
public:
      enum ETAT {EXTERIEUR=0,INTERIEUR=4,STRICTINTERIEUR=3,SUR_FACE=1,SUR_ARETE=5,FACE1=10,FACE2=11,FACE3=12,FACE4=13,ARETE1=20,ARETE2=21,ARETE3=22,ARETE4=23,ARETE5=24,ARETE6=25,SOMMET1=30,SOMMET2=31,SOMMET3=32,SOMMET4=33};

    static int egal(double a,double b,double eps);
    static int egal(double *xyz1,double *xyz2,double eps);
    static double qualite_triangle(double* noeud1,double* noeud2,double* noeud3);
    static double  qualite_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4);
    static void doubleto2int(double val,int& val1,int& val2);
    static int estdansletetra(double *xyz1,double *xyz2,double *xyz3,double *xyz4,double x,double y, double z);
    static int estdansletriangle(double *xyz1,double *xyz2,double *xyz3,double x,double y, double z);
    static int projeteestdansletriangle(double *xyz1,double *xyz2,double *xyz3,double x,double y, double z);

    static int compare_etat_tetra(int etat,int valeur);
    static int compare_etat_triangle(int etat,int valeur);
};


template <int N=4>
class DLLPORTOUTIL DOUBLEN
{
public:
    DOUBLEN();
    DOUBLEN(double *v);
    DOUBLEN(DOUBLEN& mdd);
    DOUBLEN(const DOUBLEN& mdd);
    ~DOUBLEN();
    double get_valeur(int num);
    void change_valeur(int num,double val);
    DOUBLEN<N> & operator=(DOUBLEN<N> & mdd);
    DOUBLEN<N> & operator=(const DOUBLEN<N> & mdd);
private:
    double tab[N];
};

struct lessOT_VECTEUR_4DD : binary_function<OT_VECTEUR_4DD, OT_VECTEUR_4DD, bool>
{
    bool operator() ( OT_VECTEUR_4DD v1, OT_VECTEUR_4DD v2)
    {
        if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
        if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
        if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
        if (v1[3]!=v2[3]) return v1[3]<v2[3] ;
        return 0;

    }
    ;
};

struct lessOT_VECTEUR_3DD : binary_function<OT_VECTEUR_3DD, OT_VECTEUR_3DD, bool>
{
    bool operator() ( OT_VECTEUR_3DD v1, OT_VECTEUR_3DD v2)
    {
        if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
        if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
        if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
        return 0;

    }
    ;
};


#endif
Revision:	919
Committed:	Tue Mar 6 17:51:54 2018 UTC (7 years, 2 months ago) by couturad
Content type:	text/plain
File size:	17130 byte(s)
Log Message:	Correction des bugs lors de l'execution en mode RELWITHDEBINFO. Ajouts de fichiers pour la librairie MICROSTRUCTURE
#	User	Rev	Content
1	francois	283	//------------------------------------------------------------
2			//------------------------------------------------------------
3			// MAGiC
4			// Jean Christophe Cuilli�re et Vincent FRANCOIS
5			// D�partement de G�nie M�canique - UQTR
6			//------------------------------------------------------------
7			// Le projet MAGIC est un projet de recherche du d�partement
8			// de g�nie m�canique de l'Universit� du Qu�bec �
9			// Trois Rivi�res
10			// Les librairies ne peuvent �tre utilis�es sans l'accord
11			// des auteurs (contact : francois@uqtr.ca)
12			//------------------------------------------------------------
13			//------------------------------------------------------------
14			//
15			// ot_mathematique.h
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20			// Version du 02/03/2006 � 11H23
21			//------------------------------------------------------------
22			//------------------------------------------------------------
23			#ifndef _OTMATHEMATIQUE_
24			#define _OTMATHEMATIQUE_
25
26			#ifdef WINDOWS_VERSION
27			#ifdef BUILT_DLL_OUTIL
28			#define DLLPORTOUTIL __declspec(dllexport)
29			#else
30			#define DLLPORTOUTIL __declspec(dllimport)
31			#endif
32			#else
33			#define DLLPORTOUTIL
34			#endif
35
36			#include "ot_doubleprecision.h"
37			#include <iostream>
38	couturad	919	#include <map>
39	francois	283	#include <vector>
40
41
42	couturad	919	class DLLPORTOUTIL OT_HISTOGRAMME
43			{
44			public:
45			OT_HISTOGRAMME(double largeur_colonne);
46			~OT_HISTOGRAMME(void);
47			void ajouter_valeur(double x,double val);
48			void ajouter_valeur(long i,double val);
49			double get_valeur(double x);
50			int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur,double &borne_min);
51			int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur,double &borne_min);
52			long get_nb_colonne(void);
53			double get_x_min(void);
54			double get_x_max(void);
55			protected:
56			bool m_init;
57			long m_i_min;
58			long m_i_max;
59			double m_largeur_colonne;
60			std::map<long,double,std::less<unsigned long>> m_map_colonne;
61			};
62
63	couturad	906	class DLLPORTOUTIL OT_QUATERNION
64			{
65			public:
66			OT_QUATERNION(void);
67			OT_QUATERNION(double x,double y,double z,double w);
68			OT_QUATERNION(OT_QUATERNION &mdd);
69			double get_x(void);
70			void change_x(double x);
71			double get_y(void);
72			void change_y(double y);
73			double get_z(void);
74			void change_z(double z);
75			double get_w(void);
76			void change_w(double w);
77
78			OT_QUATERNION& operator=(OT_QUATERNION& mdd);
79
80			protected:
81			double valeur[4];
82			};
83	francois	283
84
85
86			class DLLPORTOUTIL OT_VECTEUR_3D
87			{
88			public :
89			// construction
90			OT_VECTEUR_3D(double x,double y,double z);
91			OT_VECTEUR_3D(double *xyz);
92			OT_VECTEUR_3D(double xyz1,double xyz2);
93			OT_VECTEUR_3D(void);
94			OT_VECTEUR_3D(const OT_VECTEUR_3D& mdd);
95			OT_VECTEUR_3D unite(int i);
96			// stream string output
97			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
98
99			// comparison
100			bool operator== (const OT_VECTEUR_3D& mdd) const;
101			bool operator!= (const OT_VECTEUR_3D& mdd) const;
102			bool operator< (const OT_VECTEUR_3D& mdd) const;
103			bool operator<= (const OT_VECTEUR_3D& mdd) const;
104			bool operator> (const OT_VECTEUR_3D& mdd) const;
105			bool operator>= (const OT_VECTEUR_3D& mdd) const;
106			int compare_valeur (const OT_VECTEUR_3D& mdd) const;
107
108			// coordinate access
109			virtual double get_x(void) const ;
110			virtual double get_y(void) const ;
111			virtual double get_z(void) const ;
112			virtual void change_x(double x);
113			virtual void change_y(double y);
114			virtual void change_z(double z);
115			virtual double* get_xyz(void);
116
117			operator const double* () const;
118			operator double* ();
119			double operator[] (int i) const;
120			double& operator[] (int i);
121			double operator() (int i) const;
122			double & operator() (int i);
123
124			// arithmetic operations
125			friend OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
126			friend OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
127			friend double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
128			friend OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
129			friend OT_VECTEUR_3D operator*(const class OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
130			friend OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
131			friend OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
132			friend OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);
133
134			// arithmetic updates
135			OT_VECTEUR_3D& operator+= (const OT_VECTEUR_3D& rkV);
136			OT_VECTEUR_3D& operator-= (const OT_VECTEUR_3D& rkV);
137			OT_VECTEUR_3D& operator*= (double fScalar);
138			OT_VECTEUR_3D& operator/= (double fScalar);
139
140			// vector operations
141			virtual double get_longueur(void) const ;
142			virtual double get_longueur2(void) const ;
143			virtual void norme(void);
144			OT_VECTEUR_3D gram_shmidt(const OT_VECTEUR_3D& vint);
145			virtual double diff(void);
146
147
148			private:
149			double valeur[3];
150			};
151
152			class DLLPORTOUTIL OT_MATRICE_3D
153			{
154			public:
155			OT_MATRICE_3D(OT_VECTEUR_3D& v1,OT_VECTEUR_3D& v2,OT_VECTEUR_3D& v3);
156			OT_MATRICE_3D(void);
157			OT_MATRICE_3D(double* t);
158			OT_MATRICE_3D(const OT_MATRICE_3D& mdd);
159
160			// stream string output
161			friend std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
162
163			// access to matrix elements
164			double operator() (int iLigne, int iCol) const;
165			double & operator() (int iLigne, int iCol);
166			double valeur(int iLigne, int iCol) const;
167			double & valeur(int iLigne, int iCol);
168			OT_VECTEUR_3D& get_vecteur1(void);
169			OT_VECTEUR_3D& get_vecteur2(void);
170			OT_VECTEUR_3D& get_vecteur3(void);
171			void change_vecteur1(OT_VECTEUR_3D v);
172			void change_vecteur2(OT_VECTEUR_3D v);
173			void change_vecteur3(OT_VECTEUR_3D v);
174			OT_VECTEUR_3D & operator [](int i);
175			// return inverse matrix
176			OT_MATRICE_3D inverse() const;
177			// assignements methods
178			void identite(void);
179			double get_determinant();
180			void transpose(OT_MATRICE_3D& res) const;
181			OT_MATRICE_3D transpose() const;
182			friend OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
183
184			private:
185			OT_VECTEUR_3D vec[3]; // attention ! vecteurs colonne
186			friend OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
187			};
188
189			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
190			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
191			DLLPORTOUTIL OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
192			DLLPORTOUTIL OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
193			DLLPORTOUTIL double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
194			DLLPORTOUTIL OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
195			DLLPORTOUTIL OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
196			DLLPORTOUTIL OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
197			DLLPORTOUTIL OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
198			DLLPORTOUTIL OT_MATRICE_3D operator*(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
199			DLLPORTOUTIL OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
200			DLLPORTOUTIL OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);
201
202
203
204			#define ot_vecteur_4d
205			#ifdef ot_vecteur_4d
206			class DLLPORTOUTIL OT_VECTEUR_4D
207			{
208			public :
209			//construction
210			OT_VECTEUR_4D(double x,double y,double z,double w);
211			OT_VECTEUR_4D(double *xyzw);
212			OT_VECTEUR_4D(void) {};
213			OT_VECTEUR_4D(const OT_VECTEUR_4D& mdd);
214			OT_VECTEUR_4D & operator= (double);
215
216			// stream string output
217			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
218
219			// comparison
220			bool operator== (const OT_VECTEUR_4D& mdd) const;
221			bool operator!= (const OT_VECTEUR_4D& mdd) const;
222			bool operator< (const OT_VECTEUR_4D& mdd) const;
223			bool operator<= (const OT_VECTEUR_4D& mdd) const;
224			bool operator> (const OT_VECTEUR_4D& mdd) const;
225			bool operator>= (const OT_VECTEUR_4D& mdd) const;
226	francois	743	// int compare_valeur (const OT_VECTEUR_4D& mdd) const;
227	francois	283
228			// coordinate access
229			virtual double get_x(void) const ;
230			virtual double get_y(void) const ;
231			virtual double get_z(void) const ;
232			virtual double get_w(void) const ;
233			virtual double & x(void);
234			virtual double & y(void);
235			virtual double & z(void);
236			virtual double & w(void);
237			virtual void change_x(double x);
238			virtual void change_y(double y);
239			virtual void change_z(double z);
240			virtual void change_w(double w);
241			virtual double* get_xyzw(void);
242			operator const double* () const;
243			operator double* ();
244			double operator[] (int i) const;
245			double& operator[] (int i);
246			double operator() (int i) const;
247			double & operator() (int i);
248
249			// arithmetic operations
250			OT_VECTEUR_4D operator+ (const OT_VECTEUR_4D& rkV);
251			OT_VECTEUR_4D operator- (const OT_VECTEUR_4D& rkV);
252			double operator* (const OT_VECTEUR_4D & a);
253
254			// arithmetic updates
255			OT_VECTEUR_4D& operator+= (const OT_VECTEUR_4D& rkV);
256			OT_VECTEUR_4D& operator-= (const OT_VECTEUR_4D& rkV);
257			OT_VECTEUR_4D& operator*= (double fScalar);
258			OT_VECTEUR_4D& operator/= (double fScalar);
259
260			private:
261			double valeur[4];
262			};
263
264			DLLPORTOUTIL OT_VECTEUR_4D operator* (const OT_VECTEUR_4D & rkV, const double a);
265			DLLPORTOUTIL OT_VECTEUR_4D operator* (const double a, const OT_VECTEUR_4D & rkV);
266			DLLPORTOUTIL OT_VECTEUR_4D operator/ (const OT_VECTEUR_4D & rkV, const double a);
267			DLLPORTOUTIL OT_VECTEUR_4D operator/ (const double a, const OT_VECTEUR_4D & rkV);
268			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
269			#endif // ot_vecteur_4d
270
271
272
273			class DLLPORTOUTIL OT_VECTEUR_4DD
274			{
275			public :
276			//construction
277			OT_VECTEUR_4DD(double2 x,double2 y,double2 z,double2 w);
278			OT_VECTEUR_4DD(double2 *xyzw);
279			OT_VECTEUR_4DD() {};
280			OT_VECTEUR_4DD(const OT_VECTEUR_4DD& mdd);
281			//OT_VECTEUR_4DD & operator= (double2);
282			OT_VECTEUR_4DD & operator= (const OT_VECTEUR_4DD&);
283
284			// stream string output
285			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
286
287			// comparison
288			bool operator== (const OT_VECTEUR_4DD& mdd) const;
289			bool operator!= (const OT_VECTEUR_4DD& mdd) const;
290			bool operator< (const OT_VECTEUR_4DD& mdd) const;
291			bool operator<= (const OT_VECTEUR_4DD& mdd) const;
292			bool operator> (const OT_VECTEUR_4DD& mdd) const;
293			bool operator>= (const OT_VECTEUR_4DD& mdd) const;
294			int compare_valeur (const OT_VECTEUR_4DD& mdd) const;
295
296			// coordinate access
297			virtual double2 get_x(void) const ;
298			virtual double2 get_y(void) const ;
299			virtual double2 get_z(void) const ;
300			virtual double2 get_w(void) const ;
301			virtual double2 & x(void);
302			virtual double2 & y(void);
303			virtual double2 & z(void);
304			virtual double2 & w(void);
305			virtual void change_x(double2 x);
306			virtual void change_y(double2 y);
307			virtual void change_z(double2 z);
308			virtual void change_w(double2 w);
309			virtual double2* get_xyzw(void);
310			double2 norme();
311			OT_VECTEUR_4DD vecteur_norme() ;
312	francois	363	OT_VECTEUR_4DD vecteur_norme_3d() ;
313	francois	283	operator const double2* () const;
314			operator double2* ();
315			double2 operator[] (int i) const;
316			double2& operator[] (int i);
317			double2 operator() (int i) const;
318			double2 & operator() (int i);
319
320			// arithmetic operations
321			OT_VECTEUR_4DD operator+ (const OT_VECTEUR_4DD& rkV);
322			OT_VECTEUR_4DD operator- (const OT_VECTEUR_4DD& rkV);
323			double2 operator* (const OT_VECTEUR_4DD & a);
324
325			// arithmetic updates
326			OT_VECTEUR_4DD& operator+= (const OT_VECTEUR_4DD& rkV);
327			OT_VECTEUR_4DD& operator-= (const OT_VECTEUR_4DD& rkV);
328			OT_VECTEUR_4DD& operator*= (double2 fScalar);
329			OT_VECTEUR_4DD& operator/= (double2 fScalar);
330			OT_VECTEUR_4DD operator^(const OT_VECTEUR_4DD& v2);
331	francois	743	bool est_nul(void);
332			bool est_nul_3d(void);
333	francois	283
334
335			private:
336			double2 valeur[4];
337			};
338
339
340
341			class DLLPORTOUTIL OT_VECTEUR_3DD
342			{
343			public :
344			//construction
345			OT_VECTEUR_3DD(double2 x,double2 y,double2 z);
346	francois	550	OT_VECTEUR_3DD(double2 *xyzw);
347			OT_VECTEUR_3DD(double2 xyz1,double2 xyz2);
348	francois	283	OT_VECTEUR_3DD() {};
349			OT_VECTEUR_3DD(const OT_VECTEUR_3DD& mdd);
350			OT_VECTEUR_3DD & operator= (const OT_VECTEUR_3DD&);
351
352			// stream string output
353			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3DD & __vec);
354
355			// comparison
356			bool operator== (const OT_VECTEUR_3DD& mdd) const;
357			bool operator!= (const OT_VECTEUR_3DD& mdd) const;
358			bool operator< (const OT_VECTEUR_3DD& mdd) const;
359			bool operator<= (const OT_VECTEUR_3DD& mdd) const;
360			bool operator> (const OT_VECTEUR_3DD& mdd) const;
361			bool operator>= (const OT_VECTEUR_3DD& mdd) const;
362			int compare_valeur (const OT_VECTEUR_3DD& mdd) const;
363
364			// coordinate access
365			virtual double2 get_x(void) const ;
366			virtual double2 get_y(void) const ;
367			virtual double2 get_z(void) const ;
368			virtual double2 & x(void);
369			virtual double2 & y(void);
370			virtual double2 & z(void);
371			virtual void change_x(double2 x);
372			virtual void change_y(double2 y);
373			virtual void change_z(double2 z);
374			virtual double2* get_xyz(void);
375			double2 norme();
376			OT_VECTEUR_3DD vecteur_norme() ;
377	francois	550	virtual double2 get_longueur(void) ;
378			virtual double2 get_longueur2(void) ;
379	francois	283	operator const double2* () const;
380			operator double2* ();
381			double2 operator[] (int i) const;
382			double2& operator[] (int i);
383			double2 operator() (int i) const;
384			double2 & operator() (int i);
385
386			// arithmetic operations
387			OT_VECTEUR_3DD operator+ (const OT_VECTEUR_3DD& rkV);
388			OT_VECTEUR_3DD operator- (const OT_VECTEUR_3DD& rkV);
389			double2 operator* (const OT_VECTEUR_3DD & a);
390
391			// arithmetic updates
392			OT_VECTEUR_3DD& operator+= (const OT_VECTEUR_3DD& rkV);
393			OT_VECTEUR_3DD& operator-= (const OT_VECTEUR_3DD& rkV);
394			OT_VECTEUR_3DD& operator*= (double2 fScalar);
395			OT_VECTEUR_3DD& operator/= (double2 fScalar);
396			OT_VECTEUR_3DD operator&(const OT_VECTEUR_3DD& v2);
397
398
399			private:
400			double2 valeur[3];
401			};
402
403
404
405
406
407
408			DLLPORTOUTIL OT_VECTEUR_4DD operator* (const OT_VECTEUR_4DD & rkV, const double2 a);
409			DLLPORTOUTIL OT_VECTEUR_4DD operator* (const double2 a, const OT_VECTEUR_4DD & rkV);
410			DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const OT_VECTEUR_4DD & rkV, const double2 a);
411			DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const double2 a, const OT_VECTEUR_4DD & rkV);
412			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
413			DLLPORTOUTIL OT_VECTEUR_3DD operator* (const OT_VECTEUR_3DD & rkV, const double2 a);
414			DLLPORTOUTIL OT_VECTEUR_3DD operator* (const double2 a, const OT_VECTEUR_3DD & rkV);
415			DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const OT_VECTEUR_3DD & rkV, const double2 a);
416			DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const double2 a, const OT_VECTEUR_3DD & rkV);
417			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
418
419
420
421
422
423
424			class DLLPORTOUTIL OPERATEUR
425			{
426			public:
427	francois	418	enum ETAT {EXTERIEUR=0,INTERIEUR=4,STRICTINTERIEUR=3,SUR_FACE=1,SUR_ARETE=5,FACE1=10,FACE2=11,FACE3=12,FACE4=13,ARETE1=20,ARETE2=21,ARETE3=22,ARETE4=23,ARETE5=24,ARETE6=25,SOMMET1=30,SOMMET2=31,SOMMET3=32,SOMMET4=33};
428
429	francois	283	static int egal(double a,double b,double eps);
430	couturad	906	static int egal(double xyz1,double xyz2,double eps);
431	francois	283	static double qualite_triangle(double* noeud1,double* noeud2,double* noeud3);
432			static double qualite_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4);
433			static void doubleto2int(double val,int& val1,int& val2);
434	francois	418	static int estdansletetra(double xyz1,double xyz2,double xyz3,double xyz4,double x,double y, double z);
435			static int estdansletriangle(double xyz1,double xyz2,double *xyz3,double x,double y, double z);
436			static int projeteestdansletriangle(double xyz1,double xyz2,double *xyz3,double x,double y, double z);
437
438			static int compare_etat_tetra(int etat,int valeur);
439			static int compare_etat_triangle(int etat,int valeur);
440	francois	283	};
441
442
443			template <int N=4>
444			class DLLPORTOUTIL DOUBLEN
445			{
446			public:
447			DOUBLEN();
448			DOUBLEN(double *v);
449			DOUBLEN(DOUBLEN& mdd);
450			DOUBLEN(const DOUBLEN& mdd);
451			~DOUBLEN();
452			double get_valeur(int num);
453			void change_valeur(int num,double val);
454			DOUBLEN<N> & operator=(DOUBLEN<N> & mdd);
455			DOUBLEN<N> & operator=(const DOUBLEN<N> & mdd);
456			private:
457			double tab[N];
458			};
459
460			struct lessOT_VECTEUR_4DD : binary_function<OT_VECTEUR_4DD, OT_VECTEUR_4DD, bool>
461			{
462			bool operator() ( OT_VECTEUR_4DD v1, OT_VECTEUR_4DD v2)
463			{
464			if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
465			if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
466			if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
467			if (v1[3]!=v2[3]) return v1[3]<v2[3] ;
468			return 0;
469
470			}
471			;
472			};
473
474			struct lessOT_VECTEUR_3DD : binary_function<OT_VECTEUR_3DD, OT_VECTEUR_3DD, bool>
475			{
476			bool operator() ( OT_VECTEUR_3DD v1, OT_VECTEUR_3DD v2)
477			{
478			if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
479			if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
480			if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
481			return 0;
482
483			}
484			;
485			};
486
487
488			#endif