Projection d'un point sur une parabole

[invitef23f09d0]

Bonsoir,

Comme indiqué dans le titre, je cherche un moyen de calculer les coordonnées (x1,y1) de la projection P1 d'un point P2 (x2,y2) sur une parabole C d'équation y = a.x²+b.x+c

J'ai beau chercher sur le net depuis plus d'une semaine, je ne trouve rien qui puisse m'aider...

Voici où j'en suis :
- la droite qui passe par P1 et P2 est perpendiculaire à la tangente à la courbe en P1
- en P1 la tangente a pour coefficient directeur la dérivée de l'équation de la parabole en P1 soit 2.a2.x1+a1
- le coefficient directeur de la droite perpendiculaire à la tangente est donc -1/(2.a2.x1+a1)
- le coefficient directeur de la droite D:y=m.x-b passant par P1 et P2 est également m=(y1-y2)/yx1-x2), et l'ordonnée à l'origine de cette droite est b=(x1.y2-x2.y1)/(x1-x2)
- les intersections d'une droite et d'une parabole peuvent être trouvées par les racines du polynôme résultant de (m.x+b) - (a2.x²+a1.x+a0)
-on peut également dire que, au point P1, les équations de la courbe C et de la droite D sont égales, soit a2.x1²+a1.x1+a0=x1.(y1-y2)/(x1-x2) + (x1.y2-x2.y1)/(x1-x2), ce qui cnduit à trouver les racines du polynôme m3.x^3+m2.x²+m1.x+m0 avec m3=2.a2², m2=3.a1.a2, m1=2.a2.(a0-y2)+a1²+1, m0=a1.(a0-y2)-x2

C'est là que je coince, car ce polynôme peut avoir 1, 2 ou 3 racines distinctes, et je ne vois pas comment une droite pourrait avoir 3 intersections avec une parabole...

Quelqu'un peut-il me dire su mes calculs sont corrects, et éventuellement finir la résoolution de ce problème?

Merci d'avance
David
-----

[invite803a8ebc]

Bonsoir,
là comme ça intuitivement, je pense que le fait que le point soit à l'intérieur ou à l'extérieur de la parabole peut changer bien des choses (nombre de projetés par exemple)
sinon encore sans réfléchir, peut-être que la formule de la distance d'un point à une droite peut être utile, j'y réfléchirai.
a+

[invitea84d96f1]

Salut,
C'est bien normal (sans jeu de mots) qu'il y a jusque 3 pieds de normales issues d'un point vers une conique (ellipse, hyperbole, parabole).
Il est démontré que ces 3 points se trouvent à l'intersection de la parabole avec une hyperbole équilatère d'Apollonius passant par le point donné.
Cet article en parle mais trop peu, j'ai appris 3 et non 4 pieds.
http://users.skynet.be/bk337103/Fiches/FIGAP001.html#9

Parabole : y = ax² +bx +c
Fonction pente = 2ax +b

1) Point (x₁;y₁) recherché, sur la parabole... donc y₁ = ax₁² +bx₁ +c (1)
2) Pente de la tangente en ce point = 2ax₁ +b
Cette pente est aussi l'opposée de l'inverse de la pente de P₁P₂ = -(x₁-x₂)/(y₁-y₂)
D'où (y₁-y₂)(2ax₁ +b) = -x₁ +x₂ (2)

On a bien 2 équations à 2 inconnues x₁ et y₁

En remplaçant dans (2) y₁ par son expression (1) on obtient une équation de 3e degré en x₁
(ax₁² +bx₁ +c -y₂)(2ax₁ +b) = -x₁ +x₂

[invitef23f09d0]

Victoire!

J'ai finalement réussi à m'en sortir en prenant le problème plus intuitivement:

J'ai lu je ne sais plus où que la distance la plus courte d'un point à une courbe est la droite reliant ce point à sa projection sur la courbe. J'ai donc cherché le ou les extrema de la fonction qui donne la distance entre un point de la courbe et mon point P2, que je connais.

Cela donne donc

les extrema sont trouvés en étudiant la dérivée de la fonction, donc en trouvant les racines de

