[Géométrie] Obtenir une droite parallèle à une autre

[Argorate]

Bonjour,

pour un projet pour la fac en webGL, j'ai besoin de créer des murs.
Pour ce faire on a une interface qui permet de définir des droites: on va sur notre éditeur html5, on click à un endroit (p1), puis un autre (p2), et on obtient une droite.
On définit une hauteur (h) des murs, donc on peut facilement avoir les deux points "au dessus".

Reste le problème pour obtenir la profondeur du mur maintenant.

Comment à partir de mes deux points p1, p2, obtenir les points p3, p4 qui serait les projetés respectif de p1, p2 sur une perpendiculaire à la droite qu'ils forment, et dont la distance (d) serait fixé à 1 par exemple.

Le but étant à la fin que p1, p2, p3, p4 forme un rectangle (et via la hauteur h, on obtient les 4 autres points pour formé le pavé droit correspondant au mur et passé toutes ces coordonnées à webGL).


Quelqu'un sait faire ça? Même le prof a du mal (même s'il nous demande de le faire et noté bien sur ^^).

merci.

[niahoo]

t'es sûr pour le mot "perpendiculaire" ?

[Argorate]

J'ai fais un dessin (voir pièce jointe),

J'ai les points rouge et vert en cliquant où je veux pour définir mon mur.
Je veux trouver le point bleu qui est à l'intersection de ma perpendiculaire qui est fixé comme étant la profondeur et la parallèle au premier plan du mur.

(faudrait ensuite projeter de la même manière le point vert pour trouvé le 4ème points manquant)


plus clair?

[Xenos]

Donc, tu as un point PR(X,Y) (rouge), un point PV(U,V) (vert), dans un plan 2D. Tu as fixé une valeur, L, qui est la distance entre le point rouge et le point pb(i,j) (bleu). Donc, on cherche la position de ce point bleu, sachant:

• Que la distance d(PR, pb) = L
  
• La droite (PR, pb) est perpendiculaire à la droite (PR, PV)

Le vecteur D=(PR, PV) est de coordonnées (U-X, V-Y).
Posons le vecteur v(V-Y, X-U) (attention, U et X sont "inversés": on avait U-X avant, là, dans v, on a X-U)
Vérifions que v┴D, c'est à dire que les deux vecteurs sont orthogonaux.
v┴D
<=> v.D = 0, où . est le produit scalaire
<=> (V-Y)*(U-X)+(X-U)*(V-Y) = 0
Cette dernière affirmation est vraie (il suffit de simplifier le membre de gauche). Par équivalences, on a donc bien v┴D.
Donc, on sait que la droite (PR,pb) est de vecteur directeur v et passe par PR.
On connait la distance D=(PR,pb), on connait le vecteur directeur de la droite, y'a plus qu'à multiplier:

pb=PR + N(v)*L

où N(.) est la fonction de normalisation du vecteur, c'est à dire que pour tout vecteur x non nul, N(x) = x/||x||, où ||x|| est la norme (longueur) de x.

En terme de coordonnées:

(a,b) = (X, Y) + L*(V-Y, X-U)/sqrt( (V-Y)² + (X-U)² )

Note:

• On aurait tout aussi bien pu passer en 3D, et poser v=(PV-PR)^(0 0 1), avec (PV-PR) = (U-X, V-Y, 0).
  
• L'algorithme fonctionne quelles que soient les coordonnées des points (pas de "si ma droite ext parallèle à l'abscisse, je suis coincé!)
  
• On vérifie facilement que
  • ||pb-PR||=||(a,b)-(X,Y)||=||L*(V-Y, X-U)/sqrt( (V-Y)² + (X-U)² )|| = |L| = L > 0
    
  • (pb-PR).(PV-PR) = ((a,b)-(X,Y)).((U,V)-(X,Y)) = (L*(V-Y, X-U)/sqrt( (V-Y)² + (X-U)² )).(U-X,V-Y) = k*(V-Y, X-U).(U-X,V-Y) = 0
    
  Donc le résultat répond bien au problème posé.
  
