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;
	}

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;
}

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;
}

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 operator-(const Vecteur& v)
{
    return Vecteur(-v.getX(), -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();
}

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 &parag,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;
}

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();
}