Je me suis donc concentré sur les racines de

En utilisant la méthode de Cardan j'obtiens ma ou mes racines, donc l'abscisse de mon point projeté, donc son ordonnée puisqu'il est sur la parabole...

Voila. J'ai implémenté tout ça rapidement avec une petit logiciel fort sympatique (Processing), et ça marche plutôt pas mal...

int maxsize = 100;
Point[] pts = new Point[maxsize];
Point[] prj = new Point[maxsize];
int index,indprj;
float a2,a1,a0,nb_pts;
color defcolor,prjcolor;

void setup () {
  background (255);
  size (1000, 1000);
  a2 = 0.005;
  a1 = 0;
  a0 = 0;
  nb_pts = 10*width;
  defcolor = color (255,0,0);
  prjcolor = color (0,0,255);
  index = 0;
  indprj = 0;
}

void draw () {
  // Initialisation de la zone de traçage
  fill (255);
  rect (0, 0, width, height);
  // Axes du repère
  stroke (0);
  line (0, height/2, width, height/2);
  line (width/2, 0, width/2, height);
  // Dessin de la parabole
  for (float i = -nb_pts/2; i <= nb_pts/2; i = i + 1) {
    float x1 = i;
    float y1 = a2*pow(x1,2) + a1*x1 + a0;
    float x2 = i+1;
    float y2 = a2*pow(x2,2) + a1*x2 + a0;
    //println ("Point1 : ( " + x1 + " ; " + y1 + ")   --   Point2 : ( " + x2 + " ; " + y2 + ")");
    stroke (color(0,0,255));
    line (x1 + width/2, y1 + height/2, x2 + width/2, y2 + height/2);
  }
  // Dessin de la fonction représentant le distatnce du dernier point à la courbe 
  if ( index > 0 ) {
    for (float i = -nb_pts/2; i <= nb_pts/2; i = i + 1) {
      float x0 = pts[index].getx();
      float y0 = pts[index].gety();
      float x1 = i;
      float y1 = sqrt(pow(x1-x0,2)+pow(a2*pow(x1,2) + a1*x1 + a0-y0,2));
      float x2 = i+1;
      float y2 = sqrt(pow(x2-x0,2)+pow(a2*pow(x2,2) + a1*x2 + a0-y0,2));
      //println ("Point1 : ( " + x1 + " ; " + y1 + ")   --   Point2 : ( " + x2 + " ; " + y2 + ")");
      stroke (color(0,127,0));
      line (x1 + width/2, y1 + height/2, x2 + width/2, y2 + height/2);
    }
  }
  // Dessin d'un droite verticale à l'abscisse du dernier point projeté
  if ( indprj > 0 ) {
    stroke (color(200,200,255));
    line (prj[indprj].getx()+width/2, 0, prj[indprj].getx()+width/2, height);
  }
  // Dessin des points cliqués
  if (index > 0) {
    for ( int j = 1; j <= index; j = j + 1) {
      pts[j].plot();
    }
  }
  // Dessin des points projetés + ligne reliant chaque point cliqué à sa projection
  if (indprj > 0) {
    for ( int j = 1; j <= indprj; j = j + 1) {
      prj[j].plot();
      stroke (50);
      line (pts[j].getx()+width/2, pts[j].gety()+height/2, prj[j].getx()+width/2, prj[j].gety()+height/2);
    }
  }
  // Point pour tests
  point (width/2-105, height/2-50);
}

