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