home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / src / plane / _circle.c next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  4.3 KB  |  178 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  _circle.c
  7. +
  8. +
  9. +  Copyright (c) 1991  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. #include <LEDA/plane.h>
  18. #include <math.h>
  19.  
  20. static const double eps = 1e-10;
  21.  
  22. //------------------------------------------------------------------------------
  23. // circles
  24. //------------------------------------------------------------------------------
  25.  
  26.  
  27. circle_rep::circle_rep(point p, double r)  
  28. { center = p;
  29.   radius = r;
  30.   count = 1; 
  31.  }
  32.  
  33. circle_rep::circle_rep()                { count = 1; }
  34.  
  35. circle::circle()                        { ptr = new circle_rep; }
  36. circle::circle(int)                     { ptr = new circle_rep; }
  37. circle::circle(ent x)                   { ptr= (circle_rep*)x; ptr->count++; }
  38. circle::circle(circle& l)               { ptr = l.ptr; ptr->count++; }
  39. circle::circle(point c, double r)         { ptr = new circle_rep(c,r); }
  40. circle::circle(double x, double y, double r)  { ptr = new circle_rep(point(x,y),r); }
  41. void circle::clear()                    { if (--(ptr->count)==0) delete ptr; }
  42.   
  43.  
  44. int circle::operator==(const circle& c) 
  45. { double dr =  fabs(ptr->radius - c.ptr->radius);
  46.   return (ptr->center == c.ptr->center && dr < eps);
  47.  }
  48.  
  49.  
  50. double circle::distance(point p)
  51. { double d = p.distance(ptr->center);
  52.   return (d - ptr->radius);
  53.  }
  54.  
  55. double circle::distance(line l)
  56. { double d = l.distance(ptr->center);
  57.   return (d - ptr->radius);
  58.  }
  59.  
  60. double circle::distance(circle c)
  61. { double d = ptr->center.distance(c.ptr->center);
  62.   return (d - ptr->radius - c.ptr->radius);
  63.  }
  64.  
  65. bool circle::inside(point p) { return distance(p)<=0; }
  66.  
  67.  
  68. circle circle::translate(double alpha, double d)
  69. { point p = ptr->center.translate(alpha,d);
  70.   return circle(p,ptr->radius);
  71.  }
  72.  
  73. circle circle::translate(const vector& v)
  74. { point p = ptr->center.translate(v);
  75.   return circle(p,ptr->radius);
  76.  }
  77.  
  78. circle  circle::rotate(point o, double alpha)
  79. { return circle(ptr->center.rotate(o,alpha),ptr->radius); 
  80.  }
  81.  
  82. circle  circle::rotate(double alpha)         
  83. { return rotate(point(0,0),alpha);
  84.  }
  85.  
  86. segment circle::left_tangent(point p)
  87. { if (inside(p)) error_handler(1,"left_tangent:: point inside circle");
  88.   segment s(p,ptr->center);
  89.   double d = s.length();
  90.   double alpha = asin(ptr->radius/d) + s.angle();
  91.   point touch = p.translate(alpha,sqrt(d*d - ptr->radius*ptr->radius));
  92.   return segment(p,touch);
  93. }
  94.  
  95. segment circle::right_tangent(point p)
  96. { if (inside(p)) error_handler(1,"right_tangent:: point inside circle");
  97.   segment s(p,ptr->center);
  98.   double d = s.length();
  99.   double alpha = s.angle() - asin(ptr->radius/d);
  100.   point touch = p.translate(alpha,sqrt(d*d - ptr->radius*ptr->radius));
  101.   return segment(p,touch);
  102. }
  103.  
  104.  
  105. list(point) circle::intersection(line l)
  106. { list(point) result;
  107.   segment s = l.perpendicular(ptr->center);
  108.   double  d = s.length();
  109.   double  r = ptr->radius;
  110.   point   F = s.end();
  111.  
  112.   if (d==r) result.append(F);
  113.   
  114.   if (d < r)
  115.   { double alpha = l.angle();
  116.     double x = sqrt(r*r - d*d);
  117.     point  p = F.translate(alpha,x);
  118.     point  q = F.translate(alpha,-x);
  119.     result.append(q);
  120.     result.append(p);
  121.   }
  122.  
  123.   return result;
  124. }
  125.  
  126.  
  127. list(point) circle::intersection(segment s)
  128. { list(point) result,L;
  129.  
  130.   line l(s);
  131.   L = intersection(l);
  132.  
  133.   point p;
  134.   double  d  = s.length();
  135.  
  136.   forall(p,L)
  137.   { double d1 = s.ptr->start.distance(p);
  138.     double d2 = s.ptr->end.distance(p);
  139.     if (d1 <= d && d2 <= d) result.append(p);
  140.    }
  141.  
  142.   return result;
  143. }
  144.  
  145. list(point) circle::intersection(circle c)
  146. { list(point) result;
  147.   segment s(ptr->center, c.ptr->center);
  148.   double d  = s.length();
  149.   double r1 = ptr->radius;
  150.   double r2 = c.ptr->radius;
  151.  
  152.   if (d > (r1+r2) || (d+r2) < r1 || (d+r1) < r2) return result;
  153.  
  154.  
  155.   double x = (d*d + r1*r1 - r2*r2)/(2*d);
  156.   double alpha = acos(x/r1);
  157.   double beta  = s.angle() + alpha;
  158.   double gamma = s.angle() - alpha;
  159.  
  160.   result.append(ptr->center.translate(beta,r1));
  161.   if (alpha!=0) result.append(ptr->center.translate(gamma,r1));
  162.  
  163.   return result;
  164.  }
  165.  
  166.  
  167. ostream& operator<<(ostream& out, const circle& c) 
  168. { out << "(" << c.center() << "*"<< c.radius() <<")"; 
  169.   return out;
  170.  } 
  171.  
  172. istream& operator>>(istream& in,  circle& c) 
  173. { in >> c.ptr->center >> c.ptr->radius;
  174.   return in;
  175. }
  176.  
  177.  
  178.