outil/src/ot_mathematique.h

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

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

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


class DLLPORTOUTIL OT_HISTOGRAMME
{
public:
  OT_HISTOGRAMME(void);
  OT_HISTOGRAMME(double largeur_colonne);
  OT_HISTOGRAMME(double largeur_colonne,OT_HISTOGRAMME &mdd);
  OT_HISTOGRAMME(OT_HISTOGRAMME &mdd);
  ~OT_HISTOGRAMME(void);
  void fixe_largeur_colonne(double largeur_colonne);
  double get_largeur_colonne(void);
  void ajouter_valeur(double x,double val);
  void ajouter_valeur(long i,double val);  
  int get_valeur(double x,double &val);
  int get_valeur(long i,double &val);
  int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur);
  int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur);
  int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur,double &borne_min,double &borne_max);
  int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur,double &borne_min,double &borne_max);
  int get_premiere_valeur(std::map<long,double>::iterator &it,double &valeur,long &i);
  int get_suivante_valeur(std::map<long,double>::iterator &it,double &valeur,long &i);
  long get_nb_colonne(void);
  double get_x_min(void);
  double get_x_max(void);
  OT_HISTOGRAMME& operator=(OT_HISTOGRAMME& mdd);
  OT_HISTOGRAMME& operator=(const OT_HISTOGRAMME& mdd);
  void enregistrer_bin(std::ofstream& ofstr);
  void ouvrir_bin(std::ifstream& ifstr);
  void ouvrir_txt(char* nom_fichier);
  void exporter(std::ofstream& ofstrm);
protected:
  bool m_init;
  long m_i_min;
  long m_i_max;
  double m_largeur_colonne;
  std::map<long,double,std::less<long>> m_map_colonne;
};

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


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

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

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

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

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

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

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


private:
    double valeur[3];
};

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

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

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

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

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


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

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

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

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

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

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

private:
    double valeur[4];
};

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


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

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

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

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

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

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


private:
    double2 valeur[4];
};


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

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

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

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

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

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


private:
    double2 valeur[3];
};


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


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

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

    static int compare_etat_tetra(int etat,int valeur);
    static int compare_etat_triangle(int etat,int valeur);
    
    static double taille_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4);
    static double taille_triangle(double* noeud1,double* noeud2,double* noeud3);
};


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