1 //---------------------------------------------------------------------------- 2 // Anti-Grain Geometry - Version 2.4 3 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com) 4 // 5 // Permission to copy, use, modify, sell and distribute this software 6 // is granted provided this copyright notice appears in all copies. 7 // This software is provided "as is" without express or implied 8 // warranty, and with no claim as to its suitability for any purpose. 9 // 10 //---------------------------------------------------------------------------- 11 // Contact: mcseem@antigrain.com 12 // mcseemagg@yahoo.com 13 // http://www.antigrain.com 14 //---------------------------------------------------------------------------- 15 // 16 // classes conv_curve 17 // 18 //---------------------------------------------------------------------------- 19 20 #ifndef AGG_CONV_CURVE_INCLUDED 21 #define AGG_CONV_CURVE_INCLUDED 22 23 #include "agg_basics.h" 24 #include "agg_curves.h" 25 26 #include <cmath> 27 28 29 namespace agg 30 { 31 32 33 //---------------------------------------------------------------conv_curve 34 // Curve converter class. Any path storage can have Bezier curves defined 35 // by their control points. There're two types of curves supported: curve3 36 // and curve4. Curve3 is a conic Bezier curve with 2 endpoints and 1 control 37 // point. Curve4 has 2 control points (4 points in total) and can be used 38 // to interpolate more complicated curves. Curve4, unlike curve3 can be used 39 // to approximate arcs, both circular and elliptical. Curves are approximated 40 // with straight lines and one of the approaches is just to store the whole 41 // sequence of vertices that approximate our curve. It takes additional 42 // memory, and at the same time the consecutive vertices can be calculated 43 // on demand. 44 // 45 // Initially, path storages are not suppose to keep all the vertices of the 46 // curves (although, nothing prevents us from doing so). Instead, path_storage 47 // keeps only vertices, needed to calculate a curve on demand. Those vertices 48 // are marked with special commands. So, if the path_storage contains curves 49 // (which are not real curves yet), and we render this storage directly, 50 // all we will see is only 2 or 3 straight line segments (for curve3 and 51 // curve4 respectively). If we need to see real curves drawn we need to 52 // include this class into the conversion pipeline. 53 // 54 // Class conv_curve recognizes commands path_cmd_curve3 and path_cmd_curve4 55 // and converts these vertices into a move_to/line_to sequence. 56 //----------------------------------------------------------------------- 57 template<class VertexSource, 58 class Curve3=curve3, 59 class Curve4=curve4> class conv_curve 60 { 61 public: 62 typedef Curve3 curve3_type; 63 typedef Curve4 curve4_type; 64 typedef conv_curve<VertexSource, Curve3, Curve4> self_type; 65 66 conv_curve(VertexSource& source) : 67 m_source(&source), m_last_x(0.0), m_last_y(0.0) {} 68 void attach(VertexSource& source) { m_source = &source; } 69 70 void approximation_method(curve_approximation_method_e v) 71 { 72 m_curve3.approximation_method(v); 73 m_curve4.approximation_method(v); 74 } 75 76 curve_approximation_method_e approximation_method() const 77 { 78 return m_curve4.approximation_method(); 79 } 80 81 void approximation_scale(double s) 82 { 83 m_curve3.approximation_scale(s); 84 m_curve4.approximation_scale(s); 85 } 86 87 double approximation_scale() const 88 { 89 return m_curve4.approximation_scale(); 90 } 91 92 void angle_tolerance(double v) 93 { 94 m_curve3.angle_tolerance(v); 95 m_curve4.angle_tolerance(v); 96 } 97 98 double angle_tolerance() const 99 { 100 return m_curve4.angle_tolerance(); 101 } 102 103 void cusp_limit(double v) 104 { 105 m_curve3.cusp_limit(v); 106 m_curve4.cusp_limit(v); 107 } 108 109 double cusp_limit() const 110 { 111 return m_curve4.cusp_limit(); 112 } 113 114 void rewind(unsigned path_id); 115 unsigned vertex(double* x, double* y); 116 117 private: 118 conv_curve(const self_type&); 119 const self_type& operator = (const self_type&); 120 121 VertexSource* m_source; 122 double m_last_x; 123 double m_last_y; 124 curve3_type m_curve3; 125 curve4_type m_curve4; 126 }; 127 128 129 130 //------------------------------------------------------------------------ 131 template<class VertexSource, class Curve3, class Curve4> 132 void conv_curve<VertexSource, Curve3, Curve4>::rewind(unsigned path_id) 133 { 134 m_source->rewind(path_id); 135 m_last_x = 0.0; 136 m_last_y = 0.0; 137 m_curve3.reset(); 138 m_curve4.reset(); 139 } 140 141 142 //------------------------------------------------------------------------ 143 template<class VertexSource, class Curve3, class Curve4> 144 unsigned conv_curve<VertexSource, Curve3, Curve4>::vertex(double* x, double* y) 145 { 146 if(!is_stop(m_curve3.vertex(x, y))) 147 { 148 m_last_x = *x; 149 m_last_y = *y; 150 return path_cmd_line_to; 151 } 152 153 if(!is_stop(m_curve4.vertex(x, y))) 154 { 155 m_last_x = *x; 156 m_last_y = *y; 157 return path_cmd_line_to; 158 } 159 160 double ct2_x = 0; 161 double ct2_y = 0; 162 double end_x = 0; 163 double end_y = 0; 164 165 unsigned cmd = m_source->vertex(x, y); 166 switch(cmd) 167 { 168 case path_cmd_curve3: 169 m_source->vertex(&end_x, &end_y); 170 171 if (!std::isnan(m_last_x) && !std::isnan(m_last_y) && !std::isnan(*x) 172 && !std::isnan(*y) && !std::isnan(end_x) && !std::isnan(end_y)) { 173 m_curve3.init(m_last_x, m_last_y, 174 *x, *y, 175 end_x, end_y); 176 177 m_curve3.vertex(x, y); // First call returns path_cmd_move_to 178 m_curve3.vertex(x, y); // This is the first vertex of the curve 179 } 180 cmd = path_cmd_line_to; 181 break; 182 183 case path_cmd_curve4: 184 m_source->vertex(&ct2_x, &ct2_y); 185 m_source->vertex(&end_x, &end_y); 186 187 if (!std::isnan(m_last_x) && !std::isnan(m_last_y) && !std::isnan(*x) 188 && !std::isnan(*y) && !std::isnan(end_x) && !std::isnan(end_y)) { 189 m_curve4.init(m_last_x, m_last_y, 190 *x, *y, 191 ct2_x, ct2_y, 192 end_x, end_y); 193 194 m_curve4.vertex(x, y); // First call returns path_cmd_move_to 195 m_curve4.vertex(x, y); // This is the first vertex of the curve 196 } 197 cmd = path_cmd_line_to; 198 break; 199 } 200 m_last_x = *x; 201 m_last_y = *y; 202 return cmd; 203 } 204 205 206 } 207 208 209 210 #endif 211