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, 9 months ago) by couturad
Content type:	text/plain
File size:	16454 byte(s)
Log Message:	Nouveau opencascade commit 1
#	Content
1	//------------------------------------------------------------
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	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
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	// int compare_valeur (const OT_VECTEUR_4D& mdd) const;
205
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	OT_VECTEUR_4DD vecteur_norme_3d() ;
291	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	bool est_nul(void);
310	bool est_nul_3d(void);
311
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	OT_VECTEUR_3DD(double2 *xyzw);
325	OT_VECTEUR_3DD(double2 xyz1,double2 xyz2);
326	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	virtual double2 get_longueur(void) ;
356	virtual double2 get_longueur2(void) ;
357	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	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	static int egal(double a,double b,double eps);
408	static int egal(double xyz1,double xyz2,double eps);
409	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	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	};
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