Anti-Grain Geometry Tutorial
agg_curves.h
1 //----------------------------------------------------------------------------
2 // Anti-Grain Geometry - Version 2.4
3 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
4 // Copyright (C) 2005 Tony Juricic (tonygeek@yahoo.com)
5 //
6 // Permission to copy, use, modify, sell and distribute this software
7 // is granted provided this copyright notice appears in all copies.
8 // This software is provided "as is" without express or implied
9 // warranty, and with no claim as to its suitability for any purpose.
10 //
11 //----------------------------------------------------------------------------
12 // Contact: mcseem@antigrain.com
13 // mcseemagg@yahoo.com
14 // http://www.antigrain.com
15 //----------------------------------------------------------------------------
16 
17 #ifndef AGG_CURVES_INCLUDED
18 #define AGG_CURVES_INCLUDED
19 
20 #include "agg_array.h"
21 
22 namespace agg
23 {
24 
25  // See Implementation agg_curves.cpp
26 
27  //--------------------------------------------curve_approximation_method_e
28  enum curve_approximation_method_e
29  {
30  curve_inc,
31  curve_div
32  };
33 
34  //--------------------------------------------------------------curve3_inc
35  class curve3_inc
36  {
37  public:
38  curve3_inc() :
39  m_num_steps(0), m_step(0), m_scale(1.0) { }
40 
41  curve3_inc(double x1, double y1,
42  double x2, double y2,
43  double x3, double y3) :
44  m_num_steps(0), m_step(0), m_scale(1.0)
45  {
46  init(x1, y1, x2, y2, x3, y3);
47  }
48 
49  void reset() { m_num_steps = 0; m_step = -1; }
50  void init(double x1, double y1,
51  double x2, double y2,
52  double x3, double y3);
53 
54  void approximation_method(curve_approximation_method_e) {}
55  curve_approximation_method_e approximation_method() const { return curve_inc; }
56 
57  void approximation_scale(double s);
58  double approximation_scale() const;
59 
60  void angle_tolerance(double) {}
61  double angle_tolerance() const { return 0.0; }
62 
63  void cusp_limit(double) {}
64  double cusp_limit() const { return 0.0; }
65 
66  void rewind(unsigned path_id);
67  unsigned vertex(double* x, double* y);
68 
69  private:
70  int m_num_steps;
71  int m_step;
72  double m_scale;
73  double m_start_x;
74  double m_start_y;
75  double m_end_x;
76  double m_end_y;
77  double m_fx;
78  double m_fy;
79  double m_dfx;
80  double m_dfy;
81  double m_ddfx;
82  double m_ddfy;
83  double m_saved_fx;
84  double m_saved_fy;
85  double m_saved_dfx;
86  double m_saved_dfy;
87  };
88 
89 
90 
91 
92 
93  //-------------------------------------------------------------curve3_div
94  class curve3_div
95  {
96  public:
97  curve3_div() :
98  m_approximation_scale(1.0),
99  m_angle_tolerance(0.0),
100  m_count(0)
101  {}
102 
103  curve3_div(double x1, double y1,
104  double x2, double y2,
105  double x3, double y3) :
106  m_approximation_scale(1.0),
107  m_angle_tolerance(0.0),
108  m_count(0)
109  {
110  init(x1, y1, x2, y2, x3, y3);
111  }
112 
113  void reset() { m_points.remove_all(); m_count = 0; }
114  void init(double x1, double y1,
115  double x2, double y2,
116  double x3, double y3);
117 
118  void approximation_method(curve_approximation_method_e) {}
119  curve_approximation_method_e approximation_method() const { return curve_div; }
120 
121  void approximation_scale(double s) { m_approximation_scale = s; }
122  double approximation_scale() const { return m_approximation_scale; }
123 
124  void angle_tolerance(double a) { m_angle_tolerance = a; }
125  double angle_tolerance() const { return m_angle_tolerance; }
126 
127  void cusp_limit(double) {}
128  double cusp_limit() const { return 0.0; }
129 
130  void rewind(unsigned)
131  {
132  m_count = 0;
133  }
134 
135  unsigned vertex(double* x, double* y)
136  {
137  if(m_count >= m_points.size()) return path_cmd_stop;
138  const point_d& p = m_points[m_count++];
139  *x = p.x;
140  *y = p.y;
141  return (m_count == 1) ? path_cmd_move_to : path_cmd_line_to;
142  }
143 
144  private:
145  void bezier(double x1, double y1,
146  double x2, double y2,
147  double x3, double y3);
148  void recursive_bezier(double x1, double y1,
149  double x2, double y2,
150  double x3, double y3,
151  unsigned level);
152 
153  double m_approximation_scale;
154  double m_distance_tolerance_square;
155  double m_angle_tolerance;
156  unsigned m_count;
157  pod_bvector<point_d> m_points;
158  };
159 
160 
161 
162 
163 
164 
165 
166  //-------------------------------------------------------------curve4_points
167  struct curve4_points
168  {
169  double cp[8];
170  curve4_points() {}
171  curve4_points(double x1, double y1,
172  double x2, double y2,
173  double x3, double y3,
174  double x4, double y4)
175  {
176  cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
177  cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
178  }
179  void init(double x1, double y1,
180  double x2, double y2,
181  double x3, double y3,
182  double x4, double y4)
183  {
184  cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
185  cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
186  }
187  double operator [] (unsigned i) const { return cp[i]; }
188  double& operator [] (unsigned i) { return cp[i]; }
189  };
190 
191 
192 
193  //-------------------------------------------------------------curve4_inc
194  class curve4_inc
195  {
196  public:
197  curve4_inc() :
198  m_num_steps(0), m_step(0), m_scale(1.0) { }
199 
200  curve4_inc(double x1, double y1,
201  double x2, double y2,
202  double x3, double y3,
203  double x4, double y4) :
204  m_num_steps(0), m_step(0), m_scale(1.0)
205  {
206  init(x1, y1, x2, y2, x3, y3, x4, y4);
207  }
208 
209  curve4_inc(const curve4_points& cp) :
210  m_num_steps(0), m_step(0), m_scale(1.0)
211  {
212  init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
213  }
214 
215  void reset() { m_num_steps = 0; m_step = -1; }
216  void init(double x1, double y1,
217  double x2, double y2,
218  double x3, double y3,
219  double x4, double y4);
220 
221  void init(const curve4_points& cp)
222  {
223  init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
224  }
225 
226  void approximation_method(curve_approximation_method_e) {}
227  curve_approximation_method_e approximation_method() const { return curve_inc; }
228 
229  void approximation_scale(double s);
230  double approximation_scale() const;
231 
232  void angle_tolerance(double) {}
233  double angle_tolerance() const { return 0.0; }
234 
235  void cusp_limit(double) {}
236  double cusp_limit() const { return 0.0; }
237 
238  void rewind(unsigned path_id);
239  unsigned vertex(double* x, double* y);
240 
241  private:
242  int m_num_steps;
243  int m_step;
244  double m_scale;
245  double m_start_x;
246  double m_start_y;
247  double m_end_x;
248  double m_end_y;
249  double m_fx;
250  double m_fy;
251  double m_dfx;
252  double m_dfy;
253  double m_ddfx;
254  double m_ddfy;
255  double m_dddfx;
256  double m_dddfy;
257  double m_saved_fx;
258  double m_saved_fy;
259  double m_saved_dfx;
260  double m_saved_dfy;
261  double m_saved_ddfx;
262  double m_saved_ddfy;
263  };
264 
265 
266 
267  //-------------------------------------------------------catrom_to_bezier
268  inline curve4_points catrom_to_bezier(double x1, double y1,
269  double x2, double y2,
270  double x3, double y3,
271  double x4, double y4)
272  {
273  // Trans. matrix Catmull-Rom to Bezier
274  //
275  // 0 1 0 0
276  // -1/6 1 1/6 0
277  // 0 1/6 1 -1/6
278  // 0 0 1 0
279  //
280  return curve4_points(
281  x2,
282  y2,
283  (-x1 + 6*x2 + x3) / 6,
284  (-y1 + 6*y2 + y3) / 6,
285  ( x2 + 6*x3 - x4) / 6,
286  ( y2 + 6*y3 - y4) / 6,
287  x3,
288  y3);
289  }
290 
291 
292  //-----------------------------------------------------------------------
293  inline curve4_points
294  catrom_to_bezier(const curve4_points& cp)
295  {
296  return catrom_to_bezier(cp[0], cp[1], cp[2], cp[3],
297  cp[4], cp[5], cp[6], cp[7]);
298  }
299 
300 
301 
302  //-----------------------------------------------------ubspline_to_bezier
303  inline curve4_points ubspline_to_bezier(double x1, double y1,
304  double x2, double y2,
305  double x3, double y3,
306  double x4, double y4)
307  {
308  // Trans. matrix Uniform BSpline to Bezier
309  //
310  // 1/6 4/6 1/6 0
311  // 0 4/6 2/6 0
312  // 0 2/6 4/6 0
313  // 0 1/6 4/6 1/6
314  //
315  return curve4_points(
316  (x1 + 4*x2 + x3) / 6,
317  (y1 + 4*y2 + y3) / 6,
318  (4*x2 + 2*x3) / 6,
319  (4*y2 + 2*y3) / 6,
320  (2*x2 + 4*x3) / 6,
321  (2*y2 + 4*y3) / 6,
322  (x2 + 4*x3 + x4) / 6,
323  (y2 + 4*y3 + y4) / 6);
324  }
325 
326 
327  //-----------------------------------------------------------------------
328  inline curve4_points
329  ubspline_to_bezier(const curve4_points& cp)
330  {
331  return ubspline_to_bezier(cp[0], cp[1], cp[2], cp[3],
332  cp[4], cp[5], cp[6], cp[7]);
333  }
334 
335 
336 
337 
338  //------------------------------------------------------hermite_to_bezier
339  inline curve4_points hermite_to_bezier(double x1, double y1,
340  double x2, double y2,
341  double x3, double y3,
342  double x4, double y4)
343  {
344  // Trans. matrix Hermite to Bezier
345  //
346  // 1 0 0 0
347  // 1 0 1/3 0
348  // 0 1 0 -1/3
349  // 0 1 0 0
350  //
351  return curve4_points(
352  x1,
353  y1,
354  (3*x1 + x3) / 3,
355  (3*y1 + y3) / 3,
356  (3*x2 - x4) / 3,
357  (3*y2 - y4) / 3,
358  x2,
359  y2);
360  }
361 
362 
363 
364  //-----------------------------------------------------------------------
365  inline curve4_points
366  hermite_to_bezier(const curve4_points& cp)
367  {
368  return hermite_to_bezier(cp[0], cp[1], cp[2], cp[3],
369  cp[4], cp[5], cp[6], cp[7]);
370  }
371 
372 
373  //-------------------------------------------------------------curve4_div
374  class curve4_div
375  {
376  public:
377  curve4_div() :
378  m_approximation_scale(1.0),
379  m_angle_tolerance(0.0),
380  m_cusp_limit(0.0),
381  m_count(0)
382  {}
383 
384  curve4_div(double x1, double y1,
385  double x2, double y2,
386  double x3, double y3,
387  double x4, double y4) :
388  m_approximation_scale(1.0),
389  m_angle_tolerance(0.0),
390  m_cusp_limit(0.0),
391  m_count(0)
392  {
393  init(x1, y1, x2, y2, x3, y3, x4, y4);
394  }
395 
396  curve4_div(const curve4_points& cp) :
397  m_approximation_scale(1.0),
398  m_angle_tolerance(0.0),
399  m_count(0)
400  {
401  init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
402  }
403 
404  void reset() { m_points.remove_all(); m_count = 0; }
405  void init(double x1, double y1,
406  double x2, double y2,
407  double x3, double y3,
408  double x4, double y4);
409 
410  void init(const curve4_points& cp)
411  {
412  init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
413  }
414 
415  void approximation_method(curve_approximation_method_e) {}
416 
417  curve_approximation_method_e approximation_method() const
418  {
419  return curve_div;
420  }
421 
422  void approximation_scale(double s) { m_approximation_scale = s; }
423  double approximation_scale() const { return m_approximation_scale; }
424 
425  void angle_tolerance(double a) { m_angle_tolerance = a; }
426  double angle_tolerance() const { return m_angle_tolerance; }
427 
428  void cusp_limit(double v)
429  {
430  m_cusp_limit = (v == 0.0) ? 0.0 : pi - v;
431  }
432 
433  double cusp_limit() const
434  {
435  return (m_cusp_limit == 0.0) ? 0.0 : pi - m_cusp_limit;
436  }
437 
438  void rewind(unsigned)
439  {
440  m_count = 0;
441  }
442 
443  unsigned vertex(double* x, double* y)
444  {
445  if(m_count >= m_points.size()) return path_cmd_stop;
446  const point_d& p = m_points[m_count++];
447  *x = p.x;
448  *y = p.y;
449  return (m_count == 1) ? path_cmd_move_to : path_cmd_line_to;
450  }
451 
452  private:
453  void bezier(double x1, double y1,
454  double x2, double y2,
455  double x3, double y3,
456  double x4, double y4);
457 
458  void recursive_bezier(double x1, double y1,
459  double x2, double y2,
460  double x3, double y3,
461  double x4, double y4,
462  unsigned level);
463 
464  double m_approximation_scale;
465  double m_distance_tolerance_square;
466  double m_angle_tolerance;
467  double m_cusp_limit;
468  unsigned m_count;
469  pod_bvector<point_d> m_points;
470  };
471 
472 
473  //-----------------------------------------------------------------curve3
474  class curve3
475  {
476  public:
477  curve3() : m_approximation_method(curve_div) {}
478  curve3(double x1, double y1,
479  double x2, double y2,
480  double x3, double y3) :
481  m_approximation_method(curve_div)
482  {
483  init(x1, y1, x2, y2, x3, y3);
484  }
485 
486  void reset()
487  {
488  m_curve_inc.reset();
489  m_curve_div.reset();
490  }
491 
492  void init(double x1, double y1,
493  double x2, double y2,
494  double x3, double y3)
495  {
496  if(m_approximation_method == curve_inc)
497  {
498  m_curve_inc.init(x1, y1, x2, y2, x3, y3);
499  }
500  else
501  {
502  m_curve_div.init(x1, y1, x2, y2, x3, y3);
503  }
504  }
505 
506  void approximation_method(curve_approximation_method_e v)
507  {
508  m_approximation_method = v;
509  }
510 
511  curve_approximation_method_e approximation_method() const
512  {
513  return m_approximation_method;
514  }
515 
516  void approximation_scale(double s)
517  {
518  m_curve_inc.approximation_scale(s);
519  m_curve_div.approximation_scale(s);
520  }
521 
522  double approximation_scale() const
523  {
524  return m_curve_inc.approximation_scale();
525  }
526 
527  void angle_tolerance(double a)
528  {
529  m_curve_div.angle_tolerance(a);
530  }
531 
532  double angle_tolerance() const
533  {
534  return m_curve_div.angle_tolerance();
535  }
536 
537  void cusp_limit(double v)
538  {
539  m_curve_div.cusp_limit(v);
540  }
541 
542  double cusp_limit() const
543  {
544  return m_curve_div.cusp_limit();
545  }
546 
547  void rewind(unsigned path_id)
548  {
549  if(m_approximation_method == curve_inc)
550  {
551  m_curve_inc.rewind(path_id);
552  }
553  else
554  {
555  m_curve_div.rewind(path_id);
556  }
557  }
558 
559  unsigned vertex(double* x, double* y)
560  {
561  if(m_approximation_method == curve_inc)
562  {
563  return m_curve_inc.vertex(x, y);
564  }
565  return m_curve_div.vertex(x, y);
566  }
567 
568  private:
569  curve3_inc m_curve_inc;
570  curve3_div m_curve_div;
571  curve_approximation_method_e m_approximation_method;
572  };
573 
574 
575 
576 
577 
578  //-----------------------------------------------------------------curve4
579  class curve4
580  {
581  public:
582  curve4() : m_approximation_method(curve_div) {}
583  curve4(double x1, double y1,
584  double x2, double y2,
585  double x3, double y3,
586  double x4, double y4) :
587  m_approximation_method(curve_div)
588  {
589  init(x1, y1, x2, y2, x3, y3, x4, y4);
590  }
591 
592  curve4(const curve4_points& cp) :
593  m_approximation_method(curve_div)
594  {
595  init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
596  }
597 
598  void reset()
599  {
600  m_curve_inc.reset();
601  m_curve_div.reset();
602  }
603 
604  void init(double x1, double y1,
605  double x2, double y2,
606  double x3, double y3,
607  double x4, double y4)
608  {
609  if(m_approximation_method == curve_inc)
610  {
611  m_curve_inc.init(x1, y1, x2, y2, x3, y3, x4, y4);
612  }
613  else
614  {
615  m_curve_div.init(x1, y1, x2, y2, x3, y3, x4, y4);
616  }
617  }
618 
619  void init(const curve4_points& cp)
620  {
621  init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
622  }
623 
624  void approximation_method(curve_approximation_method_e v)
625  {
626  m_approximation_method = v;
627  }
628 
629  curve_approximation_method_e approximation_method() const
630  {
631  return m_approximation_method;
632  }
633 
634  void approximation_scale(double s)
635  {
636  m_curve_inc.approximation_scale(s);
637  m_curve_div.approximation_scale(s);
638  }
639  double approximation_scale() const { return m_curve_inc.approximation_scale(); }
640 
641  void angle_tolerance(double v)
642  {
643  m_curve_div.angle_tolerance(v);
644  }
645 
646  double angle_tolerance() const
647  {
648  return m_curve_div.angle_tolerance();
649  }
650 
651  void cusp_limit(double v)
652  {
653  m_curve_div.cusp_limit(v);
654  }
655 
656  double cusp_limit() const
657  {
658  return m_curve_div.cusp_limit();
659  }
660 
661  void rewind(unsigned path_id)
662  {
663  if(m_approximation_method == curve_inc)
664  {
665  m_curve_inc.rewind(path_id);
666  }
667  else
668  {
669  m_curve_div.rewind(path_id);
670  }
671  }
672 
673  unsigned vertex(double* x, double* y)
674  {
675  if(m_approximation_method == curve_inc)
676  {
677  return m_curve_inc.vertex(x, y);
678  }
679  return m_curve_div.vertex(x, y);
680  }
681 
682  private:
683  curve4_inc m_curve_inc;
684  curve4_div m_curve_div;
685  curve_approximation_method_e m_approximation_method;
686  };
687 
688 
689 
690 
691 }
692 
693 #endif
agg::curve3_inc
Definition: agg_curves.h:35
agg::curve4_inc
Definition: agg_curves.h:194
agg::curve4_div
Definition: agg_curves.h:374
agg::curve3_div
Definition: agg_curves.h:94
agg::pod_bvector
Definition: agg_array.h:326
agg::curve4_points
Definition: agg_curves.h:167
agg
Definition: agg_arc.cpp:24
agg::point_base
Definition: agg_basics.h:508