home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / src / plane / _segment.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  4.6 KB  |  207 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  _segment.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. #include <ctype.h>
  20.  
  21. static const double eps = 1e-10;
  22.  
  23.  
  24. //------------------------------------------------------------------------------
  25. // segments 
  26. //------------------------------------------------------------------------------
  27.  
  28. segment_rep::segment_rep()  { count = 1; }
  29.  
  30. segment_rep::segment_rep(point p, point q) 
  31. { start = p;
  32.   end   = q;
  33.   count = 1; 
  34. }
  35.  
  36. segment::segment()                 { ptr = new segment_rep; }
  37. segment::segment(int)              { ptr = new segment_rep; }
  38. segment::segment(ent x)            { ptr = (segment_rep*)x; ptr->count++; }
  39. segment::segment(point x, point y) { ptr = new segment_rep(x,y); }
  40. segment::segment(double x1, double y1, double x2, double y2) 
  41.                           { ptr = new segment_rep(point(x1,y1), point(x2,y2)); }
  42.  
  43. segment::segment(point p, double alpha, double length)
  44. { point q = p.translate(alpha,length);
  45.   ptr  = new segment_rep(p,q); 
  46.  }
  47.   
  48. segment::segment(segment& s)       { ptr = s.ptr; ptr->count++; }
  49. void segment::clear()              { if (--(ptr->count)==0) delete ptr; }
  50.  
  51.  
  52. segment segment::translate(double alpha, double d)
  53. { point p = ptr->start.translate(alpha,d);
  54.   point q = ptr->end.translate(alpha,d);
  55.   return segment(p,q);
  56.  }
  57.  
  58. segment segment::translate(const vector& v)
  59. { point p = ptr->start.translate(v);
  60.   point q = ptr->end.translate(v);
  61.   return segment(p,q);
  62.  }
  63.  
  64.  
  65. segment& segment::operator=(const segment& s)
  66. { s.ptr->count++;
  67.   if (--ptr->count == 0)  delete ptr;
  68.   ptr = s.ptr;
  69.   return *this;
  70. }
  71.  
  72.  
  73. ostream& operator<<(ostream& out, const segment& s) 
  74. { out << "[" << s.start() << "===" << s.end() << "]"; 
  75.   return out;
  76.  } 
  77.  
  78. /*
  79. istream& operator>>(istream& in, segment& s) 
  80. { double x1,x2,y1,y2; 
  81.   in >> x1 >> y1 >> x2 >> y2; 
  82.   s = segment(x1,y1,x2,y2); 
  83.   return in; 
  84.  } 
  85. */
  86.  
  87. istream& operator>>(istream& in, segment& s) 
  88. { // syntax: {[} p {===} q {]}
  89.  
  90.   point p,q; 
  91.   char c;
  92.  
  93.   do in.get(c); while (isspace(c));
  94.   if (c != '[') in.putback(c);
  95.  
  96.   in >> p;
  97.  
  98.   do in.get(c); while (isspace(c));
  99.   while (c== '=') in.get(c);
  100.   while (isspace(c)) in.get(c);
  101.   in.putback(c);
  102.  
  103.   in >> q; 
  104.  
  105.   do in.get(c); while (c == ' ');
  106.   if (c != ']') in.putback(c);
  107.  
  108.   s = segment(p,q); 
  109.   return in; 
  110.  
  111.  } 
  112.  
  113.  
  114.  
  115. bool  segment::vertical()            
  116. { return ptr->start.ptr->x == ptr->end.ptr->x; }
  117.  
  118. bool  segment::horizontal()            
  119. { return ptr->start.ptr->y == ptr->end.ptr->y; }
  120.  
  121. double  segment::length()            
  122. { return ptr->start.distance(ptr->end); }
  123.  
  124. double segment::angle()
  125. {  return -angle(segment(0,0,1,0)); }
  126.  
  127.  
  128. double segment::angle(segment s)
  129. {
  130.   double cosfi,fi,norm;
  131.   
  132.   double dx  = ptr->end.ptr->x - ptr->start.ptr->x; 
  133.   double dy  = ptr->end.ptr->y - ptr->start.ptr->y; 
  134.  
  135.   double dxs = s.ptr->end.ptr->x - s.ptr->start.ptr->x; 
  136.   double dys = s.ptr->end.ptr->y - s.ptr->start.ptr->y; 
  137.   
  138.   cosfi=dx*dxs+dy*dys;
  139.   
  140.   norm=(dx*dx+dy*dy)*(dxs*dxs+dys*dys);
  141.  
  142.   cosfi /= sqrt( norm );
  143.  
  144.   if (cosfi >=  1.0 ) return 0;
  145.   if (cosfi <= -1.0 ) return M_PI;
  146.   
  147.   fi=acos(cosfi);
  148.  
  149.   if (dx*dys-dy*dxs>0) return fi;
  150.  
  151.   return -fi;
  152. }
  153.   
  154. double segment::distance(segment s)
  155. { if (angle(s)!=0) return 0;
  156.   return distance(s.ptr->start);
  157.  }
  158.  
  159. double  segment::distance()          
  160. { return distance(point(0,0)); }
  161.  
  162. double segment::distance(point p)
  163. { segment s(ptr->start,p);
  164.   double l = s.length();
  165.   if (l==0) return 0;
  166.   else return l*sin(angle(s));
  167.  }
  168.  
  169. double  segment::slope()  
  170. { double dx = (ptr->end.ptr->x - ptr->start.ptr->x); 
  171.   if (dx==0) 
  172.   { cout << *this << "\n";
  173.     cout.flush();
  174.     error_handler(1,"segment::slope() : vertical segment");
  175.    }
  176.   return   (ptr->end.ptr->y - ptr->start.ptr->y)/dx; 
  177. }
  178.  
  179. double  segment::y_abs() 
  180. { return  ptr->start.ptr->y - (ptr->start.ptr->x * slope()); }
  181.  
  182. bool segment::intersection(segment s, point& inter)
  183. { line l(s);
  184.   if (l.intersection(*this,inter))
  185.   { double d1  = inter.distance(s.ptr->start);
  186.     double d2  = inter.distance(s.ptr->end);
  187.     double l   = s.length()+eps;
  188.     if ( d1 < l && d2 < l) return true;
  189.    }
  190.    return false;
  191. }
  192.  
  193. segment segment::rotate(double alpha)
  194. {  double  l = length();
  195.    point p = start();
  196.    double beta = alpha + angle();
  197.    return segment(p,beta,l);
  198. }
  199.  
  200. segment segment::rotate(point origin, double alpha)
  201. {  point p = start().rotate(origin,alpha);
  202.    point q = end().rotate(origin,alpha);
  203.    return segment(p,q);
  204. }
  205.  
  206.  
  207.