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

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

数值算法/人工智能

开发平台：

MultiPlatform

_point.c：源码内容
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  _point.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/segment.h>
  15. #include <math.h>
  16. #include <ctype.h>
  18. //------------------------------------------------------------------------------
  19. // points 
  20. //------------------------------------------------------------------------------
  23. point_rep::point_rep()  { count=1; x = y = 0.0; }
  25. point_rep::point_rep(double a, double b) 
  26. { x = a; 
  27.   y = b; 
  28.   count = 1; 
  29. }
  33. point::point()                  { PTR = new point_rep; }
  34. point::point(double x, double y){ PTR = new point_rep(x,y); }
  35. point::point(vector v)          { PTR = new point_rep(v[0], v[1]); }
  37. double point::angle(const point& q, const point& r) const
  38. {
  39.   double cosfi,fi,norm;
  40.   
  41.   double dx  = q.ptr()->x - ptr()->x; 
  42.   double dy  = q.ptr()->y - ptr()->y; 
  44.   double dxs = r.ptr()->x - q.ptr()->x; 
  45.   double dys = r.ptr()->y - q.ptr()->y; 
  46.   
  47.   cosfi=dx*dxs+dy*dys;
  48.   
  49.   norm=(dx*dx+dy*dy)*(dxs*dxs+dys*dys);
  51.   cosfi /= sqrt( norm );
  53.   if (cosfi >=  1.0 ) return 0;
  54.   if (cosfi <= -1.0 ) return LEDA_PI;
  55.   
  56.   fi=acos(cosfi);
  58.   if (dx*dys-dy*dxs>0) return fi;
  60.   return -fi;
  61. }
  62.   
  65. // Rotations 
  67. point point::rotate90(const point& origin) const
  68. { double cx = origin.xcoord();
  69.   double cy = origin.ycoord();
  70.   double dx = xcoord() - cx;
  71.   double dy = ycoord() - cy;
  72.   return point(cx-dy,cy+dx);
  73. }
  75. point point::rotate90() const
  76. { return point(-ycoord(),xcoord()); }
  79. point point::rotate(const point& origin, double fi) const
  80. { double cx = origin.xcoord();
  81.   double cy = origin.ycoord();
  82.   double sinfi = sin(fi);
  83.   double cosfi = cos(fi);
  84.   double dx = xcoord() - cx;
  85.   double dy = ycoord() - cy;
  86.   return point(cx+dx*cosfi-dy*sinfi,cy+dx*sinfi+dy*cosfi);
  87. }
  90. point point::rotate(double fi) const
  91. { double sinfi = sin(fi);
  92.   double cosfi = cos(fi);
  93.   double x = xcoord();
  94.   double y = ycoord();
  95.   return point(x*cosfi-y*sinfi,x*sinfi+y*cosfi);
  96. }
  100. // Translations
  102. /*
  103. point point::translate(double dx, double dy) const
  104. { return point(xcoord()+dx,ycoord()+dy); }
  105. */
  108. point point::translate(double phi, double d) const
  109. { double dx = cos(phi) * d;
  110.   double dy = sin(phi) * d;
  111.   if (fabs(dx) < 1e-12) dx = 0; 
  112.   if (fabs(dy) < 1e-12) dy = 0; 
  113.   return point(xcoord()+dx,ycoord()+dy);
  114.  }
  116. point point::translate(const vector& v) const 
  117. { return point(xcoord()+v[0],ycoord()+v[1]); }
  120. // Distances
  122. double point::distance(const point& p)  const
  123. { double dx = p.ptr()->x - ptr()->x; 
  124.   double dy = p.ptr()->y - ptr()->y;
  125.   return sqrt(dx*dx + dy*dy);
  126.  }
  128. double point::distance() const
  129. { return distance(point(0,0)); }
  133. int point::operator==(const point& p) const 
  134. { return (ptr()->x == p.ptr()->x) && (ptr()->y == p.ptr()->y); }
  137.    
  139. int incircle(const point& a, const point& b, const point& c, const point& d)
  140. {
  141.    double ax = a.xcoord();
  142.    double ay = a.ycoord();
  144.    double bx = b.xcoord() - ax;
  145.    double by = b.ycoord() - ay;
  146.    double bw = bx*bx + by*by;
  148.    double cx = c.xcoord() - ax;
  149.    double cy = c.ycoord() - ay;
  150.    double cw = cx*cx + cy*cy;
  152.    double dx = d.xcoord() - ax;
  153.    double dy = d.ycoord() - ay;
  154.    double dw = dx*dx + dy*dy;
  156.    //return (by*cw-cy*bw) * (bx*dw-dx*bw) > (bx*cw-cx*bw) * (by*dw-dy*bw);
  158.    double D = (by*cx-bx*cy)*dw + (cy*bw-by*cw)*dx  + (bx*cw-cx*bw)*dy;
  160.    if (D != 0) 
  161.       return (D > 0) ? 1 : -1;
  162.    else
  163.       return 0;
  164.  }
  167. double area(const point& a, const point& b, const point& c)
  168. { return ((a.xcoord()-b.xcoord()) * (a.ycoord()-c.ycoord()) -
  169.           (a.ycoord()-b.ycoord()) * (a.xcoord()-c.xcoord()))/2; }
  173. ostream& operator<<(ostream& out, const point& p)
  174. { out << "(" << p.xcoord() << "," << p.ycoord() << ")";
  175.   return out;
  176.  } 
  178. istream& operator>>(istream& in, point& p) 
  179. { // syntax: {(} x {,} y {)}
  181.   double x,y; 
  182.   char c;
  184.   do in.get(c); while (in && isspace(c));
  186.   if (!in) return in;
  188.   if (c != '(') in.putback(c);
  190.   in >> x;
  192.   do in.get(c); while (isspace(c));
  193.   if (c != ',') in.putback(c);
  195.   in >> y; 
  197.   do in.get(c); while (c == ' ');
  198.   if (c != ')') in.putback(c);
  200.   p = point(x,y); 
  201.   return in; 
  203.  }