Commit 3a1bbc43 authored by paps's avatar paps

--no commit message

--no commit message
parent 0b795523
#include "LrPoint.h"
/*---------------------------------------------------------------------------*
* constructors and destructor *
*---------------------------------------------------------------------------*/
LrPoint::LrPoint()
:x(0), y(0), z(0)
{
}
LrPoint::LrPoint(const LrPoint &source)
:x(source.x), y(source.y), z(source.z)
{
}
LrPoint::LrPoint(Real x, Real y, Real z)
:x(x), y(y), z(z)
{
}
LrPoint::~LrPoint()
{
}
void LrPoint::translate(const LrVector &v)
{
x+=v.getCompo(X);
y+=v.getCompo(Y);
z+=v.getCompo(Z);
}
/*---------------------------------------------------------------------------*
* assignement operator(s) *
*---------------------------------------------------------------------------*/
LrPoint & LrPoint::operator = (const LrPoint &source)
{
if(this == &source) return (*this);
this->x = source.x;
this->y = source.y;
this->z = source.z;
return (*this);
}
/*---------------------------------------------------------------------------*
* comparison operator(s) *
*---------------------------------------------------------------------------*/
bool operator == (const LrPoint &lhs, const LrPoint &rhs)
{
return ((lhs.x == rhs.x) && (lhs.y == rhs.y) && (lhs.z == rhs.z));
}
bool operator != (const LrPoint &lhs, const LrPoint &rhs)
{
return !((lhs.x == rhs.x) && (lhs.y == rhs.y) && (lhs.z == rhs.z));
}
/*---------------------------------------------------------------------------*
* methodes de classe *
*---------------------------------------------------------------------------*/
static Real distance(const LrPoint &p1, const LrPoint &p2)
{
return sqrt(pow((p2.x - p1.x),2)+ pow((p2.y - p1.y),2)+ pow((p2.z - p1.z),2));
}
static LrPoint middle(const LrPoint &p1, const LrPoint &p2)
{
LrPoint point((p2.x - p1.x), (p2.y - p1.y), (p2.z - p1.z));
return point;
}
static LrPoint interpolate(Real t, const LrPoint &p1,const LrPoint &p2)
{
}
static LrPoint translate( const LrPoint &p, const LrVector &v)
{
LrPoint point;
point.x = x + v.getCompo(X);
point.y = y + v.getCompo(Y);
point.z = z + v.getCompo(Z);
return point;
}
\ No newline at end of file
/*****************************************************************************
* class LrPoint3d (specification) *
* class LrPoint (specification) *
* *
* author : Gilles Subrenat *
* creation : Sunday, March 2 2008 (3/2/2008) *
......@@ -9,40 +9,42 @@
#ifndef LRPOINT3D_H
#define LRPOINT3D_H
class LrVector3d;
#include "config.h"
class LrVector;
class LrPoint3d
class LrPoint
{
public:
// constants
// *********
static const LrPoint3d ZERO;
static const LrPoint3d I;
static const LrPoint3d J;
static const LrPoint3d K;
static const LrPoint ZERO;
static const LrPoint I;
static const LrPoint J;
static const LrPoint K;
// constructors and destructor
// ***************************
LrPoint3d();
LrPoint3d(const LrPoint3d &source);
LrPoint3d(Real x, Real y, Real z);
LrPoint();
LrPoint(const LrPoint &source);
LrPoint(Real x, Real y, Real z);
virtual ~LrPoint3d();
virtual ~LrPoint();
// assignement operator(s)
// ***********************
LrPoint3d & operator = (const LrPoint3d &source);
LrPoint & operator = (const LrPoint &source);
// comparison operator(s)
// **********************
friend bool operator == (const LrPoint3d &lhs, const LrPoint3d &rhs);
friend bool operator != (const LrPoint3d &lhs, const LrPoint3d &rhs);
friend bool operator == (const LrPoint &lhs, const LrPoint &rhs);
friend bool operator != (const LrPoint &lhs, const LrPoint &rhs);
// accessors
// *********
......@@ -61,12 +63,11 @@ public:
// miscellaneous functions
// ***********************
static Real distance(const LrPoint3d &p1, const LrPoint3d &p2);
static LrPoint3d middle(const LrPoint3d &p1, const LrPoint3d &p2);
static LrPoint3d interpolate(Real t, const LrPoint3d &p1,
const LrPoint3d &p2);
static LrPoint3d translate( const LrPoint3d &p, const LrVector3d &v);
void translate(const LrVector3d &v);
static Real distance(const LrPoint &p1, const LrPoint &p2);
static LrPoint middle(const LrPoint &p1, const LrPoint &p2);
static LrPoint interpolate(Real t, const LrPoint &p1, const LrPoint &p2);
static LrPoint translate( const LrPoint &p, const LrVector &v);
void translate(const LrVector &v);
// data
......
......@@ -3,57 +3,65 @@
////////////////////////////// CONSTRUCTEURS ///////////////////////////////////////////////////////
//Par defaut
Vecteur::Vecteur()
LrVector::LrVector()
{
composantes[0]= 0;
composantes[1]= 0;
composantes[2]= 0;
composantes[X]= 0;
composantes[Y]= 0;
composantes[Z]= 0;
norme = 0;
}
//Par copie ////////////////////////////////////////////////////////////////////////////////////////
Vecteur::Vecteur(const Vecteur & source)
LrVector::LrVector(const LrVector & source)
{
composantes[0]= source.getCompo(0);
composantes[1]= source.getCompo(1);
composantes[2]= source.getCompo(2);
composantes[X]= source.getCompo(X);
composantes[Y]= source.getCompo(Y);
composantes[Z]= source.getCompo(Z);
norme =source.getNorme();
}
//Personel ////////////////////////////////////////////////////////////////////////////////////////
Vecteur::Vecteur (float x, float y, float z)
LrVector::LrVector (float x, float y, float z)
{
composantes[0]= x;
composantes[1]= y;
composantes[2]= z;
composantes[X]= x;
composantes[Y]= y;
composantes[Z]= z;
calculNorme();
}
//Constructeur d'un vecteur à partir de 2 points //////////////////////////////////////////////////
LrVector::LrVector (const LrPoint & A, const LrPoint & B)
{
composantes[X] = B.x - A.x;
composantes[Y] = B.y - A.y;
composantes[Z] = B.z - A.z;
calculNorme();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
Vecteur::~Vecteur()
LrVector::~LrVector()
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
float Vecteur::getCompo(int compo) const
float LrVector::getCompo(int compo) const
{
return composantes[compo];
}
////////////////////////////////////////////////////////////////////////////////////////
float Vecteur::getNorme() const
float LrVector::getNorme() const
{
return norme;
}
////////////////////////////////////////////////////////////////////////////////////////
void Vecteur::calculNorme()
void LrVector::calculNorme()
{
norme = sqrt(pow(composantes[0],2)+ pow(composantes[1],2)+ pow(composantes[2],2));
norme = sqrt(pow(composantes[X],2)+ pow(composantes[Y],2)+ pow(composantes[Z],2));
}
////////////////////////////////////////////////////////////////////////////////////////
void Vecteur::setComposante(int compo, float valeur)
void LrVector::setComposante(int compo, float valeur)
{
composantes[compo] = valeur;
calculNorme();
}
////////////////////////////////////////////////////////////////////////////////////////
void Vecteur::addXfois(const Vecteur & vs, float nbFois)
void LrVector::addXfois(const LrVector & vs, float nbFois)
{
for(int i=0;i<nbFois;i++)
{
......@@ -61,110 +69,110 @@ void Vecteur::addXfois(const Vecteur & vs, float nbFois)
}
}
////////////////////////////////////////////////////////////////////////////////////////
Vecteur & Vecteur::operator = (const Vecteur & source)
LrVector & LrVector::operator = (const LrVector & source)
{
if(this == &source) return (*this);
composantes[0]= source.getCompo(0);
composantes[1]= source.getCompo(1);
composantes[2]= source.getCompo(2);
composantes[X]= source.getCompo(X);
composantes[Y]= source.getCompo(Y);
composantes[Z]= source.getCompo(Z);
norme =source.getNorme();
return (*this);
}
////////////////////////////////////////////////////////////////////////////////////////
Vecteur & Vecteur::operator += (const Vecteur & source)
LrVector & LrVector::operator += (const LrVector & source)
{
composantes[0] += source.getCompo(0);
composantes[1] += source.getCompo(1);
composantes[2] += source.getCompo(2);
composantes[X] += source.getCompo(X);
composantes[Y] += source.getCompo(Y);
composantes[Z] += source.getCompo(Z);
norme =source.getNorme();
return (*this);
}
////////////////////////////////////////////////////////////////////////////////////////
Vecteur & Vecteur::operator -= (const Vecteur & source)
LrVector & LrVector::operator -= (const LrVector & source)
{
composantes[0] -= source.getCompo(0);
composantes[1] -= source.getCompo(1);
composantes[2] -= source.getCompo(2);
composantes[X] -= source.getCompo(X);
composantes[Y] -= source.getCompo(Y);
composantes[Z] -= source.getCompo(Z);
norme =source.getNorme();
return (*this);
}
////////////////////////////////////////////////////////////////////////////////////////
Vecteur operator + (const Vecteur & v_1, const Vecteur & v_2)
LrVector operator + (const LrVector & v_1, const LrVector & v_2)
{
Vecteur tmp(v_1);
LrVector tmp(v_1);
tmp += v_2;
return tmp;
}
Vecteur operator - (const Vecteur & v_1, const Vecteur & v_2)
LrVector operator - (const LrVector & v_1, const LrVector & v_2)
{
Vecteur tmp(v_1);
LrVector tmp(v_1);
tmp -= v_2;
return tmp;
}
//produit scalaire ////////////////////////////////////////////////////////////////////////////////////////
float operator * (const Vecteur & v_1, const Vecteur & v_2)
float operator * (const LrVector & v_1, const LrVector & v_2)
{
return ((v_1.composantes[0] * v_2.composantes[0]) +
(v_1.composantes[1] * v_2.composantes[1]) +
(v_1.composantes[2] * v_2.composantes[2]));
return ((v_1.composantes[X] * v_2.composantes[X]) +
(v_1.composantes[Y] * v_2.composantes[Y]) +
(v_1.composantes[Z] * v_2.composantes[Z]));
}
//multiplication par un scalaire ////////////////////////////////////////////////////////////////////////////////////////
Vecteur operator * (const Vecteur & v_1, float scalaire)
LrVector operator * (const LrVector & v_1, float scalaire)
{
Vecteur tmp(v_1);
tmp.composantes[0] = tmp.composantes[0]*scalaire;
tmp.composantes[1] = tmp.composantes[1]*scalaire;
tmp.composantes[2] = tmp.composantes[2]*scalaire;
LrVector tmp(v_1);
tmp.composantes[X] = tmp.composantes[X]*scalaire;
tmp.composantes[Y] = tmp.composantes[Y]*scalaire;
tmp.composantes[Z] = tmp.composantes[Z]*scalaire;
return tmp;
}
////////////////////////////////////////////////////////////////////////////////////////
Vecteur operator * (float scalaire, const Vecteur & v)
LrVector operator * (float scalaire, const LrVector & v)
{
return v*scalaire;
}
//produit vectoriel ////////////////////////////////////////////////////////////////////////////////////////
Vecteur operator ^ (const Vecteur & v_1, const Vecteur & v_2)
LrVector operator ^ (const LrVector & v_1, const LrVector & v_2)
{
Vecteur tmp;
tmp.composantes[0] = (v_1.composantes[1]*v_2.composantes[2]) - (v_1.composantes[2]*v_2.composantes[1]);
tmp.composantes[1] = (v_1.composantes[2]*v_2.composantes[0]) - (v_1.composantes[0]*v_2.composantes[2]);
tmp.composantes[2] = (v_1.composantes[0]*v_2.composantes[1]) - (v_1.composantes[1]*v_2.composantes[0]);
LrVector tmp;
tmp.composantes[X] = (v_1.composantes[Y]*v_2.composantes[Z]) - (v_1.composantes[Z]*v_2.composantes[Y]);
tmp.composantes[Y] = (v_1.composantes[Z]*v_2.composantes[X]) - (v_1.composantes[X]*v_2.composantes[Z]);
tmp.composantes[Z] = (v_1.composantes[X]*v_2.composantes[Y]) - (v_1.composantes[Y]*v_2.composantes[X]);
return tmp;
}
////////////////////////////////////////////////////////////////////////////////////////
float calculAngle(const Vecteur & v_1, const Vecteur & v_2)
float calculAngle(const LrVector & v_1, const LrVector & v_2)
{
float scalaire = v_1*v_2;
return acos(scalaire/(v_1.getNorme()*v_2.getNorme()));
}
/*
//somme
Vecteur Vecteur::somm(const Vecteur &) const
LrVector LrVector::somm(const LrVector &) const
{
}
//soustraction
Vecteur Vecteur::sous(const Vecteur &) const
LrVector LrVector::sous(const LrVector &) const
{
}
//produit vectoriel
Vecteur Vecteur::prodVectoriel(const Vecteur &) const
LrVector LrVector::prodVectoriel(const LrVector &) const
{
}
//produit scalaire
Vecteur Vecteur::prodScalaire(const Vecteur &) const
LrVector LrVector::prodScalaire(const LrVector &) const
{
}
//multiplication par un scalaire
Vecteur Vecteur::multScalaire(float scalaire)
LrVector LrVector::multScalaire(float scalaire)
{
}
*/
//normaliser le vecteur ////////////////////////////////////////////////////////////////////////////////////////
void Vecteur::normaliser()
void LrVector::normaliser()
{
composantes[0] /= norme;
composantes[1] /= norme;
composantes[2] /= norme;
composantes[Z] /= norme;
composantes[Y] /= norme;
composantes[Z] /= norme;
norme=1;
}
......@@ -2,18 +2,20 @@
#define VECTEURS_H
#include <math.h>
#include "config.h"
#define X 0;
#define Y 1;
#define Z 2;
class Vecteur
class LrPoint;
class LrVector
{
private :
float composantes[3];
float norme;
Real composantes[3];
Real norme;
//calculer la norme
void calculNorme();
......@@ -23,63 +25,62 @@ class Vecteur
// CONSTRUCTEURS ///////////////////////////////////////////////////////////////////////////
//Constructeur par defaut
Vecteur ();
LrVector ();
//constructeur par copie
Vecteur (const Vecteur &);
LrVector (const LrVector &);
//Constructeur personnel
Vecteur (float x, float y, float z);
virtual ~Vecteur();
LrVector (Real x, Real y, Real z);
//Constructeur d'un vecteur à partir de 2 points
LrVector (const LrPoint & A, const LrPoint & B);
virtual ~LrVector();
// calcul de l'angle form� par 2 vecteurs
static float calculAngle(const Vecteur & v_1, const Vecteur & v_2);
static Real calculAngle(const LrVector & v_1, const LrVector & v_2);
// ACCESSEURS //////////////////////////////////////////////////////////////////////////////
//renvoie la norme du vecteur
float getNorme() const;
Real getNorme() const;
//renvoie la valeur d'une composante du vecteur suivant le param int compo qui peut valoir X, Y ou Z
float getCompo(int compo) const;
Real getCompo(int compo) const;
//renvoie une copie de l'ensemble des composantes
float* getComposantes() const;
Real* getComposantes() const;
//modifier une composante du vecteur
void setComposante(int compo, float valeur);
void setComposante(int compo, Real valeur);
//appliquer plusieur fois un vecteur au vecteur courant
void addXfois(const Vecteur & vs, float nbFois);
void addXfois(const LrVector & vs, Real nbFois);
// CALCUL SUR LES VECTEURS /////////////////////////////////////////////////////////////////
//somme
Vecteur somm(const Vecteur &) const;
LrVector somm(const LrVector &) const;
//soustraction
Vecteur sous(const Vecteur &) const;
LrVector sous(const LrVector &) const;
//produit vectoriel
Vecteur prodVectoriel(const Vecteur &) const;
LrVector prodVectoriel(const LrVector &) const;
//produit scalaire
Vecteur prodScalaire(const Vecteur &) const;
LrVector prodScalaire(const LrVector &) const;
//multiplication par un scalaire
Vecteur multScalaire(float scalaire);
LrVector multScalaire(Real scalaire);
//normaliser le vecteur
void normaliser();
Vecteur & operator = (const Vecteur &);
Vecteur & operator += (const Vecteur & source);
Vecteur & operator -= (const Vecteur &);
LrVector & operator = (const LrVector &);
LrVector & operator += (const LrVector & source);
LrVector & operator -= (const LrVector &);
friend Vecteur operator + (const Vecteur & v_1, const Vecteur & v_2);
friend Vecteur operator - (const Vecteur & v_1, const Vecteur & v_2);
friend LrVector operator + (const LrVector & v_1, const LrVector & v_2);
friend LrVector operator - (const LrVector & v_1, const LrVector & v_2);
//produit scalaire
friend float operator * (const Vecteur & v_1, const Vecteur & v_2);
friend Real operator * (const LrVector & v_1, const LrVector & v_2);
//multiplication par un scalaire
friend Vecteur operator * (const Vecteur & v_1, float scalaire);
friend Vecteur operator * (float scalaire, const Vecteur & v);
friend LrVector operator * (const LrVector & v_1, Real scalaire);
friend LrVector operator * (Real scalaire, const LrVector & v);
//produit vectoriel
friend Vecteur operator ^ (const Vecteur & v_1, const Vecteur & v_2);
friend LrVector operator ^ (const LrVector & v_1, const LrVector & v_2);
};
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment