--no commit message

--no commit message

LrBinder.cpp

+/**
+ * @brief OBJET : represente un octree pour la structure acceleratrice
+ * @file LrOctree.h
+ * @date Lundi 10 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 octree
+ */
+
+#if defined HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "LrBinder.h"
+
+LrBinder::LrBinder()
+: m_liste_objets(), m_globalOctree(NULL)
+{
+
+}
+
+LrBinder::LrBinder(const LrBinder & source)
+:  m_liste_objets(source.m_liste_objets), m_globalOctree(source.m_globalOctree)
+{
+
+}
+
+LrBinder::LrBinder(LISTE_OBJETS l, LrVector pos_init, LrVector &taille)
+: m_liste_objets(l), m_globalOctree(new LrOctree(NULL, pos_init, taille.getNorme()))
+{
+
+} 
+
+~LrBinder()
+{
+
+}
+
+void LrBinder::initBinder()
+{
+    
+} 
+
+void LrBinder::createSubdiv(LrOctree &oct, Real taille)
+{
+    for(int i=0; i < 8; i++)
+    {
+        oct.addOctree(new LrOctree(*this,  
+    }
+}

LrBinder.h

+/**
+ * @brief OBJET : represente la structure acceleratrice
+ * @file LrOctree.h
+ * @date Lundi 10 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'une structure acceleratrice pour la gestion des objets 3D
+ */ 
+
+#ifndef LRBINDER_H
+#define LRBINDER_H
+
+#include "LrOctree.h"
+#include "LrVecteur.h"
+#include "LrObject.h"
+
+#define MAX_DIV 4
+
+class LrBinder
+{
+    private :
+
+        LISTE_OBJETS m_liste_objets;//la liste d'objet
+        LrOctree *m_globalOctree; //un pointer sur la boite englobante principale
+
+    public :
+            typedef list<LrObject *> LISTE_OBJETS;
+
+            LrBinder();
+            LrBinder(const LrBinder & source);
+            LrBinder(LISTE_OBJETS l, LrVector pos_init, LrVector &taille);
+            
+            virtual ~LrBinder();
+
+            void initBinder(int subdivision);//creation de la structure accélatrice type Grille reguliere
+};
+#endif
+            
\ No newline at end of file

LrMatrix.cpp

@@ -147,19 +147,19 @@ operator * (const LrMatrix &lhs, const LrMatrix &rhs)
     return result;
 }
 
-LrPoint3d
-operator * (const LrMatrix &lhs, const LrPoint3d &rhs)
+LrPoint
+operator * (const LrMatrix &lhs, const LrPoint &rhs)
 {
-    return LrPoint3d(
+    return LrPoint(
         lhs.m11 * rhs.x + lhs.m12 * rhs.y + lhs.m13 * rhs.z + lhs.m14,
         lhs.m21 * rhs.x + lhs.m22 * rhs.y + lhs.m23 * rhs.z + lhs.m24,        
         lhs.m31 * rhs.x + lhs.m32 * rhs.y + lhs.m33 * rhs.z + lhs.m34);       
 }
 
-LrVector3d
-operator * (const LrMatrix &lhs, const LrVector3d &rhs)
+LrVector
+operator * (const LrMatrix &lhs, const LrVector &rhs)
 {
-    return LrVector3d(
+    return LrVector(
         lhs.m11 * rhs.x + lhs.m12 * rhs.y + lhs.m13 * rhs.z,
         lhs.m21 * rhs.x + lhs.m22 * rhs.y + lhs.m23 * rhs.z,        
         lhs.m31 * rhs.x + lhs.m32 * rhs.y + lhs.m33 * rhs.z);       
@@ -221,7 +221,7 @@ LrMatrix::scale(Real scaleX, Real scaleY, Real scaleZ)
 }
 
 LrMatrix
-LrMatrix::translate(const LrVector3d &v)
+LrMatrix::translate(const LrVector &v)
 {
     return LrMatrix(1.0, 0.0, 0.0, v.x,
                     0.0, 1.0, 0.0, v.y,
@@ -271,7 +271,7 @@ LrMatrix::rotateZ(Real cosinus, Real sinus)
 }
 
 LrMatrix
-LrMatrix::rotate(const LrPoint3d &center, const LrVector3d &axis,
+LrMatrix::rotate(const LrPoint &center, const LrVector &axis,
                 Real angle)
 {
     return rotate(center, axis, cos(angle), sin(angle));
@@ -279,8 +279,8 @@ LrMatrix::rotate(const LrPoint3d &center, const LrVector3d &axis,
 
 /*
  * soient O' le point de la droite (i.e. center)
- *        O l'origine du repre
- *        (phi, theta) les coordonnes polaires de axis
+ *        O l'origine du rep�re
+ *        (phi, theta) les coordonn�es polaires de axis
  *            phi : angle entre Ox et la projection de axis sur Oxy
  *            theta : angle entre 0z et axis
  *        c = cosinus
@@ -303,10 +303,10 @@ LrMatrix::rotate(const LrPoint3d &center, const LrVector3d &axis,
  * et donc il faut multiplier les matrices dans l'autre sens
  */
 LrMatrix
-LrMatrix::rotate(const LrPoint3d &center, const LrVector3d &axis,
+LrMatrix::rotate(const LrPoint &center, const LrVector &axis,
                  Real cosinus, Real sinus)
 {
-    LrVector3d a = axis;
+    LrVector a = axis;
     a.normalize();
 
     Real x = a.x;
@@ -315,20 +315,20 @@ LrMatrix::rotate(const LrPoint3d &center, const LrVector3d &axis,
     Real c = cosinus;
     Real s = sinus;
 
-    LrMatrix TtoO = translate(LrVector3d(center, LrPoint3d::ZERO));
+    LrMatrix TtoO = translate(LrVector(center, LrPoint::ZERO));
     LrMatrix R(x*x*(1-c)+c,   x*y*(1-c)-z*s, x*z*(1-c)+y*s, 0.0,
                x*y*(1-c)+z*s, y*y*(1-c)+c,   y*z*(1-c)-x*s, 0.0,
                x*z*(1-c)-y*s, y*z*(1-c)+x*s, z*z*(1-c)+c,   0.0);
-    LrMatrix TfromO = translate(LrVector3d(LrPoint3d::ZERO, center));
+    LrMatrix TfromO = translate(LrVector(LrPoint::ZERO, center));
 
     return TfromO * R * TtoO;
 }
 
 LrMatrix
-LrMatrix::frameToFrame(const LrPoint3d &o1, const LrVector3d &u1,
-                       const LrVector3d &v1, const LrVector3d &w1,
-                       const LrPoint3d &o2, const LrVector3d &u2,
-                       const LrVector3d &v2, const LrVector3d &w2)
+LrMatrix::frameToFrame(const LrPoint &o1, const LrVector &u1,
+                       const LrVector &v1, const LrVector &w1,
+                       const LrPoint &o2, const LrVector &u2,
+                       const LrVector &v2, const LrVector &w2)
 {
     LrMatrix F1toF(u1.x, v1.x, w1.x, o1.x,
                    u1.y, v1.y, w1.y, o1.y,
@@ -342,11 +342,11 @@ LrMatrix::frameToFrame(const LrPoint3d &o1, const LrVector3d &u1,
 }
 
 LrMatrix
-LrMatrix::projectOnPlane(const LrPoint3d &o, const LrVector3d &normal)
+LrMatrix::projectOnPlane(const LrPoint &o, const LrVector &normal)
 {
-    LrVector3d n = normal;
+    LrVector n = normal;
     n.normalize();
-    Real prod = LrVector3d(LrPoint3d::ZERO, o) * n;
+    Real prod = LrVector(LrPoint::ZERO, o) * n;
     
     return LrMatrix(1-n.x*n.x, -n.x*n.y,  -n.x*n.z,  n.x*prod,
                     -n.x*n.y,  1-n.y*n.y, -n.y*n.z,  n.y*prod,
@@ -354,11 +354,11 @@ LrMatrix::projectOnPlane(const LrPoint3d &o, const LrVector3d &normal)
 }
 
 LrMatrix
-LrMatrix::projectOnLine(const LrPoint3d &o, const LrVector3d &direction)
+LrMatrix::projectOnLine(const LrPoint &o, const LrVector &direction)
 {
-    LrVector3d d = direction;
+    LrVector d = direction;
     d.normalize();
-    Real prod = LrVector3d(LrPoint3d::ZERO, o) * d;
+    Real prod = LrVector(LrPoint::ZERO, o) * d;
     
     return LrMatrix(d.x*d.x, d.x*d.y, d.x*d.z, o.x-d.x*prod,
                     d.x*d.y, d.y*d.y, d.y*d.z, o.y-d.y*prod,

LrMatrix.h

@@ -16,8 +16,8 @@
 #ifndef LRMATRIX_H
 #define LRMATRIX_H
 
-#include "LrPoint3d.h"
-#include "LrVector3d.h"
+#include "LrPoint.h"
+#include "LrVector.h"
 
 class LrMatrix
 {
@@ -52,8 +52,8 @@ public:
     // **************************
 
     friend LrMatrix operator * (const LrMatrix &lhs, const LrMatrix &rhs);
-    friend LrPoint3d operator * (const LrMatrix &lhs, const LrPoint3d &rhs);
-    friend LrVector3d operator * (const LrMatrix &lhs, const LrVector3d &rhs);
+    friend LrPoint operator * (const LrMatrix &lhs, const LrPoint &rhs);
+    friend LrVector operator * (const LrMatrix &lhs, const LrVector &rhs);
 
     // inverse matrix
     // **************
@@ -67,7 +67,7 @@ public:
     static LrMatrix scale(Real scaleXYZ);
     static LrMatrix scale(Real scaleX, Real scaleY, Real scaleZ);
     
-    static LrMatrix translate(const LrVector3d &v);
+    static LrMatrix translate(const LrVector &v);
     
     static LrMatrix rotateX(Real angle);
     static LrMatrix rotateX(Real cosinus, Real sinus);
@@ -75,20 +75,20 @@ public:
     static LrMatrix rotateY(Real cosinus, Real sinus);
     static LrMatrix rotateZ(Real angle);
     static LrMatrix rotateZ(Real cosinus, Real sinus);
-    static LrMatrix rotate(const LrPoint3d &center, const LrVector3d &axis,
+    static LrMatrix rotate(const LrPoint &center, const LrVector &axis,
                            Real angle);
-    static LrMatrix rotate(const LrPoint3d &center, const LrVector3d &axis,
+    static LrMatrix rotate(const LrPoint &center, const LrVector &axis,
                            Real cosinus, Real sinus);
     
-    static LrMatrix frameToFrame(const LrPoint3d &o1, const LrVector3d &u1,
-                                 const LrVector3d &v1, const LrVector3d &w1,
-                                 const LrPoint3d &o2, const LrVector3d &u2,
-                                 const LrVector3d &v2, const LrVector3d &w2);
+    static LrMatrix frameToFrame(const LrPoint &o1, const LrVector &u1,
+                                 const LrVector &v1, const LrVector &w1,
+                                 const LrPoint &o2, const LrVector &u2,
+                                 const LrVector &v2, const LrVector &w2);
     
-    static LrMatrix projectOnPlane(const LrPoint3d &o,
-                                   const LrVector3d &normal);
-    static LrMatrix projectOnLine(const LrPoint3d &o,
-                                  const LrVector3d &direction);
+    static LrMatrix projectOnPlane(const LrPoint &o,
+                                   const LrVector &normal);
+    static LrMatrix projectOnLine(const LrPoint &o,
+                                  const LrVector &direction);
 
     // accessors
     // *********

LrOctree.cpp

+/**
+ * @brief OBJET : represente un octree pour la structure acceleratrice
+ * @file LrOctree.h
+ * @date Lundi 10 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 octree
+ */
+
+#if defined HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "LrOctree.h"
+
+/*---------------------------------------------------------------------------*
+ * constructors and destructor                                               *
+ *---------------------------------------------------------------------------*/
+LrOctree::LrOctree()
+:
+    m_parent(NULL),
+    m_pos(),
+    m_taille(),
+    m_listeObj(),
+    m_listeOct()
+{
+    m_listeOct.resize(8);
+}
+
+LrOctree::LrOctree(const LrOctree &source)
+:
+    m_parent(source.m_parent),
+    m_pos(source.m_pos),
+    m_taille(source.m_taille),
+    m_listeObj(source.m_listeObj),
+    m_listeOct(source.m_listeOct)
+{
+
+}
+
+LrOctree *
+LrOctree::clone() const
+{
+    return new LrOctree(*this);
+}
+
+LrOctree::LrOctree(const LrOctree &parent, const LrVector &pos, const Real &taille)
+:
+    m_parent(&parent),
+    m_pos(pos),
+    m_taille(taille)
+{
+    m_listeOct.resize(8);
+}
+
+LrOctree::~LrOctree()
+{
+}
+
+
+/*---------------------------------------------------------------------------*
+ * assignement operator(s)                                                   *
+ *---------------------------------------------------------------------------*/
+LrOctree &
+LrOctree::operator = (const LrOctree &source)
+{
+    if (this == &source)
+        return *this;
+
+    m_parent = source.m_parent;
+    m_pos = source.m_pos;
+    m_taille = source.m_taille;
+    m_listeObj = source.m_listeObj;
+    m_listeOct = source.m_listeOct;
+
+    return *this;
+}
+
+
+/*---------------------------------------------------------------------------*
+ * comparison operator(s)                                                    *
+ *---------------------------------------------------------------------------*/
+bool
+operator == (const LrOctree &lhs, const LrOctree &rhs)
+{
+    bool res = ((*(lhs.m_parent)) == (*(rhs.m_parent))) && (lhs.m_pos == rhs.m_pos) && (lhs.m_taille == rhs.m_taille);
+
+    if((lhs.m_listeObj.size() != rhs.m_listeObj.size()) || (lhs.m_listeOct.size() != rhs.m_listeOct.size())) return false;
+
+    list<LrObject *>::iterator itObj_rhs = ((LrOctree &)rhs).m_listeObj.begin();
+    for(list<LrObject *>::iterator itObj_lhs = ((LrOctree &)lhs).m_listeObj.begin(); itObj_lhs != lhs.m_listeObj.end(); itObj_lhs++)
+    {
+        res = res && (*itObj_lhs == *itObj_rhs);
+        itObj_rhs++;
+    }
+
+    list<LrOctree *>::iterator itOct_rhs = ((LrOctree &)rhs).m_listeOct.begin();
+    list<LrOctree *>::iterator itOct_lhs;
+    for( itOct_lhs = ((LrOctree &)lhs).m_listeOct.begin(); itOct_lhs != lhs.m_listeOct.end(); itOct_lhs++)
+    {
+        res = res && (*itOct_lhs == *itOct_rhs);
+        itOct_rhs++;
+    }
+
+    return  res; 
+}
+
+bool
+operator != (const LrOctree &lhs, const LrOctree &rhs)
+{
+    return (! (lhs == rhs));
+}
+
+
+/*---------------------------------------------------------------------------*
+ * accessors                                                                 *
+ *---------------------------------------------------------------------------*/
+const LrOctree*
+LrOctree::getParent() const
+{
+    return m_parent;
+}
+
+void
+LrOctree::setParent(const LrOctree &parent)
+{
+    m_parent = &parent;
+}
+
+LrVector
+LrOctree::getPos() const
+{
+    return m_pos;
+}
+
+void
+LrOctree::setPos(const LrVector &pos)
+{
+    m_pos = pos;
+}
+
+Real
+LrOctree::getTaille() const
+{
+    return m_taille;
+}
+
+void
+LrOctree::setTaille(const Real &taille)
+{
+    m_taille = taille;
+}
+
+const LrOctree* LrOctree::getOctree(int index) const
+{
+    if(index < 8)
+    {
+        list<LrOctree *>::iterator it = ((LrOctree *)this)->m_listeOct.begin();
+        int i = 0;
+        while(i !=index) it++;
+       
+        return *it;
+    }
+    
+}
+
+void LrOctree::addOctree(LrOctree *oct)
+{
+    if(m_listeOct.size() != 8) m_listeOct.push_back(oct); 
+}
+
+void LrOctree::addObjet (LrObject *obj) 
+{
+    m_listeObj.push_back(obj);
+}
+
+LrObject* LrOctree::getObject(int index) const
+{
+    if(index < m_listeObj.size())
+    {
+        list<LrObject *>::iterator it = ((LrOctree *)this)->m_listeObj.begin();
+        int i = 0;
+        while(i !=index) it++;
+        return *it;
+    }
+}

LrOctree.h

+/**
+ * @brief OBJET : represente un octree pour la structure acceleratrice
+ * @file LrOctree.h
+ * @date Lundi 10 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 octree
+ */
+
+#ifndef LROCTREE_H
+#define LROCTREE_H
+
+#include <list>
+#include "LrVector.h"
+#include "LrObject.h"
+#include "global.h"
+
+using namespace std;
+
+class LrOctree
+{
+    private:
+
+        // data
+        // ****
+        const LrOctree *m_parent;
+        LrVector m_pos;
+        Real m_taille;
+        list<LrObject *> m_listeObj;
+        list<LrOctree *> m_listeOct;
+
+    public:
+
+        typedef list<LrObject *> LISTE_OBJETS;
+        typedef list<LrOctree *> LISTE_OCTREES_SONS;
+        // constructors and destructor
+        // ***************************
+    
+        LrOctree();
+        LrOctree(const LrOctree &source);
+        LrOctree * clone() const;
+        LrOctree(const LrOctree &parent, const LrVector &pos, const Real &taille);
+    
+        virtual ~LrOctree();
+    
+        // assignement operator(s)
+        // ***********************
+    
+        LrOctree & operator = (const LrOctree &source);
+    
+        // comparison operator(s)
+        // **********************
+    
+        friend bool operator == ( const LrOctree &lhs,  const LrOctree &rhs);
+        friend bool operator != ( const LrOctree &lhs,  const LrOctree &rhs);
+    
+        // accessors
+        // *********
+    
+        const LrOctree* getParent() const;
+        void setParent(const LrOctree &parent);
+    
+        LrVector getPos() const;
+        void setPos(const LrVector &pos);
+    
+        Real getTaille() const;
+        void setTaille(const Real &taille);
+    
+        const LrOctree* getOctree(int index) const;
+        void addOctree(LrOctree *oct);
+    
+        void addObjet (LrObject *obj);
+        LrObject* getObject(int index) const;
+
+};
+
+#endif

LrVector.h

@@ -16,6 +16,7 @@
 #define VECTEURS_H
 
 #include <math.h>
+#include "global.h"
 
 class LrPoint;
 

Old/LrColor.h

+/*****************************************************************************
+ * class LrColor (specification)                                             *
+ *                                                                           *
+ * author : Gilles Subrenat                                                  *
+ * creation : Sunday, March 2 2008 (3/2/2008)                                *
+ * note :                                                                    *
+ *****************************************************************************/
+
+#ifndef LRCOLOR_H
+#define LRCOLOR_H
+
+class LrColor
+{
+public:
+
+    static const LrColor BLACK;
+    static const LrColor WHITE;
+    static const LrColor RED;
+    static const LrColor GREEN;
+    static const LrColor BLUE;
+    static const LrColor CYAN;
+    static const LrColor MAGENTA;
+    static const LrColor YELLOW;
+
+    // constructors and destructor
+    // ***************************
+
+    LrColor();
+    LrColor(const LrColor &source);
+    LrColor(Real red, Real green, Real blue);
+    explicit LrColor(Real grey);
+
+    virtual ~LrColor();
+
+    // assignement operator(s)
+    // ***********************
+
+    LrColor & operator = (const LrColor &source);
+    LrColor & operator += (const LrColor &source);
+    LrColor & operator += (Real grey);
+    LrColor & operator -= (const LrColor &source);
+    LrColor & operator -= (Real grey);
+    LrColor & operator *= (const LrColor &source);
+    LrColor & operator *= (Real factor);
+    LrColor & operator /= (Real factor);
+
+    // comparison operator(s)
+    // **********************
+
+    friend bool operator == (const LrColor &lhs, const LrColor &rhs);
+    friend bool operator != (const LrColor &lhs, const LrColor &rhs);
+
+    // "mathematical" operator(s)
+    // **************************
+
+    friend LrColor operator + (const LrColor &lhs, const LrColor &rhs);
+    friend LrColor operator + (Real lhs, const LrColor &rhs);
+    friend LrColor operator + (const LrColor &lhs, Real rhs);
+    friend LrColor operator - (const LrColor &lhs, const LrColor &rhs);
+    friend LrColor operator - (Real lhs, const LrColor &rhs);
+    friend LrColor operator - (const LrColor &lhs, Real rhs);
+    friend LrColor operator * (const LrColor &lhs, const LrColor &rhs);
+    friend LrColor operator * (Real lhs, const LrColor &rhs);
+    friend LrColor operator * (const LrColor &lhs, Real rhs);
+    friend LrColor operator / (const LrColor &lhs, Real rhs);
+
+    // accessors
+    // *********
+
+    Real getRed() const;
+    void setRed(Real red);
+    Real getGreen() const;
+    void setGreen(Real green);
+    Real getBlue() const;
+    void setBlue(Real blue);
+    void setRGB(Real red, Real green, Real blue);
+    Real getGrey() const;
+    void setGrey(Real grey);
+    Real getLuminosity() const;
+
+
+private:
+
+    // data
+    // ****
+
+    Real m_red;
+    Real m_green;
+    Real m_blue;
+};
+
+#endif