Commit ba9beb23 authored by axel's avatar axel
Browse files

mise en forme du code

parent c3105ce2

LrVector.cpp

+314 −257
Original line number Diff line number Diff line 
/**

 * @brief OBJET : un vecteur 3D

 * @brief Classe pour la gestion des vecteurs 3D

 * @file LrVector.cpp

 * @date Vendredi 7 mars 2008

 * @note 

 * @author Josselin Francois

 * @author Michael Nauge

 * @author Axel Richard

 * @author Hervé Souchaud

 * @author Emeric Verschuur

 * 

 * Ce fichier contient la classe qui gère la creation d'un vecteur 3D     

 */
@@ -21,58 +24,70 @@ const LrVector LrVector::I (1.0, 0.0, 0.0); 
const LrVector LrVector::J    (0.0, 1.0, 0.0);

const LrVector LrVector::K    (0.0, 0.0, 1.0);



// ############################################################################



////////////////////////////// CONSTRUCTEURS ///////////////////////////////////////////////////////



//Par defaut

LrVector::LrVector()

:   x(0.0), y(0.0), z(0.0)

{



}

//Par copie /*********************************************************************************/



// ############################################################################



LrVector::LrVector(const LrVector & source)

{

    x= source.x;

    y= source.y;

    z= source.z;

}

//Personel //*********************************************************************************/



// ############################################################################



LrVector::LrVector (Real x, Real y, Real z)

{

    this->x= x;

    this->y= y;

    this->z= z;

}

/*********************************************************************************/



// ############################################################################



LrVector::LrVector (const LrPoint & A, const LrPoint & B)

{

    x = B.x - A.x;

    y = B.y - A.y;

    z = B.z - A.z;

}

/*********************************************************************************/



// ############################################################################



LrVector::~LrVector()

{



}

/*********************************************************************************/



// ############################################################################



Real LrVector::getNorme() const

{

    return calculNorme();

}

/*********************************************************************************/



// ############################################################################



Real LrVector::getNormeCarre() const

{

    return calculNorme(true);

}

/*********************************************************************************/



// ############################################################################



Real LrVector::calculNorme(bool carre) const

{

    if(carre) return (Real)((x*x) + (y*y) + (z*z));

    else return (Real)(sqrt((x*x) + (y*y) + (z*z)));

}

/*********************************************************************************/



// ############################################################################



Real LrVector::getCompo(int compo) const

{

    switch(compo)
@@ -91,7 +106,9 @@ Real LrVector::getCompo(int compo) const 
            break;

    }

}

/*********************************************************************************/



// ############################################################################



void  LrVector::setComposante(int compo, Real val)

{

    switch(compo)
@@ -109,14 +126,18 @@ void LrVector::setComposante(int compo, Real val) 
            break;

    }

}

/*********************************************************************************/



// ############################################################################



void LrVector::setComposante(Real valx, Real valy, Real valz)

{

    x = valx;

    y = valy;

    z = valz;

}

/*********************************************************************************/



// ############################################################################



void LrVector::addXfois(const LrVector & vs, Real nbFois)

{

  for(int i=0;i<nbFois;i++)
@@ -124,7 +145,9 @@ void LrVector::addXfois(const LrVector & vs, Real nbFois) 
    (*this)+= vs;

  }

}

/*********************************************************************************/



// ############################################################################



LrVector & LrVector::operator = (const LrVector & source)

{

    if(this == &source) return (*this);
@@ -133,7 +156,9 @@ LrVector & LrVector::operator = (const LrVector & source) 
    z= source.z;

    return (*this);

}

/*********************************************************************************/



// ############################################################################



LrVector & LrVector::operator += (const LrVector & source)

{

     x+= source.x;
@@ -141,7 +166,9 @@ LrVector & LrVector::operator += (const LrVector & source) 
     z+= source.z;

    return (*this);

}

/*********************************************************************************/



// ############################################################################



LrVector & LrVector::operator += (const Real t)

{

    x+= t;
@@ -149,7 +176,9 @@ LrVector & LrVector::operator += (const Real t) 
    z+= t;

    return (*this);

}

/*********************************************************************************/



// ############################################################################



LrVector & LrVector::operator -= (const LrVector & source)

{

     x-= source.x;
@@ -157,56 +186,74 @@ LrVector & LrVector::operator -= (const LrVector & source) 
     z-= source.z;

    return (*this);

}

/*********************************************************************************/