void mousePressed() {
  // Récupération des cooordonées du point dans le repère 
  float xc = mouseX - width/2;
  float yc = mouseY - height/2;
  // Ajout du point cliqué dans la liste de points
  if ( index >= maxsize-1 ) {
    pts = new Point[maxsize];
    prj = new Point[maxsize];
    index = 0;
    indprj=0;
  }
  index = index + 1;
  pts[index] = new Point(xc, yc, defcolor);
  // Calcul du point projeté sur la parabole
  float m0 = 2*a1*(a0-yc)-2*xc;
  float m1 = 4*a2*(a0-yc)+2*pow(a1,2)+2;
  float m2 = 6*a1*a2;
  float m3 = 4*pow(a2,2);
  float p = m1/m3 - pow(m2,2)/(3*pow(m3,2));
  float q = (2*pow(m2,3))/(27*pow(m3,3)) + m0/m3 - (m2*m1)/(3*pow(m3,2));
  float d = pow(q,2) + 4*pow(p,3)/27;
  float t = 0.333333333;
  //println ("Paramètres : m3="+m3+" ,m2="+m2+" m1="+m1+" m0="+m0+" - p="+p+" q="+q+" d="+d+" t="+t);
  float xp = 0;
  float yp = 0;
  if ( d > 0 ) { // 1 seule solution
    float r1,r2;
    if ( (-q-sqrt(d))/2 < 0 ) {
      r2 = -pow(abs((-q-sqrt(d))/2),t);
    } 
    else r2 = pow((-q-sqrt(d))/2,t);
    if ( (-q+sqrt(d))/2 < 0 ) {
      r1 = -pow(abs((-q+sqrt(d))/2),t);
    } 
    else r1 = pow((-q+sqrt(d))/2,t);
    xp = r1 + r2 - m2/(3*m3);
    yp = a2*pow(xp,2) + a1*xp + a0;
  }
  if ( d == 0 ) { // 2 solutions
    float x1 = 3*q/p-m2/(3*m3);
    float y1 = a2*pow(x1,2) + a1*x1 + a0;
    float d1 = dist(xc, yc, x1, y1);
    float x2 = -3*q/(2*p)-m2/(3*m3);
    float y2 = a2*pow(x2,2) + a1*x2 + a0;
    float d2 = dist(xc, yc, x2, y2);
    // Choix de la solution la plus proche du point cliqué
    if ( d1 <= d2 ) { xp = x1; yp = y1; }
    else { xp = x2; yp = y2; }
  }
  if ( d < 0) { // 3 solutions
    float x1 = 2*sqrt(-p/3)*cos((acos((-q/2)*sqrt(27/pow(-p,3))))/3+(2*PI)/3)-m2/(3*m3);
    float y1 = a2*pow(x1,2) + a1*x1 + a0;
    float d1 = dist(xc, yc, x1, y1);
    float x2 = 2*sqrt(-p/3)*cos((acos((-q/2)*sqrt(27/pow(-p,3))))/3+(2*PI*2)/3)-m2/(3*m3);
    float y2 = a2*pow(x2,2) + a1*x1 + a0;
    float d2 = dist(xc, yc, x2, y2);
    float x3 = 2*sqrt(-p/3)*cos((acos((-q/2)*sqrt(27/pow(-p,3))))/3+(2*PI*3)/3)-m2/(3*m3);
    float y3 = a2*pow(x3,2) + a1*x3 + a0;
    float d3 = dist(xc, yc, x3, y3);
    // Choix de la solution la plus proche du point cliqué
    if ( d1 <= d2 ) { 
      if ( d1 <= d3 ) { xp = x1; yp = y1; }
      else { xp = x3; yp = y3; }
    }
    else {
      if ( d2 <= d3 ) { xp = x2; yp = y2; }
      else { xp = x3; yp = y3; }
    }
  }
  println (index + "° point cliqué : ( " + xc + " ; " + yc + ")   -->   Point projeté : ( " + xp + " ; " + yp + ")");
  // Ajout du point projeté dans la liste de points projetés
  indprj = indprj + 1;
  prj[indprj] = new Point(xp, yp, prjcolor);
}

class Point {
  // données
  float x;
  float y;
  color c;
  
  // constructeur
  Point (float tmpx, float tmpy, color tmpc) {
    x = tmpx;
    y = tmpy;
    c = tmpc;
  }
  
  // méthodes
  void plot () {
    fill (c);
    stroke (c);
    ellipse (x + width/2, y + height/2, 3, 3);
  }
  float getx() { return x; }
  float gety() { return y; }
}

Merci de votre aide.

[A voir en vidéo sur Futura]