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 <vector>


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:	906
Committed:	Mon Nov 13 22:30:18 2017 UTC (7 years, 6 months ago) by couturad
Content type:	text/plain
File size:	16454 byte(s)
Log Message:	Nouveau opencascade commit 1
#	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			#include <vector>
39
40
41	couturad	906	class DLLPORTOUTIL OT_QUATERNION
42			{
43			public:
44			OT_QUATERNION(void);
45			OT_QUATERNION(double x,double y,double z,double w);
46			OT_QUATERNION(OT_QUATERNION &mdd);
47			double get_x(void);
48			void change_x(double x);
49			double get_y(void);
50			void change_y(double y);
51			double get_z(void);
52			void change_z(double z);
53			double get_w(void);
54			void change_w(double w);
55
56			OT_QUATERNION& operator=(OT_QUATERNION& mdd);
57
58			protected:
59			double valeur[4];
60			};
61	francois	283
62
63
64			class DLLPORTOUTIL OT_VECTEUR_3D
65			{
66			public :
67			// construction
68			OT_VECTEUR_3D(double x,double y,double z);
69			OT_VECTEUR_3D(double *xyz);
70			OT_VECTEUR_3D(double xyz1,double xyz2);
71			OT_VECTEUR_3D(void);
72			OT_VECTEUR_3D(const OT_VECTEUR_3D& mdd);
73			OT_VECTEUR_3D unite(int i);
74			// stream string output
75			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
76
77			// comparison
78			bool operator== (const OT_VECTEUR_3D& mdd) const;
79			bool operator!= (const OT_VECTEUR_3D& mdd) const;
80			bool operator< (const OT_VECTEUR_3D& mdd) const;
81			bool operator<= (const OT_VECTEUR_3D& mdd) const;
82			bool operator> (const OT_VECTEUR_3D& mdd) const;
83			bool operator>= (const OT_VECTEUR_3D& mdd) const;
84			int compare_valeur (const OT_VECTEUR_3D& mdd) const;
85
86			// coordinate access
87			virtual double get_x(void) const ;
88			virtual double get_y(void) const ;
89			virtual double get_z(void) const ;
90			virtual void change_x(double x);
91			virtual void change_y(double y);
92			virtual void change_z(double z);
93			virtual double* get_xyz(void);
94
95			operator const double* () const;
96			operator double* ();
97			double operator[] (int i) const;
98			double& operator[] (int i);
99			double operator() (int i) const;
100			double & operator() (int i);
101
102			// arithmetic operations
103			friend OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
104			friend OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
105			friend double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
106			friend OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
107			friend OT_VECTEUR_3D operator*(const class OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
108			friend OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
109			friend OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
110			friend OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);
111
112			// arithmetic updates
113			OT_VECTEUR_3D& operator+= (const OT_VECTEUR_3D& rkV);
114			OT_VECTEUR_3D& operator-= (const OT_VECTEUR_3D& rkV);
115			OT_VECTEUR_3D& operator*= (double fScalar);
116			OT_VECTEUR_3D& operator/= (double fScalar);
117
118			// vector operations
119			virtual double get_longueur(void) const ;
120			virtual double get_longueur2(void) const ;
121			virtual void norme(void);
122			OT_VECTEUR_3D gram_shmidt(const OT_VECTEUR_3D& vint);
123			virtual double diff(void);
124
125
126			private:
127			double valeur[3];
128			};
129
130			class DLLPORTOUTIL OT_MATRICE_3D
131			{
132			public:
133			OT_MATRICE_3D(OT_VECTEUR_3D& v1,OT_VECTEUR_3D& v2,OT_VECTEUR_3D& v3);
134			OT_MATRICE_3D(void);
135			OT_MATRICE_3D(double* t);
136			OT_MATRICE_3D(const OT_MATRICE_3D& mdd);
137
138			// stream string output
139			friend std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
140
141			// access to matrix elements
142			double operator() (int iLigne, int iCol) const;
143			double & operator() (int iLigne, int iCol);
144			double valeur(int iLigne, int iCol) const;
145			double & valeur(int iLigne, int iCol);
146			OT_VECTEUR_3D& get_vecteur1(void);
147			OT_VECTEUR_3D& get_vecteur2(void);
148			OT_VECTEUR_3D& get_vecteur3(void);
149			void change_vecteur1(OT_VECTEUR_3D v);
150			void change_vecteur2(OT_VECTEUR_3D v);
151			void change_vecteur3(OT_VECTEUR_3D v);
152			OT_VECTEUR_3D & operator [](int i);
153			// return inverse matrix
154			OT_MATRICE_3D inverse() const;
155			// assignements methods
156			void identite(void);
157			double get_determinant();
158			void transpose(OT_MATRICE_3D& res) const;
159			OT_MATRICE_3D transpose() const;
160			friend OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
161
162			private:
163			OT_VECTEUR_3D vec[3]; // attention ! vecteurs colonne
164			friend OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
165			};
166
167			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat);
168			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec);
169			DLLPORTOUTIL OT_VECTEUR_3D operator / (const OT_VECTEUR_3D& mdd1, double a);
170			DLLPORTOUTIL OT_VECTEUR_3D operator - (const OT_VECTEUR_3D& mdd1);
171			DLLPORTOUTIL double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
172			DLLPORTOUTIL OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
173			DLLPORTOUTIL OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2);
174			DLLPORTOUTIL OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
175			DLLPORTOUTIL OT_VECTEUR_3D operator-(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2);
176			DLLPORTOUTIL OT_MATRICE_3D operator*(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
177			DLLPORTOUTIL OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2);
178			DLLPORTOUTIL OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2);
179
180
181
182			#define ot_vecteur_4d
183			#ifdef ot_vecteur_4d
184			class DLLPORTOUTIL OT_VECTEUR_4D
185			{
186			public :
187			//construction
188			OT_VECTEUR_4D(double x,double y,double z,double w);
189			OT_VECTEUR_4D(double *xyzw);
190			OT_VECTEUR_4D(void) {};
191			OT_VECTEUR_4D(const OT_VECTEUR_4D& mdd);
192			OT_VECTEUR_4D & operator= (double);
193
194			// stream string output
195			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
196
197			// comparison
198			bool operator== (const OT_VECTEUR_4D& mdd) const;
199			bool operator!= (const OT_VECTEUR_4D& mdd) const;
200			bool operator< (const OT_VECTEUR_4D& mdd) const;
201			bool operator<= (const OT_VECTEUR_4D& mdd) const;
202			bool operator> (const OT_VECTEUR_4D& mdd) const;
203			bool operator>= (const OT_VECTEUR_4D& mdd) const;
204	francois	743	// int compare_valeur (const OT_VECTEUR_4D& mdd) const;
205	francois	283
206			// coordinate access
207			virtual double get_x(void) const ;
208			virtual double get_y(void) const ;
209			virtual double get_z(void) const ;
210			virtual double get_w(void) const ;
211			virtual double & x(void);
212			virtual double & y(void);
213			virtual double & z(void);
214			virtual double & w(void);
215			virtual void change_x(double x);
216			virtual void change_y(double y);
217			virtual void change_z(double z);
218			virtual void change_w(double w);
219			virtual double* get_xyzw(void);
220			operator const double* () const;
221			operator double* ();
222			double operator[] (int i) const;
223			double& operator[] (int i);
224			double operator() (int i) const;
225			double & operator() (int i);
226
227			// arithmetic operations
228			OT_VECTEUR_4D operator+ (const OT_VECTEUR_4D& rkV);
229			OT_VECTEUR_4D operator- (const OT_VECTEUR_4D& rkV);
230			double operator* (const OT_VECTEUR_4D & a);
231
232			// arithmetic updates
233			OT_VECTEUR_4D& operator+= (const OT_VECTEUR_4D& rkV);
234			OT_VECTEUR_4D& operator-= (const OT_VECTEUR_4D& rkV);
235			OT_VECTEUR_4D& operator*= (double fScalar);
236			OT_VECTEUR_4D& operator/= (double fScalar);
237
238			private:
239			double valeur[4];
240			};
241
242			DLLPORTOUTIL OT_VECTEUR_4D operator* (const OT_VECTEUR_4D & rkV, const double a);
243			DLLPORTOUTIL OT_VECTEUR_4D operator* (const double a, const OT_VECTEUR_4D & rkV);
244			DLLPORTOUTIL OT_VECTEUR_4D operator/ (const OT_VECTEUR_4D & rkV, const double a);
245			DLLPORTOUTIL OT_VECTEUR_4D operator/ (const double a, const OT_VECTEUR_4D & rkV);
246			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec);
247			#endif // ot_vecteur_4d
248
249
250
251			class DLLPORTOUTIL OT_VECTEUR_4DD
252			{
253			public :
254			//construction
255			OT_VECTEUR_4DD(double2 x,double2 y,double2 z,double2 w);
256			OT_VECTEUR_4DD(double2 *xyzw);
257			OT_VECTEUR_4DD() {};
258			OT_VECTEUR_4DD(const OT_VECTEUR_4DD& mdd);
259			//OT_VECTEUR_4DD & operator= (double2);
260			OT_VECTEUR_4DD & operator= (const OT_VECTEUR_4DD&);
261
262			// stream string output
263			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
264
265			// comparison
266			bool operator== (const OT_VECTEUR_4DD& mdd) const;
267			bool operator!= (const OT_VECTEUR_4DD& mdd) const;
268			bool operator< (const OT_VECTEUR_4DD& mdd) const;
269			bool operator<= (const OT_VECTEUR_4DD& mdd) const;
270			bool operator> (const OT_VECTEUR_4DD& mdd) const;
271			bool operator>= (const OT_VECTEUR_4DD& mdd) const;
272			int compare_valeur (const OT_VECTEUR_4DD& mdd) const;
273
274			// coordinate access
275			virtual double2 get_x(void) const ;
276			virtual double2 get_y(void) const ;
277			virtual double2 get_z(void) const ;
278			virtual double2 get_w(void) const ;
279			virtual double2 & x(void);
280			virtual double2 & y(void);
281			virtual double2 & z(void);
282			virtual double2 & w(void);
283			virtual void change_x(double2 x);
284			virtual void change_y(double2 y);
285			virtual void change_z(double2 z);
286			virtual void change_w(double2 w);
287			virtual double2* get_xyzw(void);
288			double2 norme();
289			OT_VECTEUR_4DD vecteur_norme() ;
290	francois	363	OT_VECTEUR_4DD vecteur_norme_3d() ;
291	francois	283	operator const double2* () const;
292			operator double2* ();
293			double2 operator[] (int i) const;
294			double2& operator[] (int i);
295			double2 operator() (int i) const;
296			double2 & operator() (int i);
297
298			// arithmetic operations
299			OT_VECTEUR_4DD operator+ (const OT_VECTEUR_4DD& rkV);
300			OT_VECTEUR_4DD operator- (const OT_VECTEUR_4DD& rkV);
301			double2 operator* (const OT_VECTEUR_4DD & a);
302
303			// arithmetic updates
304			OT_VECTEUR_4DD& operator+= (const OT_VECTEUR_4DD& rkV);
305			OT_VECTEUR_4DD& operator-= (const OT_VECTEUR_4DD& rkV);
306			OT_VECTEUR_4DD& operator*= (double2 fScalar);
307			OT_VECTEUR_4DD& operator/= (double2 fScalar);
308			OT_VECTEUR_4DD operator^(const OT_VECTEUR_4DD& v2);
309	francois	743	bool est_nul(void);
310			bool est_nul_3d(void);
311	francois	283
312
313			private:
314			double2 valeur[4];
315			};
316
317
318
319			class DLLPORTOUTIL OT_VECTEUR_3DD
320			{
321			public :
322			//construction
323			OT_VECTEUR_3DD(double2 x,double2 y,double2 z);
324	francois	550	OT_VECTEUR_3DD(double2 *xyzw);
325			OT_VECTEUR_3DD(double2 xyz1,double2 xyz2);
326	francois	283	OT_VECTEUR_3DD() {};
327			OT_VECTEUR_3DD(const OT_VECTEUR_3DD& mdd);
328			OT_VECTEUR_3DD & operator= (const OT_VECTEUR_3DD&);
329
330			// stream string output
331			friend std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3DD & __vec);
332
333			// comparison
334			bool operator== (const OT_VECTEUR_3DD& mdd) const;
335			bool operator!= (const OT_VECTEUR_3DD& mdd) const;
336			bool operator< (const OT_VECTEUR_3DD& mdd) const;
337			bool operator<= (const OT_VECTEUR_3DD& mdd) const;
338			bool operator> (const OT_VECTEUR_3DD& mdd) const;
339			bool operator>= (const OT_VECTEUR_3DD& mdd) const;
340			int compare_valeur (const OT_VECTEUR_3DD& mdd) const;
341
342			// coordinate access
343			virtual double2 get_x(void) const ;
344			virtual double2 get_y(void) const ;
345			virtual double2 get_z(void) const ;
346			virtual double2 & x(void);
347			virtual double2 & y(void);
348			virtual double2 & z(void);
349			virtual void change_x(double2 x);
350			virtual void change_y(double2 y);
351			virtual void change_z(double2 z);
352			virtual double2* get_xyz(void);
353			double2 norme();
354			OT_VECTEUR_3DD vecteur_norme() ;
355	francois	550	virtual double2 get_longueur(void) ;
356			virtual double2 get_longueur2(void) ;
357	francois	283	operator const double2* () const;
358			operator double2* ();
359			double2 operator[] (int i) const;
360			double2& operator[] (int i);
361			double2 operator() (int i) const;
362			double2 & operator() (int i);
363
364			// arithmetic operations
365			OT_VECTEUR_3DD operator+ (const OT_VECTEUR_3DD& rkV);
366			OT_VECTEUR_3DD operator- (const OT_VECTEUR_3DD& rkV);
367			double2 operator* (const OT_VECTEUR_3DD & a);
368
369			// arithmetic updates
370			OT_VECTEUR_3DD& operator+= (const OT_VECTEUR_3DD& rkV);
371			OT_VECTEUR_3DD& operator-= (const OT_VECTEUR_3DD& rkV);
372			OT_VECTEUR_3DD& operator*= (double2 fScalar);
373			OT_VECTEUR_3DD& operator/= (double2 fScalar);
374			OT_VECTEUR_3DD operator&(const OT_VECTEUR_3DD& v2);
375
376
377			private:
378			double2 valeur[3];
379			};
380
381
382
383
384
385
386			DLLPORTOUTIL OT_VECTEUR_4DD operator* (const OT_VECTEUR_4DD & rkV, const double2 a);
387			DLLPORTOUTIL OT_VECTEUR_4DD operator* (const double2 a, const OT_VECTEUR_4DD & rkV);
388			DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const OT_VECTEUR_4DD & rkV, const double2 a);
389			DLLPORTOUTIL OT_VECTEUR_4DD operator/ (const double2 a, const OT_VECTEUR_4DD & rkV);
390			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
391			DLLPORTOUTIL OT_VECTEUR_3DD operator* (const OT_VECTEUR_3DD & rkV, const double2 a);
392			DLLPORTOUTIL OT_VECTEUR_3DD operator* (const double2 a, const OT_VECTEUR_3DD & rkV);
393			DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const OT_VECTEUR_3DD & rkV, const double2 a);
394			DLLPORTOUTIL OT_VECTEUR_3DD operator/ (const double2 a, const OT_VECTEUR_3DD & rkV);
395			DLLPORTOUTIL std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec);
396
397
398
399
400
401
402			class DLLPORTOUTIL OPERATEUR
403			{
404			public:
405	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};
406
407	francois	283	static int egal(double a,double b,double eps);
408	couturad	906	static int egal(double xyz1,double xyz2,double eps);
409	francois	283	static double qualite_triangle(double* noeud1,double* noeud2,double* noeud3);
410			static double qualite_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4);
411			static void doubleto2int(double val,int& val1,int& val2);
412	francois	418	static int estdansletetra(double xyz1,double xyz2,double xyz3,double xyz4,double x,double y, double z);
413			static int estdansletriangle(double xyz1,double xyz2,double *xyz3,double x,double y, double z);
414			static int projeteestdansletriangle(double xyz1,double xyz2,double *xyz3,double x,double y, double z);
415
416			static int compare_etat_tetra(int etat,int valeur);
417			static int compare_etat_triangle(int etat,int valeur);
418	francois	283	};
419
420
421			template <int N=4>
422			class DLLPORTOUTIL DOUBLEN
423			{
424			public:
425			DOUBLEN();
426			DOUBLEN(double *v);
427			DOUBLEN(DOUBLEN& mdd);
428			DOUBLEN(const DOUBLEN& mdd);
429			~DOUBLEN();
430			double get_valeur(int num);
431			void change_valeur(int num,double val);
432			DOUBLEN<N> & operator=(DOUBLEN<N> & mdd);
433			DOUBLEN<N> & operator=(const DOUBLEN<N> & mdd);
434			private:
435			double tab[N];
436			};
437
438			struct lessOT_VECTEUR_4DD : binary_function<OT_VECTEUR_4DD, OT_VECTEUR_4DD, bool>
439			{
440			bool operator() ( OT_VECTEUR_4DD v1, OT_VECTEUR_4DD v2)
441			{
442			if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
443			if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
444			if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
445			if (v1[3]!=v2[3]) return v1[3]<v2[3] ;
446			return 0;
447
448			}
449			;
450			};
451
452			struct lessOT_VECTEUR_3DD : binary_function<OT_VECTEUR_3DD, OT_VECTEUR_3DD, bool>
453			{
454			bool operator() ( OT_VECTEUR_3DD v1, OT_VECTEUR_3DD v2)
455			{
456			if (v1[0]!=v2[0]) return v1[0]<v2[0] ;
457			if (v1[1]!=v2[1]) return v1[1]<v2[1] ;
458			if (v1[2]!=v2[2]) return v1[2]<v2[2] ;
459			return 0;
460
461			}
462			;
463			};
464
465
466			#endif