// ############################################################################



LrVector operator + (const LrVector & v_1, const LrVector & v_2)

{

    LrVector tmp(v_1);

    tmp += v_2;

    return tmp;

}

/*********************************************************************************/



// ############################################################################



LrVector operator + (const Real t, const LrVector &v)

{

    LrVector tmp(v);

    tmp += t;

    return tmp;

}

/*********************************************************************************/



// ############################################################################



LrVector operator + (const LrVector &v, const Real t)

{

    LrVector tmp(v);

    tmp += t;

    return tmp;

}

/*********************************************************************************/



// ############################################################################



LrVector operator - (const LrVector & v_1, const LrVector & v_2)

{

    LrVector tmp(v_1);

    tmp -= v_2;

    return tmp;

}

/*********************************************************************************/



// ############################################################################



LrVector operator - (const LrVector & v)

{

    return LrVector(-v.x, -v.y, -v.z);



}

/*********************************************************************************/



// ############################################################################



bool operator == (const LrVector & v_1, const LrVector & v_2)

{

    return ((v_1.x == v_2.x) && (v_1.y == v_2.y) && (v_1.z == v_2.z));

}

/*********************************************************************************/



// ############################################################################



bool operator != (const LrVector & v_1, const LrVector & v_2)

{

    return !(v_1 == v_2);

}

//produit scalaire /*********************************************************************************/



// ############################################################################



Real operator * (const LrVector & v_1, const LrVector & v_2)

{

    return ((v_1.x * v_2.x) + (v_1.y * v_2.y) + (v_1.z * v_2.z));

}

//multiplication par un scalaire /*********************************************************************************/



// ############################################################################



LrVector operator * (const LrVector & v_1, Real scalaire)

{

    LrVector tmp;
@@ -215,12 +262,16 @@ LrVector operator * (const LrVector & v_1, Real scalaire) 
    tmp.z = v_1.z*scalaire;

    return tmp;

}

/*********************************************************************************/



// ############################################################################



LrVector operator * (Real scalaire, const LrVector & v)

{

    return v*scalaire;

}

/*********************************************************************************/



// ############################################################################



LrVector operator / (const LrVector & v, const Real t)

{

    LrVector tmp;
@@ -230,8 +281,9 @@ LrVector operator / (const LrVector & v, const Real t) 
    return tmp;

    

}

/*********************************************************************************/

//produit vectoriel /*********************************************************************************/



// ############################################################################



LrVector operator ^ (const LrVector & v_1, const LrVector & v_2)

{

    LrVector tmp;
@@ -240,14 +292,17 @@ LrVector operator ^ (const LrVector & v_1, const LrVector & v_2) 
    tmp.z = (v_1.x*v_2.y) - (v_1.y*v_2.x);

    return tmp;

}

/*********************************************************************************/



// ############################################################################



Real calculAngle(const LrVector & v_1, const LrVector & v_2)

{

    Real scalaire = v_1*v_2;

    return acos(scalaire/(v_1.getNorme()*v_2.getNorme()));

}



//normaliser le vecteur /*********************************************************************************/

// ############################################################################



void LrVector::normalize()

{

    Real norme = calculNorme();
@@ -255,3 +310,5 @@ void LrVector::normalize() 
    y = (Real)y/norme;

    z = (Real)z/norme;

}



// ############################################################################

LrVector.h

+267 −126
Original line number Diff line number Diff line 
/**

 * @brief OBJET : un vecteur 3D

 * @brief Classe pour la gestion des vecteurs

 * @file LrVector.h

 * @date Vendredi 7 mars 2008

 * @note 

 * @author Josselin Francois

 * @author Michael Nauge

 * @author Axel Richard

 * @author Hervé Souchaud



 * @author Emeric Verschuur

 * 

 * Ce fichier contient la classe qui gère la creation d'un vecteur 3D     

 */



#ifndef LR_VECTOR_H

#define LR_VECTOR_H



#include <math.h>

#include <math.h>

#include "global.h"



class LrPoint;







/**

 * @brief OBJET : Classe pour la gestion des vecteurs

 * 

 * Ce fichier contient la classe qui gère la creation d'un vecteur 3D  

 */

class LrVector

{

    private :

        /**calculer la norme

        *@param carre : parametre par defaut pour definir si on souhaite obtenir la nomre au carre

        */

        Real calculNorme(bool carre = false) const;



public :



        /**Constantes*/

