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