Back to index

wims  3.65+svn20090927
point.java
Go to the documentation of this file.
00001 // geo/point.java - 02/12/98
00002 
00003 package geo ;
00004 
00009 public class point extends pt
00010 {
00011 
00016   public point (String Nom, Repere R)
00017   { super (Nom, R) ; }
00018 
00023   public point (pt A, String Nom, Repere R)
00024   { super (A, Nom, R) ; }
00025 
00030   public point (int X, int Y, String Nom, Repere R)
00031   { super (X, Y, Nom, R) ; }
00032 
00037   public point (double x, double y, String Nom, Repere R)
00038   { super (x, y, Nom, R) ; }
00039 
00044   public void Milieu (Segment s)
00045   { defini = s.defini ;
00046     if (defini) { x = (s.Ax + s.Bx) / 2.0 ; y = (s.Ay + s.By) / 2.0 ; majXY () ; }
00047   }
00048 
00053   public void Intersection (Droite d1, Droite d2)
00054   { double det = d1.a * d2.b - d2.a * d1.b ;
00055     defini = (d1.defini) && (d2.defini) && (det != 0.0) ;
00056     if (defini) { x = (d2.c * d1.b - d1.c * d2.b) / det ;
00057                   y = (d2.a * d1.c - d1.a * d2.c) / det ;
00058                   majXY () ; }
00059   }
00064   public void Intersection (Segment s1, Segment s2)
00065   { double a1 = s1.By - s1.Ay ; double b1 = s1.Ax - s1.Bx ; double c1 = s1.Ay * s1.Bx - s1.Ax * s1.By ;
00066     double a2 = s2.By - s2.Ay ; double b2 = s2.Ax - s2.Bx ; double c2 = s2.Ay * s2.Bx - s2.Ax * s2.By ;
00067     double det = a1 * b2 - a2 * b1 ;
00068     defini = (s1.defini) && (s2.defini) && (det != 0.0) ;
00069     if (defini) { x = (c2 * b1 - c1 * b2) / det ;
00070                   y = (a2 * c1 - a1 * c2) / det ;
00071                   majXY () ; }
00072   }
00073 
00078   public void Intersection1 (Droite d, Cercle c)
00079   { i12 (d, c, 1.0) ; }
00080 
00081 
00086   public void Intersection2 (Droite d, Cercle c)
00087   { i12 (d, c, -1.0) ; }
00088 
00089   private void i12 (Droite d, Cercle c, double signe)
00090   { defini = (d.defini) && (c.defini) ;
00091     if (defini) { if (d.b != 0.0) { double u = d.a * (d.c + d.b * c.yo) - d.b * d.b * c.xo ;
00092                                     double v = d.a * d.a + d.b * d.b ;
00093                                     double w = d.c + d.b * c.yo ;
00094                                     double deltap = u * u - v * (d.b * d.b * (c.xo * c.xo - c.r * c.r) + w * w) ;
00095                                     if (deltap >= 0.0) { x = (- u + signe * Math.sqrt (deltap)) / v ;
00096                                                          y = - (d.a * x + d.c) / d.b ; }
00097                                     else               defini = false ;
00098                                   }
00099                   else            { x = - d.c / d.a ;
00100                                     double u = x - c.xo ;
00101                                     double v = c.r * c.r - u * u ;
00102                                     if (v >= 0.0) y = c.yo + signe * Math.sqrt (v) ;
00103                                     else          defini = false ;
00104                                   }
00105                   majXY () ;
00106                 }
00107   }
00108 
00113   public void Intersection1 (Cercle c1, Cercle c2)
00114   { icc (c1, c2, 1.0) ; }
00115 
00116 
00121   public void Intersection2 (Cercle c1, Cercle c2)
00122   { icc (c1, c2, -1.0) ; }
00123 
00124   private void icc (Cercle c1, Cercle c2, double signe)
00125   { if (defini = c1.defini && c2.defini)
00126                    { double a1 = -2.0 * c1.xo ; double b1 = -2.0 * c1.yo ;
00127                   double a2 = -2.0 * c2.xo ; double b2 = -2.0 * c2.yo ;
00128                   double a12 = a1 - a2 ; double b12 = b1 - b2 ;
00129                   double a = a12 * a12 + b12 * b12 ;
00130                   if (defini = (a != 0.0))
00131                               { double C1 = c1.xo * c1.xo + c1.yo * c1.yo - c1.r * c1.r ;
00132                                 double C2 = c2.xo * c2.xo + c2.yo * c2.yo - c2.r * c2.r ;
00133                                 double C12 = C1 - C2 ;
00134                                 double b, c;
00135                                 boolean bpga = Math.abs(b12) >= Math.abs(a12) ;
00136                                 if (bpga)
00137                                    { b = 2.0 * a12 * C12 + b12 * (b1 * a2 - a1 * b2) ;
00138                                      c = C12 * C12 + b12 * (b1 * C2 - b2 * C1) ;
00139                                    }
00140                                 else
00141                                    { b = 2.0 * b12 * C12 + a12 * (a1 * b2 - b1 * a2) ;
00142                                      c = C12 * C12 + a12 * (a1 * C2 - a2 * C1) ;
00143                                    }
00144                                 double delta = b * b - 4.0 * a * c ;
00145                                 if (defini = (delta >= 0.0))
00146                                             { x = -0.5 * (b + signe * Math.sqrt (delta)) / a ;
00147                                               if (bpga) y = - (a12 * x + C12) / b12 ;
00148                                               else
00149                                               { y = x ; x = - (b12 * x + C12) / a12 ;
00150                                               }
00151                                               majXY () ;
00152                                             }
00153                               }
00154                 }
00155   }
00156 
00161   public void Centre (Cercle c)
00162   { defini = c.defini ;
00163     if (defini) { x = c.xo ; y = c.yo ; majXY () ; }
00164   }
00165 
00170   public void Projection (pt A, Droite d)
00171   { defini = A.defini && d.defini ;
00172     if (defini) { double u = (d.a * A.x + d.b * A.y + d.c) / (d.a * d.a + d.b * d.b) ;
00173                   x = A.x - u * d.a ; y = A.y - u * d.b ;
00174                   majXY () ;
00175                 }
00176   }
00177 
00182   public void Projection (pt A, Segment s)
00183   { double a, b ;
00184     a = s.Ay - s.By ; b = s.Bx - s.Ax ;
00185     defini = A.defini && ((a != 0.0) || (b != 0.0)) ;
00186     if (defini) { double c = - (a * s.Ax + b * s.Ay) ;
00187                   double u = (a * A.x + b * A.y + c) / (a * a + b * b) ;
00188                   x = A.x - u * a ; y = A.y - u * b ;
00189                   majXY () ;
00190                 }
00191   }
00192 
00197   public void Symetrique (pt A, Droite d)
00198 // modifié le 27/09/99 pour autoriser C.Symetrique (C, d) ;
00199   { double Ax = A.x ; double Ay = A.y ; Projection (A, d) ;
00200     if (defini) { x = 2.0 * x - Ax ; y = 2.0 * y - Ay ; majXY () ; }
00201   }
00202 
00207   public void Symetrique (pt A, Segment s)
00208   { double Ax = A.x ; double Ay = A.y ; Projection (A, s) ;
00209     if (defini) { x = 2.0 * x - Ax ; y = 2.0 * y - Ay ; majXY () ; }
00210   }
00211 
00216   public void Rotation1 (pt A, pt O, ArcDeCercle ARC)
00217   { if (defini = ARC.defini) Rotation (A, O, ARC.b) ;
00218   }
00219 
00224    public double Distance (Droite d)
00225    { if (defini && d.defini) return Math.abs (d.a * x + d.b * y + d.c) / Math.sqrt (d.a * d.a + d.b * d.b) ;
00226      else                    return -1.0 ;
00227    }
00228 
00229 
00234    public double Distance (Segment s)
00235    { double resultat = -1.0 ;
00236      if (defini && s.defini) { double a = s.By - s.Ay ; double b = s.Ax - s.Bx ;
00237                                if ((a != 0.0) || (b != 0.0))
00238                 resultat = Math.abs (a * x + b * y + s.Ay * s.Bx - s.Ax * s.By) / Math.sqrt (a * a + b * b) ;
00239                              }
00240    return resultat ;
00241    }
00242 
00247    public void Translation (pt A, Vecteur v)
00248    { defini = A.defini && v.defini ;
00249      if (defini)
00250        { x = A.x + v.x ; y = A.y + v.y ;
00251          majXY () ;
00252        }
00253    }
00254 
00255 }