    ///@brief VECTEUR ZERO

    static const LrVector ZERO;

    ///@brief VECTEUR I

    static const LrVector I;

    ///@brief VECTEUR J

    static const LrVector J;

    ///@brief VECTEUR K

    static const LrVector K;





    //NB : exceptionnellement les membres sont public

        /** composantes x, y et z du vecteur*/

        Real x, y, z;

    ///@brief Composantes x du vecteur

    Real x;

    ///@brief Composantes y du vecteur

    Real y;

    ///@brief Composantes z du vecteur

    Real z;



        /**constructeur par defaut*/

    /**

     * @brief LrVector constructor

     */

    LrVector();

        /**constructeur par copie*/

        LrVector (const LrVector &);

        /**Constructeur personnel

        *@param x : composante x

        *@param y : composante y

        *@param z : composante z

    

    /**

     * @brief LrVector copy constructor

     * @param source LrVector object reference

     */

    LrVector(const LrVector &source);

    

    /**

     * @brief LrVector personnal constructor

     * @param x composante x du vecteur (Real)

     * @param y composante y du vecteur (Real)

     * @param z composante z du vecteur (Real)

     */

    LrVector(Real x, Real y, Real z);



    /**

     * @brief LrVector personnal constructor : construit un vecteur a partir 

     * @brief de 2 poiints (LrPoint)

     * @param A point d'origine

     * @param B point d'arrivée

     */

    LrVector(const LrPoint &A, const LrPoint &B);

        /**destructeur*/

    

    /**

     * @brief LrColor destructor

     */

    virtual ~LrVector();



        /**calcul de l'angle form� par 2 vecteurs

    /**

     * @brief Methode statique qui calcul l'angle formé par 2 vecteurs

     * @param v_1 : vecteur 1

     * @param v_2 : vecteur 2

     */

    static Real calculAngle(const LrVector & v_1, const LrVector & v_2);



        /**obtenir une des composante du vecteur

    /**

     * @brief Accesseur pour obtenir une des composante du vecteur

     * @param compo : la composante (1 pour x, 2 pour y, 3 pour z)

     * @return Real : la valeur de la composante

     */

    Real getCompo(int compo) const;



        /**modifier une des composante du vecteur

    /**

     * @brief Methode pour modifier une des composante du vecteur

     * @param compo : la composante (1 pour x, 2 pour y, 3 pour z)

     * @param val : la valeur de la composante

     */

    void setComposante(int compo, Real val);

        /**modifier les composantes du vecteur

    

    /**

     * @brief Methode pour modifier modifier les composantes du vecteur

     * @param valx : la valeur de la composante x

     * @param valy : la valeur de la composante y

     * @param valz : la valeur de la composante z

     */

    void setComposante(Real valx, Real valy, Real valz);

        /**obtenir la norme du vecteur

    

    /**

     * @brief Accesseur pour obtenir la norme du vecteur

     * @return Real : la norme

     */

    Real getNorme() const;

        /**obtenir la norme au carre du vecteur

    

    /**

     * @brief Accesseur pour obtenir la norme au carre du vecteur

     * @return Real : la norme au carre

     */

    Real getNormeCarre() const;



        /**appliquer plusieur fois un vecteur au vecteur courant

    /**

     * @brief Methode pour appliquer plusieur fois un vecteur au vecteur courant

     * @param vs : le vecteur

     * @param nbFois : le nombre de multiplication

     */

    void addXfois(const LrVector & vs, Real nbFois);



        /**normaliser le vecteur*/

    /**

     * @brief Methode pour normaliser le vecteur

     */

    void normalize();



        LrVector & operator = (const LrVector &);

    /**

     * @brief Opérateur d'affectation

     * @param source LrVector modèle

     * @return Retourne un nouveau LrVector

     */

    LrVector & operator = (const LrVector &source);

    

    /**

     * @brief Opérateur d'addition et d'affectation

     * @param source LrVector modèle

     * @return Retourne un nouveau LrVector

     */

    LrVector & operator += (const LrVector &source);

    

    /**

     * @brief Opérateur d'addition et d'affectation

     * @param t Real modèle

     * @return Retourne un nouveau LrVector

     */

    LrVector & operator += (const Real t);

        LrVector & operator -= (const LrVector &);

    

        friend bool operator == (const LrVector & v_1, const LrVector & v_2);

        friend bool operator != (const LrVector & v_1, const LrVector & v_2);

