Bonjour,

Je recherche une classe java ayant pour parametres d'entrée 2 segments ( définis chacuns par 2 points dans l'espace ( xA,yA,zA) ( xB,yB,zB)  )  et ayant des méthodes pour connaitre:
- si ces segments s'intersectent... et si oui le point d'intersection
- si ces segments sont concourants... et si oui le ou les points extremes concourants.

Si qq peut m aider, d'avance merci.

Luc

Salut,

tu as essayé avec les classes Polygon (voir autre selon le besoin regarde les objet qui implémente Shape) et Area (qui permet de faire quelques manip de plus sur les Shape (Polygon l'implémente)?



------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

OoWORAoO

Pour trouver si les points sont coplanaires :
    - tu choisis l'une des extrémité comme centre du repère. Tu disposes donc de trois vecteurs par rapport à ce point : v1, v2, v3
    - tu fais le produit vectoriel entre deux des vecteurs v1^v2
    - tu calcules le produit scalaire du vecteur ainsi obtenu avec le troisième vecteur. (v1^v2).v3

--> Si le produit est nul, les points sont bien coplanaires.

Tu peux alors passer à la deuxième étape :

    -tu dois trouver le vecteur le vecteur normal à v1 contenu dans le plan, il suffit de faire v1^(v2^v3) = v4, (v2-v3)^(v1^v2) = v5
    -pour tester si il y a intersection, tu dois avoir :   (v2.v4)*(v3.v4) <=0 et (v2.v5)*((v2-v1).v5) <=0

Vince

avec les class java2D je ne connais pas de soluces ;o) cependant  ;o) avec les équation de tes droites ca pose pas de soucis normalement ;o) .... aller ;o) comme quoi faller pas jeter ses vieux bouquins de math ;o)...



[purple]GodConan[/purple][:o)]

public class Point
{
  double x, y, z;

  public Point(double x, double y, double z)
  {
    this.x= x;
    this.y= y;
    this.z= z;
  }

  public double scalProd(Point p)
  {
    return (x * p.x) + (y * p.y) + (z* p.z);
  }

  public Point vectProd(Point p)
  {
    return new Point((y * p.z) - (z * p.y),
                     (z * p.x) - (x * p.z),
                     (x * p.y) - (y * p.x));
  }

  public Point sub(Point p)
  {
    return new Point(x - p.x, y - p.y, z - p.z);
  }

  public double norm()
  {
    return scalProd(this);
  }
}

public class Segment
{
  Point e1, e2;

  public Segment(Point e1, Point e2)
  {
    this.e1= e1;
    this.e2= e2;
  }

  public Point intersection(Segment s)
  {
  }

  public Segment concourant(Segment s)
  {
    if( e1.sub(e2).vectProd(s.e1.sub(s.e2)).norm() > 1E-10 )
      return null;

    if( e1.sub(e2).vectProd(s.e1.sub(e1)).norm() > 1E-10 )
      return null;

    // Les 2 segments sont alignés sur une meme droite
    Point dir= e2.sub(e1);
    double n= Math.sqrt(dir.norm());
    Point u= new Point(dir.x / n, dir.y /n, dir.z / n);
    double pos1= e2.scalProd(u);
    double pos2= s.e1.scalProd(u);
    double pos3= s.e2.scalProd(u);
    boolean inv= false;

    if( pos2 > pos3 )
    {
      double t= pos2;

      pos2= pos3;
      pos3= t;
      inv= true;
    }

    if( (pos2 > pos1) || (pos3 < 0) )
      return null;

    if( (pos2 <= 0) && (pos3 >= pos1) )
      return this;

    if( (pos2 >= 0) && (pos3 <= pos1) )
      return s;

    if( pos2 < 0 )
      return new Segment(e1, ( inv )?s.e1:s.e2);
    else
      return new Segment(( inv )?s.e2:s.e1, e2);
  }
}


Core Breaker