Discussion :

[darkman19320]

Bonjour tout le monde!
J'ai un cube dans l'espace. A partir de n'importe quel point de l'espace, je souhaiterais obtenir le point associé à une des faces du cube.
Pour cela je pensais faire une projection orthogonale d'un point 3D sur un plan (une des faces de mon cube) puis projeter le point obtenu dans la face associé à mon plan.

Voici une image résumant (ou tout essaye de rendre compréhensible ce que j'essaye d'expliquer ):


J'ai réussi à obtenir l'équation du plan à partir de trois points d'une des faces:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public static void getEquationPlane(Vertex3D p1, Vertex3D p2, Vertex3D p3,
	    DoubleBuffer equationPlane) {
  //v0 est le vecteur P1P2
  Vector3D v0 = new Vector3D(p2.getX()-p1.getX(), p2.getY()-p1.getY(), p2.getZ()-p1.getZ());
  //v1 est le vecteur P2P3
  Vector3D v1 = new Vector3D(p3.getX()-p2.getX(), p3.getY()-p2.getY(), p3.getZ()-p2.getZ());
 
  Vector3D n = new Vector3D(v0);
  n.cross(v1);
 
  double A = n.getX(), B = n.getY(), C = n.getZ();
 
  double D = - (A*p1.getX() + B*p1.getY() + C*p1.getZ());
 
  //L'équation du plan :  Ax + By + Cz + D = 0;
 
  equationPlane.put(A);
  equationPlane.put(B);
  equationPlane.put(C);
  equationPlane.put(D);
}

