/***************************************************************************
     Copyright (C) 2009 by Pierre,,,
     pierre@pierre-laptop
 ***************************************************************************/

#include "vecteur.h"

const Vecteur VECT_NULL(0,0,0);
const Vecteur GTerre(0.0, 10.0, 0.0);

using namespace std;

///	Renvoie le signe de a
/**	@param a : nombre à analyser
	@return 1 si a > 0 et -1 sinon
*/
int sign(double a){
	if(a < 0){return -1;}else{return 1;}
}

///	Fonction qui renvoie le maximum entre deux valeur
/**	@param a : valeur 1
	@param b valeur 2
	@return plus grand des deux
*/
double max(double a, double b){
	if(a > b){return a;
	}else{return b;}
}

///	Fonction qui renvoie le minimum entre deux valeur
/**	@param a : valeur 1
	@param b valeur 2
	@return plus petit des deux
*/
double min(double a, double b){
	if(a < b){return a;
	}else{return b;}
}

////////////////////////////////////////////////////////////////////////
//                                                                    //
//                          Classe Vecteur                            //
//                                                                    //
////////////////////////////////////////////////////////////////////////

///	constructeur de Vecteur
/**	@param vecX : composante x du Vecteur
	@param vecY : composante y du Vecteur
	@param vecZ : composante z du Vecteur
*/
Vecteur::Vecteur(double vecX, double vecY, double vecZ){
	this->init(vecX, vecY, vecZ);
}

///	constructeur de copie de Vecteur
/**	@param vec : Vecteur
*/
Vecteur::Vecteur(const Vecteur & vec){
	this->init(vec.x, vec.y, vec.z);
}

///destructeur de Vecteur
Vecteur::~Vecteur(){}

/// 	fonction qui :sauvegarde les coordonnées du Vecteur dans le fichier fp
/**	@param fp : fichier de sauvegarde du vecteur
*/
void Vecteur::save(FILE* fp){
	fprintf(fp, "(%d, ", (int)this->x);
	fprintf(fp, "%d, ", (int)this->y);
	fprintf(fp, "%d)", (int)this->z);
}

/// 	Cette fonction initialise le Vecteur avec les valeurs de coordonnées de Vecteur enregistrées sous forme de fichiers
/**	@param fp : fichier où doit se trouver des coordonnées de Vecteur

*/
void Vecteur::load(FILE* fp){
	int nb;
	fscanf(fp, "(%d,", &nb);
	this->x = nb;
	fscanf(fp, " %d,", &nb);
	this->y = nb;
	fscanf(fp, " %d)", &nb);
	this->z = nb;
}

///	redéfinition de l'opérateur =
/**	@param vect : Vecteur
	@return Vecteur (*this)
*/
Vecteur & Vecteur::operator = ( const Vecteur & vect){
	this->init(vect.x, vect.y, vect.z);
	return *this;
}

///	redéfinition de l'opérateur +=
/**	@param vect : Vecteur
	@return Vecteur (*this)
*/
Vecteur & Vecteur::operator += ( const Vecteur & vect){
	this->x += vect.x;
	this->y += vect.y;
	this->z += vect.z;
	return *this;
}

///	redéfinition de l'opérateur -=
/**	@param vect : Vecteur
	@return Vecteur (*this)
*/
Vecteur & Vecteur::operator -= ( const Vecteur & vect){
	this->x -= vect.x;
	this->y -= vect.y;
	this->z -= vect.z;
	return *this;
}

///	redéfinition de l'opérateur *=
/**	@param coef : double
	@return Vecteur (*this)*coef
*/
Vecteur & Vecteur::operator *= (double coef){    //redéfinition de l'opérateur *=
	this->x *= coef;
	this->y *= coef;
	this->z *= coef;
	return *this;
}

///	redéfinition de l'opérateur /=
/**	@param coef : double
	@return Vecteur (*this)/coef
*/
Vecteur & Vecteur::operator /= (double coef){   //redéfinition de l'opérateur /=
	this->x /= coef;
	this->y /= coef;
	this->z /= coef;
	return *this;
}

