public gVecteur Inverse()
{
gVecteur V = new gVecteur(X, Y, Z);
V.Inverser();
return(V);
}
public Double AngleZ()
{
gVecteur V = new gVecteur(X, Y, 0);
gVecteur Vo = new gVecteur(0, Y, 0);
return(Vo.Angle(V));
}
public Boolean EstColineaire(gVecteur v, Double arrondi, Boolean prendreEnCompteSens = true)
{
var result = false;
var v1 = Unitaire();
var v2 = v.Unitaire();
var vn = v1.Vectoriel(v2);
if (vn.Norme < arrondi)
{
if (prendreEnCompteSens)
{
// Si on aditionne les deux vecteurs et que la norme est supérieur à 0
// c'est qu'ils ne sont pas opposé
if (v1.Compose(v2).Norme > arrondi)
{
result = true;
}
}
else
{
result = true;
}
}
return(result);
}
public gVecteur Compose(gVecteur v)
{
gVecteur C = new gVecteur(this);
C.Ajouter(v);
return(C);
}
/// <summary>
/// Verifie si deux plans sont identiques
/// On peut également vérifier ou non les directions des normales
/// </summary>
/// <param name="p"></param>
/// <param name="prendreEnCompteSensNormale"></param>
/// <returns></returns>
public Boolean SontIdentiques(gPlan p, Double arrondi, Boolean prendreEnCompteSensNormale = true)
{
var result = false;
var normale = p.Normale;
var origine = p.Origine;
normale.Normaliser();
// Si les normales sont colinéaires
if (normale.EstColineaire(Normale, arrondi, prendreEnCompteSensNormale))
{
if (Origine.Comparer(origine, arrondi))
{
result = true;
}
// On test si l'origine est sur le plan en calculant le
// produit vectoriel de la norme avec le vecteur(Origine, origine)
// Si la valeur est égale à 1, ces deux vecteurs sont perpendiculaire
var v2 = new gVecteur(Origine, origine);
v2.Normaliser();
var val = Math.Abs(Normale.Vectoriel(v2).Norme - 1);
if (val < arrondi)
{
result = true;
}
}
return(result);
}
public Double Distance(gSegment s)
{
gVecteur ba = new gVecteur(s.Start, this);
gVecteur u = s.Vecteur;
return(ba.Vectoriel(u).Norme / u.Norme);
}
public Double AngleY()
{
gVecteur V = new gVecteur(X, 0, Z);
gVecteur Vo = new gVecteur(0, 0, Z);
return(Vo.Angle(V));
}
public gVecteur Vectoriel(gVecteur v)
{
gVecteur prod = new gVecteur(
Y * v.Z - Z * v.Y,
Z * v.X - X * v.Z,
X * v.Y - Y * v.X);
return(prod);
}
public gSegment(gPoint a, gVecteur v)
{
Start = a;
End = new gPoint
(
a.X + v.X,
a.Y + v.Y,
a.Z + v.Z
);
}
public gVecteur Unitaire()
{
Double Lg = Norme;
gVecteur prod = new gVecteur(
X / Lg,
Y / Lg,
Z / Lg);
return(prod);
}
public Boolean RotationTrigo(gVecteur v, gVecteur normal)
{
gVecteur p = Vectoriel(v).Unitaire();
p.Ajouter(normal.Unitaire());
if (p.Norme > MathConst.Racine2())
{
return(true);
}
return(false);
}
public gPoint Projection(gSegment s)
{
gVecteur ab = s.Vecteur;
gVecteur ac = new gVecteur(s.Start, this);
Double n = ab.Scalaire(ac) / ab.Norme;
ab.Normaliser();
ab.Multiplier(n);
gPoint p = s.Start;
p.Deplacer(ab);
return(p);
}
public Boolean SurLePlan(gPoint p, Double arrondi)
{
var v2 = new gVecteur(Origine, p);
v2.Normaliser();
var val = Math.Abs(Normale.Vectoriel(v2).Norme - 1);
// Si l'origine est sur le plan
if (val < arrondi)
{
return(true);
}
return(false);
}
public void Deplacer(gVecteur V)
{
X += V.X;
Y += V.Y;
Z += V.Z;
}
public gVecteur(gVecteur v)
{
X = v.X; Y = v.Y; Z = v.Z;
}
public void Ajouter(gVecteur v)
{
X += v.X; Y += v.Y; Z += v.Z;
}
public Double Scalaire(gVecteur v)
{
return((X * v.X) + (Y * v.Y) + (Z * v.Z));
}
public gPlan(gPoint a, gVecteur v)
{
Origine = a;
Normale = v;
Normale.Normaliser();
}
public Double AnglePlZY()
{
gVecteur V = new gVecteur(0, Y, Z);
return(V.Angle(this));
}
public Double AnglePlXY()
{
gVecteur V = new gVecteur(X, Y, 0);
return(V.Angle(this));
}
public Double AnglePlXZ()
{
gVecteur V = new gVecteur(X, 0, Z);
return(V.Angle(this));
}
public Double Angle(gVecteur v)
{
return(Math.Acos(Scalaire(v) / (Norme * v.Norme)));
}
public gPoint Composer(gVecteur V)
{
return(new gPoint(X + V.X, Y + V.Y, Z + V.Z));
}