Perpendiculaire sur une ligne à partir d'un point donné
Comment puis-je dessiner une perpendiculaire sur un segment de ligne à partir d'un point donné? Mon segment de ligne est défini comme (x1, y1), (x2, y2), si je dessine une perpendiculaire d'un point (x3, y3) et qu'elle se rencontre à la ligne sur le point (x4,y4). Je veux savoir ceci (x4, y4).
10 réponses
J'ai résolu les équations pour vous:
k = ((y2-y1) * (x3-x1) - (x2-x1) * (y3-y1)) / ((y2-y1)^2 + (x2-x1)^2)
x4 = x3 - k * (y2-y1)
y4 = y3 + k * (x2-x1)
Où ^2 signifie au carré
À Partir de wiki:
En algèbre, pour toute équation linéaire y = mx + b, les perpendiculaires seront toutes avoir une pente de (-1 / m) , le contraire réciproque de la pente initiale. Il est utile de mémoriser le slogan "à trouver la pente de la perpendiculaire ligne, retourner la fraction et changer le signer."Rappelons que tout nombre entier une est lui-même sur un, et peut être écrit comme (a/1)
Pour trouver la perpendiculaire d'un ligne qui traverse également un point particulier (x, y), résoudre le équation y = (-1 / m) x + b, en remplaçant dans les valeurs connues de m, x et y pour résoudre pour B.
La pente de La ligne, m, par (x1, y1) et (x2, y2) est m = (y1 - y2) / (x1 - x2)
Je suis d'accord avec pierre.Murray.rouille, les vecteurs rendent la solution plus claire:
// first convert line to normalized unit vector
double dx = x2 - x1;
double dy = y2 - y1;
double mag = sqrt(dx*dx + dy*dy);
dx /= mag;
dy /= mag;
// translate the point and get the dot product
double lambda = (dx * (x3 - x1)) + (dy * (y3 - y1));
x4 = (dx * lambda) + x1;
y4 = (dy * lambda) + y1;
Vous constaterez souvent que l'utilisation de vecteurs rend la solution plus claire...
Voici une routine de ma propre bibliothèque:
public class Line2 {
Real2 from;
Real2 to;
Vector2 vector;
Vector2 unitVector = null;
public Real2 getNearestPointOnLine(Real2 point) {
unitVector = to.subtract(from).getUnitVector();
Vector2 lp = new Vector2(point.subtract(this.from));
double lambda = unitVector.dotProduct(lp);
Real2 vv = unitVector.multiplyBy(lambda);
return from.plus(vv);
}
}
Vous devrez implémenter Real2 (a point) et Vector2 et dotProduct () mais ceux-ci devraient être simples:
Le code ressemble alors à quelque chose comme:
Point2 p1 = new Point2(x1, y1);
Point2 p2 = new Point2(x2, y2);
Point2 p3 = new Point2(x3, y3);
Line2 line = new Line2(p1, p2);
Point2 p4 = getNearestPointOnLine(p3);
La bibliothèque (org.xmlcml.euclide) est à: http://sourceforge.net/projects/cml/
Et il y a des tests unitaires qui exerceront cette méthode et vous montreront comment utiliser.
@Test
public final void testGetNearestPointOnLine() {
Real2 p = l1112.getNearestPointOnLine(new Real2(0., 0.));
Real2Test.assertEquals("point", new Real2(0.4, -0.2), p, 0.0000001);
}
Vous connaissez à la fois le point et la pente, donc l'équation pour la nouvelle ligne est:
y-y3=m*(x-x3)
Puisque la ligne est perpendiculaire, la pente est la réciproque négative. Vous avez maintenant deux équations et pouvez résoudre pour leur intersection.
y-y3=-(1/m)*(x-x3)
y-y1=m*(x-x1)
Calculez la pente des points de jonction de ligne (x1, y1) et (x2, y2) comme m=(y2-y1)/(x2-x1)
Équation de la ligne joignant (x1, y1) et (x2, y2) en utilisant la forme de pente de l'équation de la ligne, serait y-y2 = m(x-x2)
Pente de la droite joignant (x3,y3) et (x4,y4) serait -(1/m)
Encore une fois, l'équation de la ligne joignant (x3, y3) et (x4, y4) en utilisant la forme de pente ponctuelle de l'équation de la ligne, serait y-y3 = -(1/m)(x-x3)
Résolvez ces deux équations linéaires en résolvant une équation linéaire en deux variables et les valeurs de x et y, vous obtenez serait votre (x4,y4)
J'espère que cela aide.
Santé
Découvrez les pistes pour les deux les lignes, disons les pentes sont m1 et m2 alors m1*m2=-1, est la condition de perpendicularité.
Code de fonction Matlab pour le problème suivant
function Pr=getSpPoint(Line,Point)
% getSpPoint(): find Perpendicular on a line segment from a given point
x1=Line(1,1);
y1=Line(1,2);
x2=Line(2,1);
y2=Line(2,1);
x3=Point(1,1);
y3=Point(1,2);
px = x2-x1;
py = y2-y1;
dAB = px*px + py*py;
u = ((x3 - x1) * px + (y3 - y1) * py) / dAB;
x = x1 + u * px;
y = y1 + u * py;
Pr=[x,y];
end
Mathematica a introduit la fonction RegionNearest[] dans la version 10, 2014. Cette fonction pourrait être utilisée pour renvoyer une réponse à cette question:
{x4,y4} = RegionNearest[Line[{{x1,y1},{x2,y2}}],{x3,y3}]
C'est surtout un duplicata de la réponse D'Arnkrishn. Je voulais juste compléter sa section avec un extrait de code Mathematica complet:
m = (y2 - y1)/(x2 - x1)
eqn1 = y - y3 == -(1/m)*(x - x3)
eqn2 = y - y1 == m*(x - x1)
Solve[eqn1 && eqn2, {x, y}]