export class Angle {

	//Retourne si l'angle AB-AC est inférieur à inf (en degre)
	/*static angleT(coordA, coordB, coordC, inf) {
		if(coordA.length < 3 && coordB.length < 3 && coordC.length < 3)
			return angle(coordA[0], coordA[1], coordA[2], coordB[0], coordB[1], coordB[2], coordC[0], coordC[1], coordC[2], inf);
		return false;
	}*/

	//Cas spécial pour les bulles
	static angleB(a, b, c, inf) {
		return this.angle10(a.x, a.y, a.z, b.x, b.y, b.z, c.x, c.y, c.z, inf);
	}

  //Retourne si l'angle AB-AC est inférieur à inf (en degre)
	static angle10(xA, yA, zA, xB, yB, zB, xC, yC, zC, inf) {

            //Vérification de l'angle inférieur (ou egal) à la valeur attendu
            return this.degre9(xA, yA, zA, xB, yB, zB, xC, yC, zC) <= inf;
	}

	static degre3B(a, b, c) {
		return this.degre9(a.x, a.y, a.z, b.x, b.y, b.z, c.x, c.y, c.z);
	}

	static degre9(xA, yA, zA, xB, yB, zB, xC, yC, zC) {

            let normAB, normAC, tmp, cosA, angleA;
            let AC = [3];
            let AB = [3];


            // A=acos( AB.AC / ( ||AB|| * ||AC||))
            // AB.AC = ABx * ACx + ABy * ACy + ABz * ACz
            // ||AB|| = sqrt(ABx^2 + ABy^2 + ABz^2)
            // ||AC|| = sqrt(ACx^2 + ACy^2 + ACz^2)


            AB[0] = xB - xA; AB[1] = yB - yA; AB[2] = zB - zA;
            AC[0] = xC - xA; AC[1] = yC - yA; AC[2] = zC - zA;


            normAB = Math.sqrt(Math.pow( AB[0] , 2) + Math.pow( AB[1] , 2) + Math.pow( AB[2] , 2));
            normAC = Math.sqrt(Math.pow( AC[0] , 2) + Math.pow( AC[1] , 2) + Math.pow( AC[2] , 2));

            tmp = AB[0] * AC[0] + AB[1] * AC[1] + AB[2] * AC[2];

            cosA = tmp / (normAB * normAC);

            angleA = Math.acos(cosA) * 180 / Math.PI;


            return angleA;
	}

}
