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

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

数值算法/人工智能

开发平台：

MultiPlatform

rat_point.h：源码内容
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  rat_point.h
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  14. #ifndef LEDA_RAT_POINT_H
  15. #define LEDA_RAT_POINT_H
  17. #include <math.h>
  18. #include <LEDA/integer.h>
  20. class rat_point;
  21. class rat_segment;
  24. //------------------------------------------------------------------------------
  25. // rat_points
  26. //------------------------------------------------------------------------------
  28. class rat_point_rep  : public handle_rep {
  30. friend class rat_point;
  31. friend class rat_segment;
  32.    
  33.    integer x;
  34.    integer y;
  35.    integer w;
  37.    double  xd;
  38.    double  yd;
  39.    double  wd;
  41. public:
  43.    rat_point_rep() : x(0), y(0), w(1)
  44.    { xd = 0;
  45.      yd = 0;
  46.      wd = 1;
  47.     }
  49.    rat_point_rep(integer a, integer b) : x(a), y(b), w(1)
  50.    { xd = a.todouble(); 
  51.      yd = b.todouble(); 
  52.      wd = 1;
  53.     }
  55.    rat_point_rep(integer a, integer b, integer c) : x(a), y(b), w(c)
  56.    { xd = a.todouble(); 
  57.      yd = b.todouble(); 
  58.      wd = c.todouble();
  59.     }
  61.   ~rat_point_rep() {}
  63. friend int orientation(const rat_point&, const rat_point&, const rat_point&);
  64.    
  65. };
  69. /*{Manpage {rat_point} {} {Rational Points} }*/
  71. class rat_point  : public handle_base {
  73. /*{Mdefinition
  74. An instance of the data type $rat_point$ is a point with rational coordinates 
  75. in the two-dimensional plane. A point $(a,b)$ is represented by homogeneous
  76. coordinates $(x,y,w)$ of arbitrary length integers (see ref{Integers of 
  77. Arbitrary Length}) such that $a = x/w$ and $b = y/w$. }*/
  80.  friend class rat_segment;
  82.  rat_point_rep* ptr() const { return (rat_point_rep*)PTR; } 
  84. public:
  86. static int orient_count;
  87. static int exact_orient_count;
  89. static int cmp_count;
  90. static int exact_cmp_count;
  92. static int use_filter;
  94. /*{Mcreation p}*/
  96. rat_point() { PTR = new rat_point_rep; }
  97. /*{Mcreate introduces a variable var of type name
  98. initialized to the point $(0,0)$.}*/
  100.  rat_point(integer a, integer b)       { PTR = new rat_point_rep(a,b); }
  101. /*{Mcreate introduces a variable var of type name
  102. initialized to the point $(a,b)$.}*/
  104.  rat_point(integer x, integer y, integer w){ PTR = new rat_point_rep(x,y,w); }
  105. /*{Mcreate introduces a variable var of type name
  106. initialized to the point with homogeneous coordinates$(x,y,w)$.}*/
  108.  rat_point(const rat_point& p) : handle_base(p) {}
  109. ~rat_point() {}
  111.  rat_point& operator=(const rat_point& p) 
  112.  { handle_base::operator=(p); return *this; }
  114. /*{Moperations 2 3.5 }*/
  116. double xcoord() const { return ptr()->xd/ptr()->wd;}
  117. /*{Mop     returns a double precision floating point approximation of the 
  118.             $x$-coordinate of var.}*/
  120. double ycoord() const { return ptr()->yd/ptr()->wd;}
  121. /*{Mop     returns a double precision floating point approximation of the 
  122.             $y$-coordinate of var.}*/
  124. integer X() const { return ptr()->x; }
  125. /*{Mop     returns the first homogeneous coordinate of var.}*/
  127. integer Y() const { return ptr()->y; }
  128. /*{Mop     returns the second homogeneous coordinate of var.}*/
  130. integer W() const { return ptr()->w; }
  131. /*{Mop     returns the third homogeneous coordinate of var.}*/
  133. double XD() const { return ptr()->xd; }
  134. /*{Mop     returns a floating point approximation of the first homogeneous 
  135.             coordinate of var.}*/
  137. double YD() const { return ptr()->yd; }
  138. /*{Mop     returns a floating point approximation of the second homogeneous 
  139.             coordinate of var.}*/
  141. double WD() const { return ptr()->wd; }
  142. /*{Mop     returns a floating point approximation of the third homogeneous 
  143.             coordinate of var.}*/
  146. rat_point rotate90(const rat_point& q) const;
  147. /*{Mopl    returns var rotated by 90 degrees about $q$. }  */
  149. rat_point rotate90() const;
  150. /*{Mop     returns var rotated by 90 degrees about the origin. }  */
  152. rat_point translate(const rat_point& p, int i) const;
  153. /*{Mopl    returns var translated by ... }  */
  156. friend bool identical(const rat_point& p, const rat_point& q)
  157. { return p.ptr() == q.ptr(); }
  158. /*{Mfuncl  Test for identity.}*/
  160. friend bool operator==(const rat_point& p, const rat_point& q)
  161. { return (identical(p,q)) || rat_point::cmp(p,q) == 0; }
  162. /*{Mbinopfunc  Test for equality.}*/
  164. friend bool operator!=(const rat_point& p, const rat_point& q)
  165. { return (!identical(p,q)) && rat_point::cmp(p,q) != 0; }
  166. /*{Mbinopfunc  Test for inequality.}*/
  168. friend ostream& operator<<(ostream& O, const rat_point& p) ;
  169. /*{Mbinopfunc  writes the homogeneous coordinates $(x,y,w)$ of var to 
  170.                 output stream $O$.}*/
  172. friend istream& operator>>(istream& I, rat_point& p) ;
  173. /*{Mbinopfunc  reads the homogeneous coordinates $(x,y,w)$ of var from 
  174.                 input stream $I$.}*/
  177. friend int orientation(const rat_point& a, const rat_point& b, const rat_point& c);
  178. /*{Mfuncl  computes the orientation of points $a$, $b$, $c$, i.e.,
  179.            the sign of the determinant\
  180.            [ leftLvert begin{array}{ccc} a_x & a_y & a_w\
  181.                                         b_x & b_y & b_w\
  182.                                         c_x & c_y & c_w
  183.                        end{array} rightLvert ] 
  184.            }*/
  187. static int cmp(const rat_point&, const rat_point&);
  189. };
  192. extern 
  193. double area(const rat_point& a, const rat_point& b, const rat_point& c);
  194. /*{Mfuncl computes the signed area of the triangle determined by $a$,$b$,$c$,
  195.            positive if $orientation(a,b,c) > 0$ and negative otherwise. }*/
  198. extern
  199. int incircle(const rat_point& a, const rat_point& b, const rat_point& c,
  200.                                                      const rat_point& d);
  201. /*{Mfuncl returns $+1$ if point $d$ lies in the interior of the circle
  202.            through points $a$, $b$, and $c$, $0$ if $a$,$b$,$c$,and $d$ are
  203.            cocircular, and $-1$ otherwise. }*/
  206. inline int compare(const rat_point& a, const rat_point& b)
  207. {  return (identical(a,b))  ? 0 : rat_point::cmp(a,b); }
  210. inline void Print(const rat_point& p, ostream& out) { out << p; } 
  211. inline void Read(rat_point& p,  istream& in)        { in >> p; }
  214. inline bool collinear(const rat_point& a,const rat_point& b,const rat_point& c)
  215. { return orientation(a,b,c) == 0; }
  216. /*{Mfuncl  returns true if points $a$, $b$, $c$ are collinear, i.e.,
  217.            $orientation(a,b,c) = 0$, and false otherwise. }*/
  220. inline bool right_turn(const rat_point& a,const rat_point& b,const rat_point& c)
  221. { return orientation(a,b,c) < 0; }
  222. /*{Mfuncl  returns true if points $a$, $b$, $c$ form a righ turn, i.e.,
  223.            $orientation(a,b,c) > 0$, and false otherwise. }*/
  226. inline bool left_turn(const rat_point& a,const rat_point& b,const rat_point& c)
  227. { return orientation(a,b,c) > 0; }
  228. /*{Mfuncl  returns true if points $a$, $b$, $c$ form a left turn, i.e.,
  229.            $orientation(a,b,c) < 0$, and false otherwise. }*/
  233. #endif
  235.