///	redéfinition de l'opérateur - pour un Vecteur
/**	@return Vecteur opposé de *this
*/
Vecteur Vecteur::operator - (){
	Vecteur v(-this->x,-this->y,-this->z);
	return v;
}

///renvoie la norme euclidienne du Vecteur
/**	@return taille du Vecteur
*/
double Vecteur::taille(){                                           //calcul de la taille du vecteur
	double taille = sqrt(this->x*this->x + this->y*this->y + this->z*this->z);
	return taille;
}

/// 	fonction qui calcul et renvoie la norme au carré de *this
/**	@return norme au carré du Vecteur *this
	très utile pour faire de l'économie de calcul en faisant des simulations qui font intervenir des forces
*/
double Vecteur::normeSQR(){
	double taille = this->x*this->x + this->y*this->y + this->z*this->z;
	return taille;
}

///	Retourne un Vecteur ayant pour composantes les valeurs absolues des composantes de this
/**	@return Vecteur positif
*/
Vecteur Vecteur::abs(){
	Vecteur vect(fabs(this->x), fabs(this->y), fabs(this->z));
	return vect;
}

///renvoie un Vecteur qui a un x positif
/**	@return Vecteur x positif
*/
Vecteur Vecteur::absX(){
	Vecteur vect(fabs(this->x), this->y, this->z);
	return vect;
}

///renvoie un Vecteur qui a un y positif
/**	@return Vecteur y positif
*/
Vecteur Vecteur::absY(){
	Vecteur vect(this->x, fabs(this->y), this->z);
	return vect;
}

///renvoie un Vecteur qui a un z positif
/**	@return Vecteur z positif
*/
Vecteur Vecteur::absZ(){
	Vecteur vect(this->x, this->y, fabs(this->z));
	return vect;
}

///renvoie la composante x du Vecteur
/** @return la composante x du Vecteur
*/
double Vecteur::getx() const{return this->x;}

///renvoie la composante y du Vecteur
/** @return la composante y du Vecteur
*/
double Vecteur::gety() const{return this->y;}

///renvoie la composante z du Vecteur
/** @return la composante z du Vecteur
*/
double Vecteur::getz() const{return this->z;}

///Renvoie un  vecteur (x, 0, 0)
/** @return un Vecteur de la composante x du Vecteur
*/
Vecteur Vecteur::getVectX() const{
	Vecteur vect(this->x, 0, 0);
	return vect;
}

///Renvoie un  vecteur (0, y, 0)
/** @return un Vecteur de la composante y du Vecteur
*/
Vecteur Vecteur::getVectY() const{
	Vecteur vect(0, this->y, 0);
	return vect;
}

///Renvoie un  vecteur (0, 0, z)
/** @return un Vecteur de la composante z du Vecteur
*/
Vecteur Vecteur::getVectZ() const{
	Vecteur vect(0, 0, this->z);
	return vect;
}

///Renvoie le vecteur unitaire de *this
/** @return le Vecteur unitaire correspondant au Vecteur courrant
*/
Vecteur Vecteur::getUnit(){
	double taille = this->taille();
	Vecteur unit(this->x/taille, this->y/taille, this->z/taille);
	return unit;
}

///	fonction de calcul d'angle qui doit être plus rapide que le calcul avec des nombres complexes
/**	@param normale : Vecteur qui est la référence du calcul suivant
	@return angle entre le Vecteur normal et *this en radian
*/
double Vecteur::getAngle(const Vecteur & normale){
	if(this->taille() != 0){return acos(((*this)*normale)/this->taille());}
	else{return 0;}
}

///	fonction qui initialise les composantes du Vecteur
/**	@param vecX : composante x
	@param vecY : composante y
	@param vecZ : composante z
*/
void Vecteur::setXYZ(double vecX, double vecY, double vecZ){
	this->x = vecX;
	this->y = vecY;
	this->z = vecZ;
}

///	initialise la composantes x du Vecteur
/**	@param x : composante x du Vecteur
*/
void Vecteur::setx(const double x){this->x = x;}