    /**

     * @brief Opérateur de soustraction et d'affectation

     * @param source LrVector modèle

     * @return Retourne un nouveau LrVecto

     */

    LrVector & operator -= (const LrVector &source);



    /**

     * @brief Opérateur d'égalité

     * @param lhs Opérande gauche de type LrVector

     * @param rhs Opérande droite de type LrVector

     * @return Retourne vrai si lhs et rhs sont égaux

     */ 

    friend bool operator == (const LrVector &lhs, const LrVector &rhs);

    

        friend LrVector operator + (const LrVector & v_1, const LrVector & v_2);

    /**

     * @brief Opérateur d'égalité

     * @param lhs Opérande gauche de type LrVector

     * @param rhs Opérande droite de type LrVector

     * @return Retourne vrai si lhs et rhs sont différe,ts

     */ 

    friend bool operator != (const LrVector &lhs, const LrVector &rhs);



    /**

     * @brief Opérateur d'addition

     * @param lhs Opérande gauche de type LrVector

     * @param rhs Opérande droite de type LrVector

     * @return Retourne un nouveau LrVector

     */

    friend LrVector operator + (const LrVector &lhs, const LrVector &rhs);

    

    /**

     * @brief Opérateur d'addition

     * @param t Opérande gauche de type Real

     * @param v Opérande droite de type LrVector

     * @return Retourne un nouveau LrVector

     */

    friend LrVector operator + (const Real t, const LrVector &v);

    

    /**

     * @brief Opérateur d'addition

     * @param v Opérande gauche de type LrVector

     * @param t Opérande droite de type Real

     * @return Retourne un nouveau LrVector

     */

    friend LrVector operator + (const LrVector &v, const Real t);



        friend LrVector operator - (const LrVector & v_1, const LrVector & v_2);

        /**vecteur dans la direction opposée*/

    /**

     * @brief Opérateur de soustraction

     * @param lhs Opérande gauche de type LrVector

     * @param rhs Opérande droite de type LrVector

     * @return Retourne un nouveau LrVector

     */

    friend LrVector operator - (const LrVector &lhs, const LrVector &rhs);



    /**

     * @brief Opérateur de soustraction (vecteur dans la direction opposée)

     * @param v vecteur de type LrVector

     * @return Retourne un nouveau LrVector

     */

    friend LrVector operator - (const LrVector & v);

        /**produit scalaire*/

        friend Real operator * (const LrVector & v_1, const LrVector & v_2);

        /**multiplication par un scalaire*/

        friend LrVector operator * (const LrVector & v_1, Real scalaire);

    

    /**

     * @brief Opérateur de multiplication (produit scalaire)

     * @param lhs Opérande gauche de type LrVector

     * @param rhs Opérande droite de type LrVector

     * @return Retourne un Real

     */

    friend Real operator * (const LrVector &lhs, const LrVector &rhs);

    

    /**

     * @brief Opérateur de multiplication (multiplication par un scalaire)

     * @param lhs Opérande gauche de type LrVector

     * @param scalaire Opérande droite de type Real

     * @return Retourne un nouveau LrVector

     */

    friend LrVector operator * (const LrVector &lhs, Real scalaire);

    

    /**

     * @brief Opérateur de multiplication (multiplication par un scalaire)

     * @param scalaire Opérande gauche de type Real

     * @param lhs Opérande droite de type LrVector

     * @return Retourne un nouveau LrVector

     */    

    friend LrVector operator * (Real scalaire, const LrVector & v);



    /**

     * @brief Opérateur de division

     * @param v Opérande gauche de type LrVector

     * @param t Opérande droite de type Real

     * @return Retourne un nouveau LrVector

     */ 

    friend LrVector operator / (const LrVector &v, const Real t);

         /**produit vectoriel*/

        friend LrVector operator ^ (const LrVector & v_1, const LrVector & v_2);

    

    /**

     * @brief Opérateur de multiplication (produit vectoriel)

     * @param lhs Opérande gauche de type LrVector

     * @param rhs Opérande droite de type LrVector

     * @return Retourne un nouveau LrVector

     */

    friend LrVector operator ^ (const LrVector &lhs, const LrVector &rhs);

    

private :

    /**

     * calculer la norme

     * carre : parametre par defaut pour definir si on souhaite obtenir la 

     * norme au carre

     */

    Real calculNorme(bool carre = false) const;

};



#endif