/// <summary>
/// Constructeur de la classe PointAttention
/// </summary>
/// <param name="vect">Vecteur fourni mentionné dans le fichier de données</param>
/// <param name="tps">Temps depuis le début de l'enregistrement</param>
public PointAttention(Vecteur2 vect, double tps)
{
_tempsEcoule = tps;
_PAX = vect.A;
_PAY = vect.B;
_coordPA = initialiseCoordPA(vect);
}
/// <summary>
/// Méthode qui permet de déterminer les pixels qui sont dans une ellipse de centre le point d'attention de référence
/// L'ellipse étant la zone d'attention
/// </summary>
/// <param name="screenDistance">Distance à l'écran</param>
/// <param name="logicalHeight">Hauteur logique en px</param>
/// <param name="logicalWidth">Longueur logique en px</param>
/// <param name="physicalHeight">Hauteur physique en m</param>
/// <param name="physicalWidth">Longueur logique en m</param>
/// <param name="userY">Y du PA</param>
public void pixelsEllipse(double screenDistance, double logicalHeight, double logicalWidth, double physicalHeight, double physicalWidth, double userY)
{
// Le PA avec lequel on fait le calcul devient el PA de référence :
PAref = this._coordPA;
//Largeur (première coordonnée) et hauteur (seconde coordonnée) de l'ellipse (à calculer dans le constructeur)
dimEllipse = trouveEllipse(screenDistance, logicalHeight, logicalWidth, physicalHeight, physicalWidth, userY);
// Recherche de la liste des pixels associés
List<Vecteur2> laListe = new List<Vecteur2>();
// Pour cela on réduit la zone de recherche des pixels pour trouver ceux qui sont dans l'ellipse
int min_x = (int)Math.Floor(_coordPA.A - dimEllipse.A);
int min_y = (int)Math.Floor(_coordPA.B - dimEllipse.B);// + Image.dimensionsBandeauLignes);
int max_x = min_x + (int)dimEllipse.A * 2;
int max_y = min_y + (int)dimEllipse.B * 2;// +Image.dimensionsBandeauCol;
for (int y = min_y; y < max_y; y++)
for (int x = min_x; x < max_x; x++)
if (dansEllipse(translatePixel(x, y)))
laListe.Add(new Vecteur2(x,y));
// on met à jour la liste de pixels de référence
pixelsRef = laListe;
}
/// <summary>
/// Méthode qui définit si un pixel est dans une ellispe ou non, de centre (0,0,0)
/// </summary>
/// <param name="pixel">Pixel à déterminé</param>
/// <returns>Booléen qui indique si le pixel est dans l'ellipse ou non</returns>
public bool dansEllipse(Vecteur2 pixel)
{
// On détermine l'équation de la droite y=a*x passant par le pixel et le centre de l'ellipse, dans le repère de l'ellipse
// Calcul du coef directeur coef
double coef = (pixel.B) / (pixel.A);
// L'ellipse a pour équation (x^2/a^2)+(y^2/b^2)=1
// On cherche le point M(x,y) appartenant au contour de l'ellipse et à la droite
// Calcul du discriminant de x^2*[(1/a^2)+(coef^2/b^2)]-1=0
double facteurX = 1 / Math.Pow(dimEllipse.A, 2) + Math.Pow(coef, 2) / Math.Pow(dimEllipse.B, 2);
double discrim = 4 * facteurX;
// Calcul d'une des deux solutions de x possibles (peu importe laquelle)
double x1 = Math.Sqrt(discrim) / (2 * facteurX);
// On cherche la coordonnée y correspondant à cette solution grâce à l'équation de départ;
double y1 = coef * x1;
// Calcul la distance de ce point au centre
double dSol = Math.Sqrt(Math.Pow(x1, 2) + Math.Pow(y1, 2));
// On calcule la distance du pixel au centre
double dPix = Math.Sqrt(Math.Pow(pixel.A, 2) + Math.Pow(pixel.B, 2));
// On compare les deux distances et on conclut sur l'appartenance du pixel à l'ellipse
if (dPix <= dSol)
return true;
else
return false;
}
/// <summary>
/// Méthode qui trouve le bon point d'attention à partir du "mauvais"
/// </summary>
/// <param name="vect">Le vecteur mauvais PA</param>
/// <returns>Le bon vecteur PA</returns>
public Vecteur2 initialiseCoordPA(Vecteur2 vect)
{
return new Vecteur2(vect.A + dimEllipse.A / 2, vect.B + dimEllipse.B / 2);
// On a besoin de valeurs rondes donc on arrondit
}
/// <summary>
/// Méthode de calcul de distance
/// </summary>
/// <param name="other">Vecteur dont on veut calculer </param>
/// <returns></returns>
public double Distance(Vecteur2 other)
{
return Math.Sqrt((other.A - this.A) * (other.A - this.A) + (other.B - this.B) * (other.B - this.B));
}