///	initialise la composantes y du Vecteur
/**	@param y : composante y du Vecteur
*/
void Vecteur::sety(const double y){this->y = y;}

///	initialise la composantes z du Vecteur
/**	@param z : composante z du Vecteur
*/
void Vecteur::setz(const double z){this->z = z;}

///	fonction qui initialise le vecteur avec des angles en coordonnées sphériques
/**	@param angleTeta : angle des coordonnées polaires (si phi = M_PI/2)
	@param anglePhi : angle des coordonnées sphériques
*/
void Vecteur::setRotation(double angleTeta, double anglePhi){
	double longueur = this->taille();
	this->x = sin(anglePhi)*cos(angleTeta)*longueur;
	this->y = sin(anglePhi)*sin(angleTeta)*longueur;
	this->z = cos(anglePhi)*longueur;
}

///	fonction qui calcul la rotation du vecteur avec les variations de ses angles en coordonnées sphériques
/**	@param dTeta : petite variation de l'angle des coordonnées polaires (si phi = M_PI/2)
	@param dPhi : petite variation de l'angle des coordonnées sphériques
*/
void Vecteur::rotation(double dTeta, double dPhi){
	Vecteur i(1, 0, 0);
	Vecteur k(0, 0, 1);
	Vecteur projection(this->x, this->y, 0); ///calcul de la projection du Vecteur sur le plan xOy
	double theta = projection.getAngle(i);  ///renvoie l'angle sur le plan xOy (anlge theta)
	double phi = this->getAngle(k);        ///renvoie l'angle avec le vecteur k (angle phi)
	double longueur = this->taille();
	theta +=  dTeta;                 ///on incrémente les angles
	phi +=  dPhi;
	this->x = sin(phi)*cos(theta)*longueur; ///on recalcule les coordonnées du Vecteur
	this->y = sin(phi)*sin(theta)*longueur;
	this->z = cos(phi)*longueur;
}

///fonction qui retourne l'angle dans le plan du Vecteur
/** @return angle du Vecteur
*/
float Vecteur::getAngleTeta(){
	float longueur = this->taille();
	float anglePhi = acosf(this->z/longueur);
	float cosTeta = this->x /  (longueur*sinf(anglePhi));
	float sinTeta = this->y / (longueur*sinf(anglePhi));
	float complex zTeta = longueur*(cosTeta + I*sinTeta);  //I est le i des nombres complexes
	float angleTeta = cargf(zTeta);
	return angleTeta;
}

///	fonction qui calcul le réflexion du Vecteur *this par rapport à un vecteur normal
/**	le vecteur étant réfléchit dans la direction du Vecteur normal
	@param normal : Vecteur qui est la référence du calcul suivant
*/
void Vecteur::reflexion(Vecteur normal){                //vecteur normal à une surface plane
	Vecteur xF = (normal*(-(*this)))/(normal.taille()*normal.taille())*normal;
	*this = xF*2 + (*this);
}

///	Définition de l'addition de deux Vecteur
/**	@param vect1 : Vecteur
	@param vect2 : Vecteur
	@return Vecteur addition de vect1 + vect2
*/
Vecteur operator + (const Vecteur & vect1, const Vecteur & vect2){
	Vecteur vect3(vect1.x + vect2.x, vect1.y + vect2.y, vect1.z + vect2.z);
	return vect3;
}

///	Définition de la soustraction de deux Vecteur
/**	@param vect1 : Vecteur
	@param vect2 : Vecteur
	@return Vecteur soustraction de vect1 - vect2
*/
Vecteur operator - (const Vecteur & vect1, const Vecteur & vect2){
	Vecteur vect3(vect1.x - vect2.x, vect1.y - vect2.y, vect1.z - vect2.z);
	return vect3;
}

///	Définition du produit scalaire entre deux Vecteur
/**	@param vect1 : Vecteur
	@param vect2 : Vecteur
	@return double : résultat du produit scalaire
*/
double operator * (const Vecteur & vect1, const Vecteur & vect2){
	double produitScalaire = vect1.x*vect2.x + vect1.y*vect2.y + vect1.z*vect2.z;
	return produitScalaire;
}

