zenilib: zenilib/jni/external/freetype2/src/autofit/afangles.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
afangles.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* afangles.c */
4 /* */
5 /* Routines used to compute vector angles with limited accuracy */
6 /* and very high speed. It also contains sorting routines (body). */
7 /* */
8 /* Copyright 2003-2006, 2011 by */
9 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
10 /* */
11 /* This file is part of the FreeType project, and may only be used, */
12 /* modified, and distributed under the terms of the FreeType project */
13 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
14 /* this file you indicate that you have read the license and */
15 /* understand and accept it fully. */
16 /* */
17 /***************************************************************************/
18
19
20 #include "aftypes.h"
21
22
23 #if 0
24
25 FT_LOCAL_DEF( FT_Int )
26 af_corner_is_flat( FT_Pos x_in,
27 FT_Pos y_in,
28 FT_Pos x_out,
29 FT_Pos y_out )
30 {
31 FT_Pos ax = x_in;
32 FT_Pos ay = y_in;
33
34 FT_Pos d_in, d_out, d_corner;
35
36
37 if ( ax < 0 )
38 ax = -ax;
39 if ( ay < 0 )
40 ay = -ay;
41 d_in = ax + ay;
42
43 ax = x_out;
44 if ( ax < 0 )
45 ax = -ax;
46 ay = y_out;
47 if ( ay < 0 )
48 ay = -ay;
49 d_out = ax + ay;
50
51 ax = x_out + x_in;
52 if ( ax < 0 )
53 ax = -ax;
54 ay = y_out + y_in;
55 if ( ay < 0 )
56 ay = -ay;
57 d_corner = ax + ay;
58
59 return ( d_in + d_out - d_corner ) < ( d_corner >> 4 );
60 }
61
62
63 FT_LOCAL_DEF( FT_Int )
64 af_corner_orientation( FT_Pos x_in,
65 FT_Pos y_in,
66 FT_Pos x_out,
67 FT_Pos y_out )
68 {
69 FT_Pos delta;
70
71
72 delta = x_in * y_out - y_in * x_out;
73
74 if ( delta == 0 )
75 return 0;
76 else
77 return 1 - 2 * ( delta < 0 );
78 }
79
80 #endif /* 0 */
81
82
83 /*
84 * We are not using `af_angle_atan' anymore, but we keep the source
85 * code below just in case...
86 */
87
88
89 #if 0
90
91
92 /*
93 * The trick here is to realize that we don't need a very accurate angle
94 * approximation. We are going to use the result of `af_angle_atan' to
95 * only compare the sign of angle differences, or check whether its
96 * magnitude is very small.
97 *
98 * The approximation
99 *
100 * dy * PI / (|dx|+|dy|)
101 *
102 * should be enough, and much faster to compute.
103 */
104 FT_LOCAL_DEF( AF_Angle )
105 af_angle_atan( FT_Fixed dx,
106 FT_Fixed dy )
107 {
108 AF_Angle angle;
109 FT_Fixed ax = dx;
110 FT_Fixed ay = dy;
111
112
113 if ( ax < 0 )
114 ax = -ax;
115 if ( ay < 0 )
116 ay = -ay;
117
118 ax += ay;
119
120 if ( ax == 0 )
121 angle = 0;
122 else
123 {
124 angle = ( AF_ANGLE_PI2 * dy ) / ( ax + ay );
125 if ( dx < 0 )
126 {
127 if ( angle >= 0 )
128 angle = AF_ANGLE_PI - angle;
129 else
130 angle = -AF_ANGLE_PI - angle;
131 }
132 }
133
134 return angle;
135 }
136
137
138 #elif 0
139
140
141 /* the following table has been automatically generated with */
142 /* the `mather.py' Python script */
143
144 #define AF_ATAN_BITS 8
145
146 static const FT_Byte af_arctan[1L << AF_ATAN_BITS] =
147 {
148 0, 0, 1, 1, 1, 2, 2, 2,
149 3, 3, 3, 3, 4, 4, 4, 5,
150 5, 5, 6, 6, 6, 7, 7, 7,
151 8, 8, 8, 9, 9, 9, 10, 10,
152 10, 10, 11, 11, 11, 12, 12, 12,
153 13, 13, 13, 14, 14, 14, 14, 15,
154 15, 15, 16, 16, 16, 17, 17, 17,
155 18, 18, 18, 18, 19, 19, 19, 20,
156 20, 20, 21, 21, 21, 21, 22, 22,
157 22, 23, 23, 23, 24, 24, 24, 24,
158 25, 25, 25, 26, 26, 26, 26, 27,
159 27, 27, 28, 28, 28, 28, 29, 29,
160 29, 30, 30, 30, 30, 31, 31, 31,
161 31, 32, 32, 32, 33, 33, 33, 33,
162 34, 34, 34, 34, 35, 35, 35, 35,
163 36, 36, 36, 36, 37, 37, 37, 38,
164 38, 38, 38, 39, 39, 39, 39, 40,
165 40, 40, 40, 41, 41, 41, 41, 42,
166 42, 42, 42, 42, 43, 43, 43, 43,
167 44, 44, 44, 44, 45, 45, 45, 45,
168 46, 46, 46, 46, 46, 47, 47, 47,
169 47, 48, 48, 48, 48, 48, 49, 49,
170 49, 49, 50, 50, 50, 50, 50, 51,
171 51, 51, 51, 51, 52, 52, 52, 52,
172 52, 53, 53, 53, 53, 53, 54, 54,
173 54, 54, 54, 55, 55, 55, 55, 55,
174 56, 56, 56, 56, 56, 57, 57, 57,
175 57, 57, 57, 58, 58, 58, 58, 58,
176 59, 59, 59, 59, 59, 59, 60, 60,
177 60, 60, 60, 61, 61, 61, 61, 61,
178 61, 62, 62, 62, 62, 62, 62, 63,
179 63, 63, 63, 63, 63, 64, 64, 64
180 };
181
182
183 FT_LOCAL_DEF( AF_Angle )
184 af_angle_atan( FT_Fixed dx,
185 FT_Fixed dy )
186 {
187 AF_Angle angle;
188
189
190 /* check trivial cases */
191 if ( dy == 0 )
192 {
193 angle = 0;
194 if ( dx < 0 )
195 angle = AF_ANGLE_PI;
196 return angle;
197 }
198 else if ( dx == 0 )
199 {
200 angle = AF_ANGLE_PI2;
201 if ( dy < 0 )
202 angle = -AF_ANGLE_PI2;
203 return angle;
204 }
205
206 angle = 0;
207 if ( dx < 0 )
208 {
209 dx = -dx;
210 dy = -dy;
211 angle = AF_ANGLE_PI;
212 }
213
214 if ( dy < 0 )
215 {
216 FT_Pos tmp;
217
218
219 tmp = dx;
220 dx = -dy;
221 dy = tmp;
222 angle -= AF_ANGLE_PI2;
223 }
224
225 if ( dx == 0 && dy == 0 )
226 return 0;
227
228 if ( dx == dy )
229 angle += AF_ANGLE_PI4;
230 else if ( dx > dy )
231 angle += af_arctan[FT_DivFix( dy, dx ) >> ( 16 - AF_ATAN_BITS )];
232 else
233 angle += AF_ANGLE_PI2 -
234 af_arctan[FT_DivFix( dx, dy ) >> ( 16 - AF_ATAN_BITS )];
235
236 if ( angle > AF_ANGLE_PI )
237 angle -= AF_ANGLE_2PI;
238
239 return angle;
240 }
241
242
243 #endif /* 0 */
244
245
246 FT_LOCAL_DEF( void )
247 af_sort_pos( FT_UInt count,
248 FT_Pos* table )
249 {
250 FT_UInt i, j;
251 FT_Pos swap;
252
253
254 for ( i = 1; i < count; i++ )
255 {
256 for ( j = i; j > 0; j-- )
257 {
258 if ( table[j] > table[j - 1] )
259 break;
260
261 swap = table[j];
262 table[j] = table[j - 1];
263 table[j - 1] = swap;
264 }
265 }
266 }
267
268
269 FT_LOCAL_DEF( void )
270 af_sort_widths( FT_UInt count,
271 AF_Width table )
272 {
273 FT_UInt i, j;
274 AF_WidthRec swap;
275
276
277 for ( i = 1; i < count; i++ )
278 {
279 for ( j = i; j > 0; j-- )
280 {
281 if ( table[j].org > table[j - 1].org )
282 break;
283
284 swap = table[j];
285 table[j] = table[j - 1];
286 table[j - 1] = swap;
287 }
288 }
289 }
290
291
292 /* END */
table
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glew.h:4422
FT_DivFix
FT_DivFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:536
FT_Pos
FT_BEGIN_HEADER typedef signed long FT_Pos
Definition: ftimage.h:59
AF_ANGLE_PI4
#define AF_ANGLE_PI4
Definition: aftypes.h:114
FT_Int
signed int FT_Int
Definition: fttypes.h:216
angle
GLdouble angle
Definition: glew.h:8396
j
int32_t j
Definition: e_log.c:102
af_sort_widths
af_sort_widths(FT_UInt count, AF_Width table)
Definition: afangles.c:270
FT_Byte
unsigned char FT_Byte
Definition: fttypes.h:150
AF_ANGLE_PI2
#define AF_ANGLE_PI2
Definition: aftypes.h:113
FT_LOCAL_DEF
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:467
count
GLint GLsizei count
Definition: gl2ext.h:1011
AF_Angle
FT_Int AF_Angle
Definition: aftypes.h:108
aftypes.h
FT_Fixed
signed long FT_Fixed
Definition: fttypes.h:284
AF_Width
FT_BEGIN_HEADER struct AF_WidthRec_ * AF_Width
swap
void swap(Zeni::String &lhs, Zeni::String &rhs)
Definition: String.cpp:578
FT_UInt
unsigned int FT_UInt
Definition: fttypes.h:227
AF_WidthRec
FT_BEGIN_HEADER struct AF_WidthRec_ AF_WidthRec
AF_ANGLE_PI
#define AF_ANGLE_PI
Definition: aftypes.h:111
i
int i
Definition: pngrutil.c:1377
af_sort_pos
af_sort_pos(FT_UInt count, FT_Pos *table)
Definition: afangles.c:247
AF_ANGLE_2PI
#define AF_ANGLE_2PI
Definition: aftypes.h:112