Vecteur<double> Capteur::StatsPropres()
// Algorithme :
{
// Creation de la structure de retour et variables pratiques
Vecteur<double> statsRetour;
double total = d1Resume[4] + d2Resume[4] + d3Resume[4] + d4Resume[4] +
d5Resume[4] + d6Resume[4] + d7Resume[4];
double statTrafic;
// Remplissage
for (int i = 0; i < TAILLE_RESUME - 1; i++)
{
if ( total != 0 )
{
statTrafic = ( d1Resume[i] + d2Resume[i] + d3Resume[i] + d4Resume[i] +
d5Resume[i] + d6Resume[i] + d7Resume[i] ) / total;
}
else
{
statTrafic = 0;
}
statsRetour.insererFin(statTrafic);
}
return statsRetour;
} //----- Fin de StatsPropres
void Particule::setPosInt(Vecteur pos)
{
m_pos = pos;
m_pos2 = pos;
m_x = (int)pos.getX();
m_y = (int)pos.getY();
}
Vecteur<int> Capteur::EmbouteillageJour( int d7 )
// Algorithme :
// Structure de retour : Vecteur 0->23 : nombre d'embouteillage recense par heure
// 24->47 : nombre total de donnees par heure
{
// Création structure de retour et variables pratiques
Vecteur<int> donneesRetour;
Vecteur<Evenement>* jour = nullptr;
Trafic trafic;
// Détermination de la branche dans laquelle prendre les données
switch ( d7 )
{
case 1:
jour = &d1Contenu;
break;
case 2:
jour = &d2Contenu;
break;
case 3:
jour = &d3Contenu;
break;
case 4:
jour = &d4Contenu;
break;
case 5:
jour = &d5Contenu;
break;
case 6:
jour = &d6Contenu;
break;
case 7:
jour = &d7Contenu;
break;
default:
// Erreur : mauvaise demande de jour
break;
} //----- Fin de switch ( d7 )
// Init de la structure de retour
for ( int i = 0; i < 48; i++ )
{
donneesRetour.insererFin(0);
}
// Parcours du tableau d'événements et remplissage de la structure de retour
for (int i = 0; i < jour->GetTaille(); i++)
{
trafic = (*jour)[i].GetTrafic();
if ( trafic == R || trafic == N )
{
donneesRetour[(*jour)[i].GetHeure()] += 1;
}
donneesRetour[(*jour)[i].GetHeure() + 24] += 1; // TODO: plus rapide avec creation de variable ?
}
return donneesRetour;
} //----- Fin de EmbouteillageJour
//produit vectoriel
Vecteur operator^(const Vecteur & v) const
{
Vecteur res;
res.x() = (*this).y()*v.z() - (*this).z()*v.y();
res.y() = (*this).z()*v.x() - (*this).x()*v.z();
res.z() = (*this).x()*v.y() - (*this).y()*v.x();
return res;
}
//division par un scalaire
Vecteur operator/ (double d) const
{
Vecteur res;
res.x() = x()/d;
res.y() = y()/d;
res.z() = z()/d;
return res;
}
//operateur unaire negatif
Vecteur operator- () const
{
Vecteur res;
res.x() = -x();
res.y() = -y();
res.z() = -z();
return res;
}
Vecteur_Creux Vecteur_Creux::operator+(const Vecteur_Creux& v2) const
{
// pour stocker les indices utiles et les valeurs utiles du vecteur résultat
int* ixres = new int[nbu + v2.nbu];
int* utres = new int[nbu + v2.nbu];
// pour calculer le nb de valeurs utiles du vecteur résultat
int nbures = 0;
// on parcourt en parallèle les indices utiles du vecteur 1 (l'objet courant)
// et du vecteur 2 (v2)
int i1 = 0, i2 = 0; // indices de parcours des vecteurs des indices utiles
bool finVect1 = false, finVect2 = false;
while (!finVect1 || !finVect2) {
int ind_utile1, ind_utile2;
if (!finVect1)
ind_utile1 = vix.get_val(i1);
if (!finVect2)
ind_utile2 = v2.vix.get_val(i2);
if ((ind_utile1 < ind_utile2 && !finVect1) || finVect2) {
ixres[nbures] = ind_utile1;
utres[nbures] = vut.get_val(i1);
i1++;
}
else if (ind_utile1 == ind_utile2 && !finVect1 && !finVect2) {
ixres[nbures] = ind_utile1;
utres[nbures] = vut.get_val(i1) + v2.vut.get_val(i2);
i1++; i2++;
}
else if ((ind_utile2 < ind_utile1 && !finVect2) || finVect1) {
ixres[nbures] = ind_utile2;
utres[nbures] = v2.vut.get_val(i2);
i2++;
}
nbures++;
if (i1 == nbu)
finVect1 = true;
if (i2 == v2.nbu)
finVect2 = true;
}
// nb de valeurs réelles du vecteur résultat : max des 2 nb de valeurs réelles
int nbrres = (nbr > v2.nbr)? nbr : v2.nbr;
Vecteur vutres(utres, nbures);
Vecteur vixres(ixres, nbures);
Vecteur_Creux vres(vutres, vixres, nbrres);
delete [] ixres;
delete [] utres;
return vres;
}
Vecteur XMLtoVecteur::xmlToVecteur(TiXmlElement* v)
{
Vecteur vecteur;
vecteur.setP1(this->xmlToPoint(v->FirstChildElement()));
vecteur.setP2(this->xmlToPoint(v->FirstChildElement()->NextSiblingElement()));
return vecteur;
}
void Camera::updateAngles() {
// différence de position
Vecteur delta = posTar - posCam;
float r = delta.norm();
// calcul des angles
phi = asin(delta.getZ()/r);
theta = 2*atan(delta.getX()/(delta.getY()+r*cos(phi)));
phi *= 180 / M_PI;
theta *= 180 / M_PI;
}
float calcTforIntersect(Vecteur ni, Point A, Point B, Point Pi, Point Pi1)
{
Vecteur D = Vecteur(A, B);
Vecteur W = Vecteur(Pi, A);
float t = -1;
float DdotNi = D.DotProduct(ni);
if (DdotNi != 0)
t = - W.DotProduct(ni) / DdotNi;
return t;
}
Vecteur Vecteur::operator+(const Vecteur &vecteur2) const // Somme vectorielle
{
assert(dim()==vecteur2.dim() && ref() == vecteur2.ref());
Vecteur res(*this);
for(int i=0 ; i<dim() ; i++)
{
res[i] += vecteur2[i];
}
return res;
}
Vecteur Vecteur::operator+(const Vecteur &vecteur2) // Somme vectorielle
{
assert(dim()==vecteur2.dim() && ( (ref() && vecteur2.ref()) || (!ref() && !vecteur2.ref()) ));
changerDeReferentiel(vecteur2.ref());
Vecteur res(*this);
for(int i=0 ; i<dim() ; i++)
{
res[i] += vecteur2[i];
}
return res;
}
Vecteur<double> Capteur::StatsJour( int d7 )
// Algorithme :
{
// Création structure de retour et variables pratiques
Vecteur<double> statsRetour;
int * jourTab = nullptr;
double total;
// Détermination de la branche dans laquelle prendre les données
switch ( d7 )
{
case 1:
jourTab = d1Resume;
break;
case 2:
jourTab = d2Resume;
break;
case 3:
jourTab = d3Resume;
break;
case 4:
jourTab = d4Resume;
break;
case 5:
jourTab = d5Resume;
break;
case 6:
jourTab = d6Resume;
break;
case 7:
jourTab = d7Resume;
break;
default:
// Erreur : mauvaise demande de jour
break;
} //----- Fin de switch ( d7 )
total = jourTab[4];
// Insertion dans la structure de retour
statsRetour.insererFin( jourTab[0] / total );
statsRetour.insererFin( jourTab[1] / total );
statsRetour.insererFin( jourTab[2] / total );
statsRetour.insererFin( jourTab[3] / total );
return statsRetour;
} //----- Fin de StatsJour
Vecteur<int> Capteur::DonneesJour(int d7)
{
// Création structure de retour et variables pratiques
Vecteur<int> donneesRetour;
int * jourTab = nullptr;
// Détermination de la branche dans laquelle prendre les données
switch ( d7 )
{
case 1:
jourTab = d1Resume;
break;
case 2:
jourTab = d2Resume;
break;
case 3:
jourTab = d3Resume;
break;
case 4:
jourTab = d4Resume;
break;
case 5:
jourTab = d5Resume;
break;
case 6:
jourTab = d6Resume;
break;
case 7:
jourTab = d7Resume;
break;
default:
// Erreur : mauvaise demande de jour
break;
} //----- Fin de switch ( d7 )
// Insertion dans la structure de retour
donneesRetour.insererFin( jourTab[0] );
donneesRetour.insererFin( jourTab[1] );
donneesRetour.insererFin( jourTab[2] );
donneesRetour.insererFin( jourTab[3] );
donneesRetour.insererFin( jourTab[4] );
return donneesRetour;
} //----- Fin de DonneesJour
Point Point::operator+(Vecteur &vecteur2) const // Somme vectorielle
{
assert(dim()==vecteur2.dim() && ( (ref() && vecteur2.ref()) || (!ref() && !vecteur2.ref()) ));
if(ref())
{
vecteur2.changerDeReferentiel(ref());
}
Point res(*this);
for(int i=0 ; i<dim() ; i++)
{
res[i] += vecteur2[i];
}
return res;
}
//operateur soustraction
Vecteur operator- (const Vecteur & v) const
{
Vecteur res;
res.x() = x() - v.x();
res.y() = y() - v.y();
res.z() = z() - v.z();
return res;
}
void Point::changerDeReferentiel(Referentiel* newRef)
{
if( ref_ && (ref_ != newRef) )
{
// Les deux origines sont exprimées dans le référentiel de référence
Vecteur entreOrigines = ref()->origin() - newRef->origin();
entreOrigines.changerDeReferentiel(newRef);
if(!estNul())
{
Vecteur::changerDeReferentiel(newRef);
}
*this += entreOrigines;
setRef(newRef);
}
}
bool Vecteur::operator==(const Vecteur &vecteur2)// Test d'égalité
{
if(this == &vecteur2)
{
return true;
}
if(dim() != vecteur2.dim())
{
return false;
}
changerDeReferentiel(vecteur2.ref());
bool res = true;
for(int i=0 ; i<dim() && res ; i++)
{
res &= (coord[i]==vecteur2[i]); // On pourrait peut-être introduire un seuil
}
return res;
}
Vecteur_Creux Vecteur_Creux::Sous_Vecteur(int d) const
{
// pour stocker les indices utiles et les valeurs utiles du sous-vecteur
int* ixSousVect = new int[nbu];
int* utSousVect = new int[nbu];
// parcours des indices utiles du vecteur pour ne garder que ceux < d
int i = 0;
while (vix.get_val(i) < d) {
ixSousVect[i] = vix.get_val(i);
utSousVect[i] = vut.get_val(i);
i++;
}
int nbuSousVect = i;
Vecteur vutSousVect(utSousVect, nbuSousVect);
Vecteur vixSousVect(ixSousVect, nbuSousVect);
Vecteur_Creux sousVect(vutSousVect, vixSousVect, d);
delete [] ixSousVect;
delete [] utSousVect;
return sousVect;
}
Vecteur operator-(const Vecteur& v)
{
return Vecteur(-v.getX(), -v.getY());
}
Vecteur operator+(const Point& a, const Vecteur& v)
{
return Vecteur(a.getX() + v.getX(), a.getY() + v.getY());
}
bool operator==(const Vecteur& a, const Vecteur& b)
{
return (a.getX() == b.getX() && a.getY() == b.getY());
}
Vecteur_Creux::Vecteur_Creux(const Vecteur& le_vut, const Vecteur& le_vix, int n)
: vut(le_vut), vix(le_vix) // appel du constructeur par copie pour vut et vit
{
nbr = n;
nbu = le_vut.taille();
}
Vecteur::Vecteur(const Vecteur &vecteurACopier) //Copie d'un vecteur
{
init(vecteurACopier.coord, vecteurACopier.ref());
}
Vent::Vent(Vecteur const& origine, Vecteur const& normale, Vecteur const& longueur, Vecteur const& largeur, double const& profondeur, double const& intensite)
:ChampForces(intensite * normale), m_origine(origine), m_normale(normale.unitaire()), m_longueur(longueur - (longueur*m_normale)*m_normale), m_largeur(largeur - (largeur*m_normale)*m_normale - (largeur*m_longueur.unitaire())* (m_longueur.unitaire()) ), m_profondeur(profondeur)
{
}
Param_Inter DiffO::interact(Param_Inter ¶g,bool inside,int order){
Transf parao;
Vecteur rediff;
double scal=parag.direct().prod_scalaire(prim->normal());
// cout<<"Diff0[interact()]poid = "<<parag.poid();prim->qui();
// cout<<" Normale : ";prim->normal().show();
// cout<<" Incident : ";parag.direct().show();
if(scal>0.0){
// printf(" Si pas infini, bug... Opaque attaque' par de'rrie`re");
//prim->qui();
//cout<<" Normale : ";prim->normal().show();
//cout<<" Incident : ";parag.direct().show();
//cout<<" Origine : ";parag.origin().show();
inside=true;
//sortie inchangee ( eg transparence)
return parag;
}
//raus(scal>0.0,"DiffO[interact] Opaque attaque' par de'rrie`re...");
Einc+=parao.abs=parao.rediffuse=parag.poid();
parao.teta=Macos(-scal);
parao.phi=0.0;
opti->interact(parao);
// cout <<"DiffO[interact] teta redif = "<<parao.teta<<" - phi = "<<parao.phi<<endl;
rediff=parag.direct();
if( fabs( rediff.prod_scalaire(prim->normal() ) )>1.0-1e-6 ) {
rediff[0]=primi().sommets(0)[0]-primi().sommets(1)[0];
rediff[1]=primi().sommets(0)[1]-primi().sommets(1)[1];
rediff[2]=primi().sommets(0)[2]-primi().sommets(1)[2];
}
else
rediff=rediff.prod_vectoriel(prim->normal());
rediff.normalise();
//parao.phi=rambo.tirage()*M_2PI;
/*
rediff=rediff.rotate(prim->normal(), parao.phi);
rediff.normalise();
rediff=prim->normal().rotate(rediff,(parao.teta<0.0)?M_PI+parao.teta:parao.teta);
rediff.normalise();
*/
Vecteur u,v,w,n;
n[0]=n[1]=sin(parao.teta);
n[0]*=cos(parao.phi);
n[1]*=sin(parao.phi);
n[2]=cos(parao.teta);
v=rediff;
w=prim->normal();
u=v.prod_vectoriel(w);
for(register int i=0;i<3;i++){
rediff[i]= u[i]*n[0] + v[i]*n[1] + w[i]*n[2] ;
}
//rediff=prim->normal().rotate(rediff,M_PI_2);
//cout<<"DiffO::interact() : teta = "<<parao.teta<<endl;
/*
rediff[0]=cos(parao.phi)*sin(parao.teta);
rediff[1]=sin(parao.phi)*sin(parao.teta);
rediff[2]=cos(parao.teta);
*/
parag.change_direction(rediff);
// if(parao.rediffuse>0.5) cout<<"interact poid rediffuse = "<<parao.rediffuse<<endl;
//maj de l'energie du diffuseur
if(order==0){
B1st+=parao.rediffuse;
Eabs[0]+=parao.abs;
}else
Eabs[1]+=parao.abs;
radio+=parao.rediffuse;
nk++;//cout<<"nk++\n";
parag.change_poids(parao.rediffuse);
// cout<<"DiffO[interact()] abs="<<parao.abs<<"=> Eabs ="<<Eabs<<" - Poids = "<<parag.poid()<<endl;
// cout <<" DiffO[interact()] new direct ";parag.direct().show();
return parag;
}
Vecteur operator*(int n, const Vecteur& v)
{
return Vecteur(v.getX() * n, v.getY() * n);
}
void Capteur::Inserer( Evenement& unEvenement )
// Algorithme :
{
// Variables permettant de positionner l'insertion
Vecteur<Evenement>* jour = nullptr;
int * caseResume = nullptr;
// Détermination du jour de la semaine
switch ( unEvenement.GetD7() )
{
case 1:
jour = &d1Contenu;
caseResume = d1Resume;
break;
case 2:
jour = &d2Contenu;
caseResume = d2Resume;
break;
case 3:
jour = &d3Contenu;
caseResume = d3Resume;
break;
case 4:
jour = &d4Contenu;
caseResume = d4Resume;
break;
case 5:
jour = &d5Contenu;
caseResume = d5Resume;
break;
case 6:
jour = &d6Contenu;
caseResume = d6Resume;
break;
case 7:
jour = &d7Contenu;
caseResume = d7Resume;
break;
default:
// Erreur d'insertion
break;
} //----- Fin de switch ( unEvenement.GetD7() )
// Incrémentation de la bonne case de trafic
switch ( unEvenement.GetTrafic() )
{
case V:
caseResume[0]++;
break;
case J:
caseResume[1]++;
break;
case R:
caseResume[2]++;
break;
default: // case N:
caseResume[3]++;
break;
} //----- Fin de switch ( unEvenement.GetTrafic() )
// Insertion dans le vecteur et incrementation du nombre total d'évènements
jour->insererFin( unEvenement );
caseResume[4]++;
} //----- Fin de Inserer
double operator*(Vecteur const& a, Vecteur const& b)
{
return a.getX()*b.getX() + a.getY()*b.getY();
}
int Capteur::TempsSegment( int d7, int heure, int minute )
{
// Création variable de retour et variables pratiques
int tempsParcours = 0;
Vecteur<Evenement>* jour = nullptr;
// Détermination de la branche dans laquelle prendre les données
switch ( d7 )
{
case 1:
jour = &d1Contenu;
break;
case 2:
jour = &d2Contenu;
break;
case 3:
jour = &d3Contenu;
break;
case 4:
jour = &d4Contenu;
break;
case 5:
jour = &d5Contenu;
break;
case 6:
jour = &d6Contenu;
break;
case 7:
jour = &d7Contenu;
break;
default:
// Erreur : mauvaise demande de jour
break;
} //----- Fin de switch ( d7 )
for ( int i = 0; i < jour->GetTaille(); i++ )
{
// Recherche de l'horaire
if ( (*jour)[i].GetHeure() == heure && (*jour)[i].GetMinute() == minute )
{
switch ( (*jour)[i].GetTrafic() )
{
case V:
tempsParcours += 1;
break;
case J:
tempsParcours += 2;
break;
case R:
tempsParcours += 4;
break;
default: // case N:
tempsParcours += 10;
break;
}
break; // On a trouve, on sort de la boucle
}
}
return tempsParcours;
} //----- Fin de TempsSegment