///multiplication par un scalaire à droite
/**	Définition de la multiplication par un scalaire à droite
	@param vect1 : Vecteur
	@param scal : scalaire
	@return Vecteur produit de vect1*scal
*/
Vecteur operator * (Vecteur vect, double scal){
	vect.x *= scal;
	vect.y *= scal;
	vect.z *= scal;
	return vect;
}

///multiplication par un scalaire à gauche
/**	Définition de la multiplication par un scalaire à gauche
	@param scal : scalaire
	@param vect1 : Vecteur
	@return Vecteur produit de scal*vect1
*/
Vecteur operator * (double scal, Vecteur vect){
	vect.x *= scal;
	vect.y *= scal;
	vect.z *= scal;
	return vect;
}

///	division par un scalaire
/**	@param vect1 : Vecteur
	@param scal : double
	@return Vecteur division de vect1/scal
*/
Vecteur operator / (Vecteur vect, double scal){
	vect.x /= scal;
	vect.y /= scal;
	vect.z /= scal;
	return vect;
}

///	Définition  du produit vectoriel
/**	@param vect1 : Vecteur
	@param vect2 : Vecteur
	@return Vecteur produit vectoriel vect1^vect2
*/
Vecteur operator ^ (const Vecteur & vect1, const Vecteur & vect2){
	Vecteur vect(vect1.y*vect2.z - vect1.z*vect2.y, -vect1.x*vect2.z + vect1.z*vect2.x, vect1.x*vect2.y - vect1.y*vect2.x);
	return vect;
}

///	Définition de l'égalité entre deux Vecteur
/**	@param vect1 : Vecteur
	@param vect2 : Vecteur
	@return booléen true si toutes les composantes des deux Vecteur sont égales, false sinon
*/
bool operator == (const Vecteur & vect1, const Vecteur & vect2){
	if(vect1.x == vect2.x && vect1.y == vect2.y && vect1.z == vect2.z){return true;}
	else{return false;}
}

///	Définition de l'inégalité entre deux Vecteur
/**	@param vect1 : Vecteur
	@param vect2 : Vecteur
	@return  booléen true si toutes les composantes des deux Vecteur sont inégales, false sinon
*/
bool operator != (const Vecteur & vect1, const Vecteur & vect2){
	if(vect1.x == vect2.x && vect1.y == vect2.y && vect1.z == vect2.z){return false;}
	else{return true;}
}

///	permet l'affichage d'un vecteur dans la console
/**	@param out : sortie standard de la console (cout)
	@param vecteur : Vecteur à afficher dans la console
*/
std::ostream & operator << (std::ostream & out, const Vecteur & vecteur){
	out << "(" << vecteur.x << ", " << vecteur.y << ", " << vecteur.z << ")";
	return out;
}

///permet l'initialisation d'un Vecteur dans la console où avec un fichier de config
/**	@param in : entrée standard de la console (cin)
	@param v : Vecteur à initialiser
*/
std::istream & operator >> (std::istream & in, Vecteur & v){
	in >> v.x >> v.y  >> v.z;
	return in;
}

///initialise un Vecteur à partir d'une chaîne de type (x,y,z)
/** @param source : chaîne d'initialisation
*/
void Vecteur::loadFromConfig(const char  * source)
{
	sscanf(source,"(%lf,%lf,%lf)",&x,&y,&z);
}

///	fonction qui initialise un Vecteur
/**	@param vecX : composante x du Vecteur
	@param vecY : composante y du Vecteur
	@param vecZ : composante z du Vecteur
*/
void Vecteur::init(double vecX, double vecY, double vecZ){
	this->x = vecX;
	this->y = vecY;
	this->z = vecZ;
}

///fonction qui indique comment initialiser un Vecteur avec un fichier de config
/**	@param source : chaîne d'initialisation
	@param v : Vecteur à initialiser
*/
void pConfig_load_obj(const char * source, Vecteur & v)
{
	v.loadFromConfig(source);
}