开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 查看源码
_circle.c
资源名称：leda.tar.gz　[点击查看]
上传用户：gzelex
上传日期：2007-01-07
资源大小：707k
文件大小：4k
源码类别：

数值算法/人工智能

开发平台：

MultiPlatform

_circle.c：源码内容
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  _circle.c
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  14. #include <LEDA/circle.h>
  15. #include <math.h>
  18. //------------------------------------------------------------------------------
  19. // circles
  20. //------------------------------------------------------------------------------
  23. circle::circle() 
  24. { PTR = new circle_rep; }
  26. circle::circle(const point& c, double r)       
  27. { PTR = new circle_rep(c,r); }
  29. circle::circle(double x, double y, double r)  
  30. { PTR = new circle_rep(point(x,y),r); }
  32. circle::circle(const point& a, const point& b, const point& c)
  33. { if (collinear(a,b,c)) 
  34.      error_handler(1,"circle::circle(a,b,c): points are collinear.");
  35.   line l1 = p_bisector(a,b);
  36.   line l2 = p_bisector(b,c);
  37.   point m;
  38.   l1.intersection(l2,m);
  39.   PTR = new circle_rep(m,m.distance(a));
  40.  }
  42.   
  44. bool circle::operator==(const circle& c)  const
  45. { return ptr()->center == c.ptr()->center && ptr()->radius == c.ptr()->radius; }
  48. double circle::distance(const point& p) const
  49. { double d = p.distance(ptr()->center);
  50.   return (d - ptr()->radius);
  51.  }
  53. double circle::distance(const line& l) const
  54. { double d = l.distance(ptr()->center);
  55.   return (d - ptr()->radius);
  56.  }
  58. double circle::distance(const circle& c) const
  59. { double d = ptr()->center.distance(c.ptr()->center);
  60.   return (d - ptr()->radius - c.ptr()->radius);
  61.  }
  63. bool circle::inside(const point& p) const 
  64. { return distance(p)<=0; }
  67. circle circle::translate(double alpha, double d) const
  68. { point p = ptr()->center.translate(alpha,d);
  69.   return circle(p,ptr()->radius);
  70.  }
  72. circle circle::translate(const vector& v) const
  73. { point p = ptr()->center.translate(v);
  74.   return circle(p,ptr()->radius);
  75.  }
  77. circle  circle::rotate(const point& o, double alpha) const
  78. { return circle(ptr()->center.rotate(o,alpha),ptr()->radius); 
  79.  }
  81. circle  circle::rotate(double alpha)          const
  82. { return rotate(point(0,0),alpha);
  83.  }
  85. list<point> circle::intersection(const line& l) const
  86. { list<point> result;
  87.   segment s = l.perpendicular(ptr()->center);
  88.   double  d = s.length();
  89.   double  r = ptr()->radius;
  90.   point   F = s.end();
  92.   if (d==r) result.append(F);
  93.   
  94.   if (d < r)
  95.   { double alpha = l.angle();
  96.     double x = sqrt(r*r - d*d);
  97.     point  p = F.translate(alpha,x);
  98.     point  q = F.translate(alpha,-x);
  99.     result.append(q);
  100.     result.append(p);
  101.   }
  103.   return result;
  104. }
  107. list<point> circle::intersection(const segment& s) const
  108. { list<point> result,L;
  110.   L = intersection(line(s));
  112.   point p;
  113.   double  d  = s.length();
  115.   forall(p,L)
  116.   { double d1 = s.ptr()->start.distance(p);
  117.     double d2 = s.ptr()->end.distance(p);
  118.     if (d1 <= d && d2 <= d) result.append(p);
  119.    }
  121.   return result;
  122. }
  124. list<point> circle::intersection(const circle& c) const
  125. { list<point> result;
  126.   segment s(ptr()->center, c.ptr()->center);
  127.   double d  = s.length();
  128.   double r1 = ptr()->radius;
  129.   double r2 = c.ptr()->radius;
  131.   if (d > (r1+r2) || (d+r2) < r1 || (d+r1) < r2) return result;
  134.   double x = (d*d + r1*r1 - r2*r2)/(2*d);
  135.   double alpha = acos(x/r1);
  136.   double beta  = s.angle() + alpha;
  137.   double gamma = s.angle() - alpha;
  139.   result.append(ptr()->center.translate(beta,r1));
  140.   if (alpha!=0) result.append(ptr()->center.translate(gamma,r1));
  142.   return result;
  143.  }
  146. segment circle::left_tangent(const point& p) const
  147. { if (inside(p)) error_handler(1,"left_tangent:: point inside circle");
  148.   segment s(p,ptr()->center);
  149.   double d = s.length();
  150.   double alpha = asin(ptr()->radius/d) + s.angle();
  151.   point touch = p.translate(alpha,sqrt(d*d - ptr()->radius*ptr()->radius));
  152.   return segment(p,touch);
  153. }
  155. segment circle::right_tangent(const point& p) const
  156. { if (inside(p)) error_handler(1,"right_tangent:: point inside circle");
  157.   segment s(p,ptr()->center);
  158.   double d = s.length();
  159.   double alpha = s.angle() - asin(ptr()->radius/d);
  160.   point touch = p.translate(alpha,sqrt(d*d - ptr()->radius*ptr()->radius));
  161.   return segment(p,touch);
  162. }
  164. ostream& operator<<(ostream& out, const circle& c) 
  165. { out << c.center() << " "<< c.radius(); 
  166.   return out;
  167.  } 
  169. istream& operator>>(istream& in,  circle& c) 
  170. { point cent;
  171.   double rad;
  172.   if (in) in >> cent;
  173.   if (in) in >> rad;
  174.   c = circle(cent,rad);
  175.   return in;
  176. }