Tag - geometrie

Fil des billets - Fil des commentaires

[Java] Procédé de Gram-Schmidt à partir de trois points

mardi 3 mars 2009

Application du procédé d'orthonormalisation de Gram-Schmidt pour obtenir les vecteurs du repère formé par trois points javax.vecmath.Point3d. Cette méthode retourne les trois vecteurs e1,e2,e3 qui composent le repère. Pour plus de détails, voyez l'article sur Wikipédia : Procédé de Gram-Schmidt.

 

public static Vector3d[] gramSchmidt(Point3d o, Point3d a, Point3d b) {
		
	Vector3d e2 = new Vector3d(a);
	e2.scale(-1);
	e2.add(b);
	e2.normalize();
		
	Vector3d AO = new Vector3d(a);
	AO.scale(-1);
	AO.add(o);
		
	double PS = AO.dot(e2);
	Vector3d AC = new Vector3d(e2);
	AC.scale(PS);
		
	Vector3d CO = new Vector3d(AC);
	CO.scale(-1);
	CO.add(AO);
		
	Vector3d e1 = new Vector3d(CO);
	e1.normalize();
		
	Vector3d e3 = new Vector3d();
	e3.cross(e1, e2);
	e3.normalize();
		
	return new Vector3d[] { e1, e2, e3 };
		
}

[Java] Calculer l'equation de la droite perpendiculaire à la droite AB et passant par B

dimanche 1 mars 2009

/**
 * Soit la droite (ab), on cherche l'equation de la droite (D) tel
 * que (D) est perpendiculaire à (ab) et passe par b
 */

public static double[] getPerpendiculaire(Point2d a, Point2d b) {
	return getPerpendiculaire(lineEquation(a, b), b);
}

public static double[] getPerpendiculaire(double[] eq, Point2d b) {
	double coef = -1 / eq[0];
	double pos  = b.y - coef * b.x;
	return new double[] { coef, pos };
}

[Java] Trouver la bissectrice d'un angle formé par trois points

mardi 24 février 2009

	/**
	 * Retourne un point sur la bissectrice de l'angle ABC
	 * La bissectrice sera donc représentée par [b,point retourné]
	 */
	public static Point2d getBissectricePoint(Point2d a, Point2d b, Point2d c) {
		
		Point2d p1 = getPointOnLine(b, a, 10);
		
		Point2d p2 = getPointOnLine(b, c, 10);
		
		Point2d p3 = getSegmentCenter(p1, p2);
		
		return p3;
	}

[Java] Calculer les coordonnées et les points d'intersection d'un cercle inscrit à un angle formé par trois points.

mardi 24 février 2009

fonction_getCircleInscrit.jpg Soit un angle ^ABC formé par les points A, B et C. Il est possible d'inscrire le cercle de centre C dans l'angle, avec V1 et V2 respectivement sur [AB] et [BC]. Cette méthode retourne un tableau de trois points, qui sont respectivement V1, V2 et C.

       /**
	 * 
	 * Retourne un tableau de Point2d :
	 *  indice 0 = point d'intersection entre BA et le cercle 
	 *  indice 1 = point d'intersection entre BC et le cercle
	 *  indice 2 = point au centre du cercle
	 */
	public static Point2d[] getCircleInscrit(Point2d a, Point2d b, Point2d c,
			double radius) {
		
		// Soit O le centre du cercle inscrit
		Point2d O = null;
		
		// On calcule la valeur de l'angle ABC, et on le divise par deux
		// pour trouver l'angle ABO
		double alpha = getAngleRad(a, b, c) / 2;
		
		// On cherche la distance sur BA et BC qui nous donne la position
		// des points d'intersection entre les droites et le cercle
		// po1 sur BA
		// po2 sur BC
		double bx = radius / Math.tan(alpha);
		
		Point2d po1 = getPointOnLine(b, a, bx);
		Point2d po2 = getPointOnLine(b, c, bx);

		// On cherche la bissectrice de l'angle ABC
		// Cette methode retourne un des points de cette bissectrice BX
		Point2d X = getBissectricePoint(a, b, c);
		
		// On calcule la longeur du sergment BO
		double bo = Math.sqrt(bx*bx + radius*radius);
		
		// On fabrique le vecteur BX
		Vector2d vec = vector(b, X);
		// On normalise le vecteur (recuperation du vecteur unitaire)
		vec.normalize();
		// On redimensionne le vecteur
		vec.scale(bo);
		// On replace le vecteur sur B
		vec.add(b);

		//O = getPointOnLine(b, O, bo);
		O = new Point2d(vec.x, vec.y);
		
		return new Point2d[] {
			po1,
			po2,
			O
		};
		
	}

	public static Vector2d vector(Point2d a, Point2d b) {
		return new Vector2d(
			b.x-a.x,
			b.y-a.y
		);
	}

[Java] Calculer le milieu d'un segment à partir de deux points

mardi 24 février 2009

	public static Point2d getSegmentCenter(Point2d p1, Point2d p2) {
		return new Point2d(
			p1.x+(p2.x-p1.x)/2,
			p1.y+(p2.y-p1.y)/2
		);
	}

page 1 de 3