Je pense que le calcul de l'équation du plan est correct mais je ne comprends pas:
1> comment faire pour calculer le projeté orthogonal de n'importe quel points de l'espace?
2> comment faire une translation du projeté vers la face du cube (si et seulement si le projeté n'est pas déjà dans la face).
3> Est-il possible de passer du point A (sur la figure) au point A" en un seul système d'équation (matrice de projection + translation?)?

Merci d'avance.

[Jean Dumoncel]

Bonjour,

(dis-donc, c'est bien de penser aux malvoyants et à ceux qui ont un petit écran, mais elle est un peu énorme ton image...)

Chercher le projeté orthogonal, c'est chercher l'intersection entre le plan et la droite perpendiculaire au plan passant par le point.
Pour l'intersection entre un plan et une ligne :
Subject 5.05: How do I find the intersection of a line and a plane?
(tu peux facilement trouver l'équation paramétrique de la droite en utilisant un vecteur normal à ton plan)

(une remarque au cas ou : on est bien d'accord que les faces de ton cube ne sont pas parallèle aux axes de ton repère?)

[darkman19320]

Merci pour ta réponse.
Mon cube n'est pas forcément parallèle à mon repère.
Je vais essayer ce que tu m'as dit et je vous tiens au courant.

[Nebulix]

le point associé
C'est quoi çà ?

[darkman19320]

Bonjour,
Désolé pour la réponse tardive j'avais un autre projet en cours...
Donc pour répondre à ta question Nebulix, le point associé est en fait le projeté orthogonale de A sur le segment de ma bounding Box ou sur l'une des faces de celle-ci.

Je pense avoir réussi à trouver le projeté orthogonal d'un point sur un plan et le projeté d'un point sur la droite.
Voici le code que j'utilise pour la projection d'un point dans le plan

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
/**
 * 
 * {@link Plane} defined an equation's plane:
 * Ax + By + Cz + D = 0;
 *
 */
 
 
 /**
     * Get the plane's normal: 
     * n = (A,B,C);
     * @param plane
     * @return the plane's normal vector.
     */
    public static Vector getNormal(Plane plane) {
	return new Vector(plane.A(), plane.B(), plane.C());
    }
 
 /**
     * Compute the minimal distance between the {@link Point} (p) and
     * the {@link Plane} (plane).
     * The algorithm used is:</br>
     * 1) Get the plane's normal n;</br>
     * 2) Compute the dot product between n and p and add D plane's value:</br>
     * 		dist = (n.dot(p) + plane.D())/sqrt(n.dot(n));</br>
     * @param p
     * @param plane
     * @return the distance between the plane and the point.</br> 
     * If the distance is < 0 the the point is not in the same direction
     * as the plane's normal. If the distance is equals to 0 then the point
     * is contained in the plane.
     */
    public static float distancePointPlane(Point p, Plane plane) {
	Vector n = getNormal(plane);
 
	return (float)(Math.abs(n.dot(new Vector(p)) + plane.D())/Math.sqrt(n.dot(n)));		
    }
 
 /**
     * Projected orthogonally the {@link Point} (p) on the {@link Plane}
     * (plane).</br>
     * The algorithm used is:</br>
     * 1) Compute the distance (dist) between the point and the plane. </br>
     * 2) Get the plane's normal (n).</br>
     * 3) Create the new point:</br>
     * Point q = p - n*dist;
     * @param p
     * @param plane
     * @return the point on plane.
     */
    public static Point projectionOrthoPointInPlane(Point p, Plane plane) {
	float dist = distancePointPlane(p, plane);
	Vector n = getNormal(plane);
	n.multiply(dist);
 
	Point pPlane = new Point(p);
	pPlane.remove(n);
	return pPlane;
    }

Et celui-ci pour la projection d'un point sur une droite:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
 /**
     * Distance calculation between two points.
     * @param p1
     * @param p2
     * @return the distance between p1 and p2.
     */
    public static double distance(final Point p1, final Point p2) {
	Point p1p2 = remove(p1,p2); //p1-p2;
	return Math.sqrt(Math.pow(p1p2.x(), 2) + Math.pow(p1p2.y(), 2) +
		Math.pow(p1p2.z(), 2));
    }
 
  public static double length(final Line l) {
	return l.a().distance(l.b());
    }
 
  public static Point projectionOrthoPointOnLine(final Point p, final Line l) {
	//Q = P1 + u*(P2-P1);
	//(P3-Q)dot(P2-P1) = 0;
	//(P3-P1-u*(P2-P1))dot(P2-P1) = 0;
	//u = ((x3-x1)*(x2-x1) + (y3-y1)*(y2-y1) + (z3-z1)*(z2-z1))/length(l);
	//Qx = P1x + u*(P2x-P1x);
	//Qy = P1y + u*(P2y-P1y);
	//Qz = P1z + u*(P2z-P1z);
 
	double lengthLine = l.length();
	Vector ap = new Vector(Point.remove(p, l.a()));
	Vector ab = new Vector(Point.remove(l.b(), l.a()));
 
	double u = ap.dot(ab)/(lengthLine*lengthLine);
 
	float qx = (float) (l.a().x() + u*(ab.x()));
	float qy = (float) (l.a().y() + u*(ab.y()));
	float qz = (float) (l.a().z() + u*(ab.z()));
 
	return new Point(qx, qy, qz);
    }

Me serais-je trompé dans mes calculs?

Merci d'avance.


Edit: Après vérification, mes calculs sont corrects (j'ai fait plusieurs test d'appartenance ou non d'un point à une ligne ou un plan et les résultats semblent corrects).

[darkman19320]

Bonjour,
Je pense avoir compris mon problème: le point d'origine (par exemple le point A ou B sur le dessin) n'a pas la profondeur souhaitée.
Pour information, je récupère ce point à partir de la fonction glUnProject de OpenGL (voir Problème affichage de points à partir d'un clic de souris. Je lui passe en paramètre ma matrice de transformation (MODELVIEW_MATRIX), ma matrice de projection (PROJECTION_MATRIX) ainsi que les coordonnées de ma souris (donc en 2D) et un tableau pour récupérer les 3 coordonnées du monde OpenGL.
Je pense que le problème vient de ma matrice de projection.

J'ai pensais à une autre solution: tester la distance entre les coordonnées de la souris et les différentes droites de ma bounding box et prendre la distance la plus petite mais malheureusement le résultat n'est pas concluant... Je crois savoir pourquoi: je teste les coordonnées 2D de ma souris avec les coordonnées 3D de mes droites de la bounding box.

Donc ma question est la suivante: peut-on récupérer les coordonnées 2D (de l'écran donc) à partir des coordonnées 3D (les coordonnées OpenGL)?

Merci d'avance.

[darkman19320]

Bonjour,

Merci pour ta réponse. J'ai trouvé quelques papiers sur l'intersection des axes-aligned bounding box (Fast Ray-Axis Aligned Bounding Box Overlap Tests with Plucker Coordinates
, Fast Ray/Axis-Aligned Bounding
Box Overlap Tests using Ray Slopes
) mais je ne comprends pas comment récupérer les coordonnées du point d'intersection à partir des algos décrit...
As-tu des algos à me conseiller?

PS: Je n'ai absolument pas compris l'histoire de rotation inversée du rayon...

[pseudocode]

Merci pour ta réponse. J'ai trouvé quelques papiers sur l'intersection des axes-aligned bounding box (Fast Ray-Axis Aligned Bounding Box Overlap Tests with Plucker Coordinates
, Fast Ray/Axis-Aligned Bounding
Box Overlap Tests using Ray Slopes
) mais je ne comprends pas comment récupérer les coordonnées du point d'intersection à partir des algos décrit...
As-tu des algos à me conseiller?

Tous ces algos font seulement le "test" pour savoir si le rayon intersecte la box (ils retournent true/false). Mais ils ne calculent pas les coordonnées d'intersection.

Tu as un algo basique dans GraphicsGems : http://tog.acm.org/resources/GraphicsGems/gems/RayBox.c

En cas d'intersection (la fonction retourne true) les coordonnées sont retournées dans le tableau coord[]

PS: Je n'ai absolument pas compris l'histoire de rotation inversée du rayon...

Un rayon horizontal qui se dirige vers une Box orienté a 45°, c'est la meme chose qu'un rayon orienté à -45° qui se dirige vers une Box horizontale. C'est juste un changement de repère

[darkman19320]

Merci beaucoup pour tes réponses!!
J'arrive au bout ^^
Il ne me manque plus qu'à corriger les coordonnées de la direction et de l'origine de mon rayon en fonction de la rotation de ma bounding box.
Donc si je ne me trompe pas, il faut que je multiplie les deux vecteurs (origine et direction) par la matrice de rotation au tour d'un axe quelconque?

[pseudocode]

Merci beaucoup pour tes réponses!!
J'arrive au bout ^^
Il ne me manque plus qu'à corriger les coordonnées de la direction et de l'origine de mon rayon en fonction de la rotation de ma bounding box.
Donc si je ne me trompe pas, il faut que je multiplie les deux vecteurs (origine et direction) par la matrice de rotation au tour d'un axe quelconque?

Tu utilises la matrice inverse de celle de la bounding box, ce qui revient a construire une matrice de faisant les opérations opposées (rotation de l'angle opposé, translation de la valeur opposé, ...)