]> git.sesse.net Git - vlc/blob - modules/gui/skins2/utils/bezier.cpp
Support for UDP-Lite (with full checksum coverage only atm)
[vlc] / modules / gui / skins2 / utils / bezier.cpp
1 /*****************************************************************************
2  * bezier.cpp
3  *****************************************************************************
4  * Copyright (C) 2003 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Cyril Deguet     <asmax@via.ecp.fr>
8  *          Olivier Teulière <ipkiss@via.ecp.fr>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program 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
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 #include <vlc/vlc.h>
26 #include "bezier.hpp"
27 #include <math.h>
28
29 // XXX should be in VLC core
30 #ifndef HAVE_LRINTF
31 #   ifdef HAVE_LRINT
32 #       define lrintf( x ) (int)rint( x )
33 #   elif defined WIN32
34             __inline long int lrintf( float x )
35             {
36             int i;
37             _asm fld x __asm fistp i
38                     return i;
39         }
40 #   endif
41 #endif
42
43 Bezier::Bezier( intf_thread_t *p_intf, const vector<float> &rAbscissas,
44                 const vector<float> &rOrdinates, Flag_t flag )
45     : SkinObject( p_intf )
46 {
47     // Copy the control points coordinates
48     m_ptx.assign( rAbscissas.begin(), rAbscissas.end() );
49     m_pty.assign( rOrdinates.begin(), rOrdinates.end() );
50
51     // We expect m_ptx and m_pty to have the same size, of course
52     m_nbCtrlPt = m_ptx.size();
53
54     // Precalculate the factoriels
55     m_ft.push_back( 1 );
56     for( int i = 1; i < m_nbCtrlPt; i++ )
57     {
58         m_ft.push_back( i * m_ft[i - 1] );
59     }
60
61     // Calculate the first point
62     int oldx, oldy;
63     computePoint( 0, oldx, oldy );
64     m_leftVect.push_back( oldx );
65     m_topVect.push_back( oldy );
66     m_percVect.push_back( 0 );
67
68     // Calculate the other points
69     float percentage;
70     int cx, cy;
71     for( float j = 1; j <= MAX_BEZIER_POINT; j++ )
72     {
73         percentage = j / MAX_BEZIER_POINT;
74         computePoint( percentage, cx, cy );
75         if( ( flag == kCoordsBoth && ( cx != oldx || cy != oldy ) ) ||
76             ( flag == kCoordsX && cx != oldx ) ||
77             ( flag == kCoordsY && cy != oldy ) )
78         {
79             m_percVect.push_back( percentage );
80             m_leftVect.push_back( cx );
81             m_topVect.push_back( cy );
82             oldx = cx;
83             oldy = cy;
84         }
85     }
86     m_nbPoints = m_leftVect.size();
87
88     // If we have only one control point, we duplicate it
89     // This allows to simplify the algorithms used in the class
90     if( m_nbPoints == 1 )
91     {
92         m_leftVect.push_back( m_leftVect[0] );
93         m_topVect.push_back( m_topVect[0] );
94         m_percVect.push_back( 1 );
95         m_nbPoints = 2;
96    }
97
98     // Ensure that the percentage of the last point is always 1
99     m_percVect[m_nbPoints - 1] = 1;
100 }
101
102
103 float Bezier::getNearestPercent( int x, int y ) const
104 {
105     int nearest = findNearestPoint( x, y );
106     return m_percVect[nearest];
107 }
108
109
110 float Bezier::getMinDist( int x, int y, float xScale, float yScale ) const
111 {
112     int nearest = findNearestPoint( x, y );
113     double xDist = xScale * (m_leftVect[nearest] - x);
114     double yDist = yScale * (m_topVect[nearest] - y);
115     return sqrt( xDist * xDist + yDist * yDist );
116 }
117
118
119 void Bezier::getPoint( float t, int &x, int &y ) const
120 {
121     // Find the precalculated point whose percentage is nearest from t
122     int refPoint = 0;
123     float minDiff = fabs( m_percVect[0] - t );
124
125     // The percentages are stored in increasing order, so we can stop the loop
126     // as soon as 'diff' starts increasing
127     float diff;
128     while( refPoint < m_nbPoints &&
129            (diff = fabs( m_percVect[refPoint] - t )) <= minDiff )
130     {
131         refPoint++;
132         minDiff = diff;
133     }
134
135     // The searched point is then (refPoint - 1)
136     // We know that refPoint > 0 because we looped at least once
137     x = m_leftVect[refPoint - 1];
138     y = m_topVect[refPoint - 1];
139 }
140
141
142 int Bezier::getWidth() const
143 {
144     int width = 0;
145     for( int i = 0; i < m_nbPoints; i++ )
146     {
147         if( m_leftVect[i] >= width )
148         {
149             width = m_leftVect[i] + 1;
150         }
151     }
152     return width;
153 }
154
155
156 int Bezier::getHeight() const
157 {
158     int height = 0;
159     for( int i = 0; i < m_nbPoints; i++ )
160     {
161         if( m_topVect[i] >= height )
162         {
163             height = m_topVect[i] + 1;
164         }
165     }
166     return height;
167 }
168
169
170 int Bezier::findNearestPoint( int x, int y ) const
171 {
172     // The distance to the first point is taken as the reference
173     int refPoint = 0;
174     int minDist = (m_leftVect[0] - x) * (m_leftVect[0] - x) +
175                   (m_topVect[0] - y) * (m_topVect[0] - y);
176
177     int dist;
178     for( int i = 1; i < m_nbPoints; i++ )
179     {
180         dist = (m_leftVect[i] - x) * (m_leftVect[i] - x) +
181                (m_topVect[i] - y) * (m_topVect[i] - y);
182         if( dist < minDist )
183         {
184             minDist = dist;
185             refPoint = i;
186         }
187     }
188
189     return refPoint;
190 }
191
192
193 void Bezier::computePoint( float t, int &x, int &y ) const
194 {
195     // See http://astronomy.swin.edu.au/~pbourke/curves/bezier/ for a simple
196     // explanation of the algorithm
197     float xPos = 0;
198     float yPos = 0;
199     float coeff;
200     for( int i = 0; i < m_nbCtrlPt; i++ )
201     {
202         coeff = computeCoeff( i, m_nbCtrlPt - 1, t );
203         xPos += m_ptx[i] * coeff;
204         yPos += m_pty[i] * coeff;
205     }
206
207     x = lrintf(xPos);
208     y = lrintf(yPos);
209 }
210
211
212 inline float Bezier::computeCoeff( int i, int n, float t ) const
213 {
214     return (power( t, i ) * power( 1 - t, (n - i) ) *
215         (m_ft[n] / m_ft[i] / m_ft[n - i]));
216 }
217
218
219 inline float Bezier::power( float x, int n ) const
220 {
221     if( n > 0 )
222         return x * power( x, n - 1);
223     else
224         return 1;
225 }