• Si l'orientation choisie n'est pas celle que tu souhaites (ici, PR=(0,0), PV=(1,0) et L=1 impliquent (a,b)=(0,0)+1*(0-0, 0-1)=(0,-1), c'est à dire que si la droite Rouge/Vert est l'axe des abscisses et que L>0, alors le point bleu est en y<0), il suffit de changer L en -L dans le "théorème", en d'autres mots:
  
  

  (a,b) = (X, Y) - L*(V-Y, X-U)/sqrt( (V-Y)² + (X-U)² )

  
  Est aussi une bonne réponse (tout dépend de l'orientation que tu choisie)
  

j'espère avoir répondu au problème posé...

[Argorate]

Salut,

j'avais pas prit le temps de reprendre le problème, mais maintenant j'en ai besoin^^

Donc ce qui m’embête pour l'instant c'est que je ne sais pas lire ta réponse:

"(a,b) = (X, Y) + L*(V-Y, X-U)/sqrt( (V-Y)² + (X-U)² )", ça ne veux rien dire "(X, Y)" quand tu mets une virgule quelle opération correspond? (idem pour "(V-Y, X-U)")

j'avais moi aussi trouvé deux formules en fonction de l'orientation mais pour pouvoir comparer faudrait que je comprenne tes résultats.

merci.

[Xenos]

C'est une notation parfaitement valide, qui concerne les opérations sur les vecteurs.
(x,y) = _scalaire_ _operateur_ (u,v) revient à x = _scalaire _operateur_ u et y = _scalaire_ _operateur_ v
En d'autres mots, cela regroupe en une ligne des calculs similaires sur les coordonnées des vecteurs.
Tu peux donc la traduire par:

a = X + L*(V-Y)/sqrt( (V-Y)² + (X-U)² )
b = Y + L*(X-U)/sqrt( (V-Y)² + (X-U)² )

qui peut aussi se lire (plus léger):
K = L/sqrt( (V-Y)² + (X-U)² )
a = X + (V-Y)*K
b = Y + (X-U)*K

Cela revient exactement au même que l'écriture:
K = L/sqrt( (V-Y)² + (X-U)² )
(a, b) = (X, Y) + (V-Y, X-U)*K

Si tu écris les vecteurs en colonne, tu retombe sur l'écriture du dessus:
( a )=( X )+(V-Y)*K
( b ) ( Y ) (X-U)

[Argorate]

Cela ne marche pas en utilisant:

delta = L = 15
p1 = vert
p2 = rouge
P3 = bleu

p3.x = p2.x + delta * (p1.y-p2.y) / Math.sqrt( Math.pow(p1.y-p2.y, 2) + Math.pow(p1.x-p2.x, 2) );
p3.y = p2.y + delta * (p1.x-p2.x) / Math.sqrt( Math.pow(p1.y-p2.y, 2) + Math.pow(p1.x-p2.x, 2) );

je t'ai mis en ligne le code pour que tu vois ce que ça fait^^

http://rapturestudio.fr/partage/mur/generateur3D.html

[Xenos]

T'as mal lu je crois (la page donnée ne fait rien du tout chez moi, j'ai juste une div avec une bordure rouge autour...)
Le 1er, c'est V-Y le 2nd, c'est X-U... Comment peux-tu te retrouver avec p1.y-p2.y (donc V-Y) et p1.x-p2.x (donc U-X)?

p3.x = p2.x + delta * (p1.y-p2.y) / Math.sqrt( Math.pow(p1.y-p2.y, 2) + Math.pow(p1.x-p2.x, 2) );
p3.y = p2.y + delta * (p2.x-p1.x) / Math.sqrt( Math.pow(p1.y-p2.y, 2) + Math.pow(p1.x-p2.x, 2) );

[Argorate]

Il faut click 2 fois pour définir les 2 points de départ en fait

Mais en effet ça marche mieux sans l'erreur d'étourderie^^

merci !

Maintenant plus qu'a transmettre les coordonnées a webGl ^^