I forgot to remove these prototypes when removing definitions earlier.
[synfig.git] / synfig-core / trunk / src / synfig / vector.h
1 /* === S Y N F I G ========================================================= */
2 /*!     \file vector.h
3 **      \brief Various discreet type definitions
4 **
5 **      $Id$
6 **
7 **      \legal
8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
9 **
10 **      This package is free software; you can redistribute it and/or
11 **      modify it under the terms of the GNU General Public License as
12 **      published by the Free Software Foundation; either version 2 of
13 **      the License, or (at your option) any later version.
14 **
15 **      This package is distributed in the hope that it will be useful,
16 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
17 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 **      General Public License for more details.
19 **      \endlegal
20 */
21 /* ========================================================================= */
22
23 /* === S T A R T =========================================================== */
24
25 #ifndef __SYNFIG_VECTOR_H
26 #define __SYNFIG_VECTOR_H
27
28 /* === H E A D E R S ======================================================= */
29
30 #include "real.h"
31 #include <math.h>
32
33 /* === M A C R O S ========================================================= */
34
35
36 #ifdef WIN32
37 #include <float.h>
38 #ifndef isnan
39 extern "C" { int _isnan(double x); }
40 #define isnan _isnan
41 #endif
42 #endif
43
44 // For some reason isnan() isn't working on macosx any more.
45 // This is a quick fix.
46 #if defined(__APPLE__) && !defined(SYNFIG_ISNAN_FIX)
47 #ifdef isnan
48 #undef isnan
49 #endif
50 inline bool isnan(double x) { return x != x; }
51 inline bool isnan(float x) { return x != x; }
52 #define SYNFIG_ISNAN_FIX 1
53 #endif
54
55
56 /* === T Y P E D E F S ===================================================== */
57
58 /* === C L A S S E S & S T R U C T S ======================================= */
59
60 namespace synfig {
61
62 /*!     \class Vector
63 **      \todo writeme
64 */
65 class Vector
66 {
67 public:
68         typedef Real value_type;
69
70 private:
71         value_type _x, _y;
72
73 public:
74         Vector() { };
75         Vector(const value_type &x, const value_type &y):_x(x),_y(y) { };
76
77         bool is_valid()const { return !(isnan(_x) || isnan(_y)); }
78
79         value_type &
80         operator[](const int& i)
81         { return (&_x)[i] ; }
82
83         const value_type &
84         operator[](const int& i) const
85         { return (&_x)[i] ; }
86
87         const Vector &
88         operator+=(const Vector &rhs)
89         {
90                 _x+=rhs._x;
91                 _y+=rhs._y;
92                 return *this;
93         }
94
95         const Vector &
96         operator-=(const Vector &rhs)
97         {
98                 _x-=rhs._x;
99                 _y-=rhs._y;
100                 return *this;
101         }
102
103         const Vector &
104         operator*=(const value_type &rhs)
105         {
106                 _x*=rhs;
107                 _y*=rhs;
108                 return *this;
109         }
110
111         const Vector &
112         operator/=(const value_type &rhs)
113         {
114                 value_type tmp=1.0/rhs;
115                 _x*=tmp;
116                 _y*=tmp;
117                 return *this;
118         }
119
120         Vector
121         operator+(const Vector &rhs)const
122                 { return Vector(*this)+=rhs; }
123
124         Vector
125         operator-(const Vector &rhs)const
126                 { return Vector(*this)-=rhs; }
127
128         Vector
129         operator*(const value_type &rhs)const
130                 { return Vector(*this)*=rhs; }
131
132         Vector
133         operator/(const value_type &rhs)const
134                 { return Vector(*this)/=rhs; }
135
136         Vector
137         operator-()const
138                 { return Vector(-_x,-_y); }
139
140         value_type
141         operator*(const Vector &rhs)const
142                 { return _x*rhs._x+_y*rhs._y; }
143
144         bool
145         operator==(const Vector &rhs)const
146                 { return _x==rhs._x && _y==rhs._y; }
147
148         bool
149         operator!=(const Vector &rhs)const
150                 { return _y!=rhs._y || _x!=rhs._x; }
151
152         //! Returns the squared magnitude of the vector
153         value_type mag_squared()const
154                 { return _x*_x+_y*_y; }
155
156         //! Returns the magnitude of the vector
157         value_type mag()const
158                 { return sqrt(mag_squared()); }
159
160         //! Returns the reciprocal of the magnitude of the vector
161         value_type inv_mag()const
162                 { return 1.0/sqrt(mag_squared()); }
163
164         //! Returns a normalized version of the vector
165         Vector norm()const
166                 { return (*this)*inv_mag(); }
167
168         //! Returns a perpendicular version of the vector
169         Vector perp()const
170                 { return Vector(_y,-_x); }
171
172         bool is_equal_to(const Vector& rhs)const
173         {
174                 static const value_type epsilon(0.0000000000001);
175 //              return (_x>rhs._x)?_x-rhs._x<=epsilon:rhs._x-_x<=epsilon && (_y>rhs._y)?_y-rhs._y<=epsilon:rhs._y-_y<=epsilon;
176                 return (*this-rhs).mag_squared()<=epsilon;
177         }
178
179         static const Vector zero() { return Vector(0,0); }
180 };
181
182 /*!     \typedef Point
183 **      \todo writeme
184 */
185 typedef Vector Point;
186
187
188
189 }; // END of namespace synfig
190
191 namespace std {
192
193 inline synfig::Vector::value_type
194 abs(const synfig::Vector &rhs)
195         { return rhs.mag(); }
196
197 }; // END of namespace std
198
199 #include <ETL/bezier>
200
201 _ETL_BEGIN_NAMESPACE
202
203 template <>
204 class bezier_base<synfig::Vector,float> : public std::unary_function<float,synfig::Vector>
205 {
206 public:
207         typedef synfig::Vector value_type;
208         typedef float time_type;
209 private:
210
211         bezier_base<synfig::Vector::value_type,time_type> bezier_x,bezier_y;
212
213         value_type a,b,c,d;
214
215 protected:
216         affine_combo<value_type,time_type> affine_func;
217
218 public:
219         bezier_base() { }
220         bezier_base(
221                 const value_type &a, const value_type &b, const value_type &c, const value_type &d,
222                 const time_type &r=0.0, const time_type &s=1.0):
223                 a(a),b(b),c(c),d(d) { set_rs(r,s); sync(); }
224
225         void sync()
226         {
227                 bezier_x[0]=a[0],bezier_y[0]=a[1];
228                 bezier_x[1]=b[0],bezier_y[1]=b[1];
229                 bezier_x[2]=c[0],bezier_y[2]=c[1];
230                 bezier_x[3]=d[0],bezier_y[3]=d[1];
231                 bezier_x.sync();
232                 bezier_y.sync();
233         }
234
235         value_type
236         operator()(time_type t)const
237         {
238                 return synfig::Vector(bezier_x(t),bezier_y(t));
239         }
240
241         void evaluate(time_type t, value_type &f, value_type &df) const
242         {
243                 t=(t-get_r())/get_dt();
244
245                 const value_type p1 = affine_func(
246                                                         affine_func(a,b,t),
247                                                         affine_func(b,c,t)
248                                                         ,t);
249                 const value_type p2 = affine_func(
250                                                         affine_func(b,c,t),
251                                                         affine_func(c,d,t)
252                                                 ,t);
253
254                 f = affine_func(p1,p2,t);
255                 df = (p2-p1)*3;
256         }
257
258         void set_rs(time_type new_r, time_type new_s) { bezier_x.set_rs(new_r,new_s); bezier_y.set_rs(new_r,new_s); }
259         void set_r(time_type new_r) { bezier_x.set_r(new_r); bezier_y.set_r(new_r); }
260         void set_s(time_type new_s) { bezier_x.set_s(new_s); bezier_y.set_s(new_s); }
261         const time_type &get_r()const { return bezier_x.get_r(); }
262         const time_type &get_s()const { return bezier_x.get_s(); }
263         time_type get_dt()const { return bezier_x.get_dt(); }
264
265         value_type &
266         operator[](int i)
267         { return (&a)[i]; }
268
269         const value_type &
270         operator[](int i) const
271         { return (&a)[i]; }
272
273         //! Bezier curve intersection function
274         time_type intersect(const bezier_base<value_type,time_type> &x, time_type near=0.0)const
275         {
276                 return 0;
277         }
278 };
279
280 _ETL_END_NAMESPACE
281
282
283 /* === E N D =============================================================== */
284
285 #endif