projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[FREETYPE]
[reactos.git] / reactos / lib / 3rdparty / freetype / src / base / ftbbox.c
1 /***************************************************************************/
2 /* */
3 /* ftbbox.c */
4 /* */
5 /* FreeType bbox computation (body). */
6 /* */
7 /* Copyright 1996-2001, 2002, 2004, 2006, 2010 by */
8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
9 /* */
10 /* This file is part of the FreeType project, and may only be used */
11 /* modified and distributed under the terms of the FreeType project */
12 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
13 /* this file you indicate that you have read the license and */
14 /* understand and accept it fully. */
15 /* */
16 /***************************************************************************/
17
18
19 /*************************************************************************/
20 /* */
21 /* This component has a _single_ role: to compute exact outline bounding */
22 /* boxes. */
23 /* */
24 /*************************************************************************/
25
26
27 #include <ft2build.h>
28 #include FT_BBOX_H
29 #include FT_IMAGE_H
30 #include FT_OUTLINE_H
31 #include FT_INTERNAL_CALC_H
32 #include FT_INTERNAL_OBJECTS_H
33
34
35 typedef struct TBBox_Rec_
36 {
37 FT_Vector last;
38 FT_BBox bbox;
39
40 } TBBox_Rec;
41
42
43 /*************************************************************************/
44 /* */
45 /* <Function> */
46 /* BBox_Move_To */
47 /* */
48 /* <Description> */
49 /* This function is used as a `move_to' and `line_to' emitter during */
50 /* FT_Outline_Decompose(). It simply records the destination point */
51 /* in `user->last'; no further computations are necessary since we */
52 /* use the cbox as the starting bbox which must be refined. */
53 /* */
54 /* <Input> */
55 /* to :: A pointer to the destination vector. */
56 /* */
57 /* <InOut> */
58 /* user :: A pointer to the current walk context. */
59 /* */
60 /* <Return> */
61 /* Always 0. Needed for the interface only. */
62 /* */
63 static int
64 BBox_Move_To( FT_Vector* to,
65 TBBox_Rec* user )
66 {
67 user->last = *to;
68
69 return 0;
70 }
71
72
73 #define CHECK_X( p, bbox ) \
74 ( p->x < bbox.xMin || p->x > bbox.xMax )
75
76 #define CHECK_Y( p, bbox ) \
77 ( p->y < bbox.yMin || p->y > bbox.yMax )
78
79
80 /*************************************************************************/
81 /* */
82 /* <Function> */
83 /* BBox_Conic_Check */
84 /* */
85 /* <Description> */
86 /* Finds the extrema of a 1-dimensional conic Bezier curve and update */
87 /* a bounding range. This version uses direct computation, as it */
88 /* doesn't need square roots. */
89 /* */
90 /* <Input> */
91 /* y1 :: The start coordinate. */
92 /* */
93 /* y2 :: The coordinate of the control point. */
94 /* */
95 /* y3 :: The end coordinate. */
96 /* */
97 /* <InOut> */
98 /* min :: The address of the current minimum. */
99 /* */
100 /* max :: The address of the current maximum. */
101 /* */
102 static void
103 BBox_Conic_Check( FT_Pos y1,
104 FT_Pos y2,
105 FT_Pos y3,
106 FT_Pos* min,
107 FT_Pos* max )
108 {
109 if ( y1 <= y3 && y2 == y1 ) /* flat arc */
110 goto Suite;
111
112 if ( y1 < y3 )
113 {
114 if ( y2 >= y1 && y2 <= y3 ) /* ascending arc */
115 goto Suite;
116 }
117 else
118 {
119 if ( y2 >= y3 && y2 <= y1 ) /* descending arc */
120 {
121 y2 = y1;
122 y1 = y3;
123 y3 = y2;
124 goto Suite;
125 }
126 }
127
128 y1 = y3 = y1 - FT_MulDiv( y2 - y1, y2 - y1, y1 - 2*y2 + y3 );
129
130 Suite:
131 if ( y1 < *min ) *min = y1;
132 if ( y3 > *max ) *max = y3;
133 }
134
135
136 /*************************************************************************/
137 /* */
138 /* <Function> */
139 /* BBox_Conic_To */
140 /* */
141 /* <Description> */
142 /* This function is used as a `conic_to' emitter during */
143 /* FT_Outline_Decompose(). It checks a conic Bezier curve with the */
144 /* current bounding box, and computes its extrema if necessary to */
145 /* update it. */
146 /* */
147 /* <Input> */
148 /* control :: A pointer to a control point. */
149 /* */
150 /* to :: A pointer to the destination vector. */
151 /* */
152 /* <InOut> */
153 /* user :: The address of the current walk context. */
154 /* */
155 /* <Return> */
156 /* Always 0. Needed for the interface only. */
157 /* */
158 /* <Note> */
159 /* In the case of a non-monotonous arc, we compute directly the */
160 /* extremum coordinates, as it is sufficiently fast. */
161 /* */
162 static int
163 BBox_Conic_To( FT_Vector* control,
164 FT_Vector* to,
165 TBBox_Rec* user )
166 {
167 /* we don't need to check `to' since it is always an `on' point, thus */
168 /* within the bbox */
169
170 if ( CHECK_X( control, user->bbox ) )
171 BBox_Conic_Check( user->last.x,
172 control->x,
173 to->x,
174 &user->bbox.xMin,
175 &user->bbox.xMax );
176
177 if ( CHECK_Y( control, user->bbox ) )
178 BBox_Conic_Check( user->last.y,
179 control->y,
180 to->y,
181 &user->bbox.yMin,
182 &user->bbox.yMax );
183
184 user->last = *to;
185
186 return 0;
187 }
188
189
190 /*************************************************************************/
191 /* */
192 /* <Function> */
193 /* BBox_Cubic_Check */
194 /* */
195 /* <Description> */
196 /* Finds the extrema of a 1-dimensional cubic Bezier curve and */
197 /* updates a bounding range. This version uses splitting because we */
198 /* don't want to use square roots and extra accuracy. */
199 /* */
200 /* <Input> */
201 /* p1 :: The start coordinate. */
202 /* */
203 /* p2 :: The coordinate of the first control point. */
204 /* */
205 /* p3 :: The coordinate of the second control point. */
206 /* */
207 /* p4 :: The end coordinate. */
208 /* */
209 /* <InOut> */
210 /* min :: The address of the current minimum. */
211 /* */
212 /* max :: The address of the current maximum. */
213 /* */
214
215 #if 0
216
217 static void
218 BBox_Cubic_Check( FT_Pos p1,
219 FT_Pos p2,
220 FT_Pos p3,
221 FT_Pos p4,
222 FT_Pos* min,
223 FT_Pos* max )
224 {
225 FT_Pos stack[32*3 + 1], *arc;
226
227
228 arc = stack;
229
230 arc[0] = p1;
231 arc[1] = p2;
232 arc[2] = p3;
233 arc[3] = p4;
234
235 do
236 {
237 FT_Pos y1 = arc[0];
238 FT_Pos y2 = arc[1];
239 FT_Pos y3 = arc[2];
240 FT_Pos y4 = arc[3];
241
242
243 if ( y1 == y4 )
244 {
245 if ( y1 == y2 && y1 == y3 ) /* flat */
246 goto Test;
247 }
248 else if ( y1 < y4 )
249 {
250 if ( y2 >= y1 && y2 <= y4 && y3 >= y1 && y3 <= y4 ) /* ascending */
251 goto Test;
252 }
253 else
254 {
255 if ( y2 >= y4 && y2 <= y1 && y3 >= y4 && y3 <= y1 ) /* descending */
256 {
257 y2 = y1;
258 y1 = y4;
259 y4 = y2;
260 goto Test;
261 }
262 }
263
264 /* unknown direction -- split the arc in two */
265 arc[6] = y4;
266 arc[1] = y1 = ( y1 + y2 ) / 2;
267 arc[5] = y4 = ( y4 + y3 ) / 2;
268 y2 = ( y2 + y3 ) / 2;
269 arc[2] = y1 = ( y1 + y2 ) / 2;
270 arc[4] = y4 = ( y4 + y2 ) / 2;
271 arc[3] = ( y1 + y4 ) / 2;
272
273 arc += 3;
274 goto Suite;
275
276 Test:
277 if ( y1 < *min ) *min = y1;
278 if ( y4 > *max ) *max = y4;
279 arc -= 3;
280
281 Suite:
282 ;
283 } while ( arc >= stack );
284 }
285
286 #else
287
288 static void
289 test_cubic_extrema( FT_Pos y1,
290 FT_Pos y2,
291 FT_Pos y3,
292 FT_Pos y4,
293 FT_Fixed u,
294 FT_Pos* min,
295 FT_Pos* max )
296 {
297 /* FT_Pos a = y4 - 3*y3 + 3*y2 - y1; */
298 FT_Pos b = y3 - 2*y2 + y1;
299 FT_Pos c = y2 - y1;
300 FT_Pos d = y1;
301 FT_Pos y;
302 FT_Fixed uu;
303
304 FT_UNUSED ( y4 );
305
306
307 /* The polynomial is */
308 /* */
309 /* P(x) = a*x^3 + 3b*x^2 + 3c*x + d , */
310 /* */
311 /* dP/dx = 3a*x^2 + 6b*x + 3c . */
312 /* */
313 /* However, we also have */
314 /* */
315 /* dP/dx(u) = 0 , */
316 /* */
317 /* which implies by subtraction that */
318 /* */
319 /* P(u) = b*u^2 + 2c*u + d . */
320
321 if ( u > 0 && u < 0x10000L )
322 {
323 uu = FT_MulFix( u, u );
324 y = d + FT_MulFix( c, 2*u ) + FT_MulFix( b, uu );
325
326 if ( y < *min ) *min = y;
327 if ( y > *max ) *max = y;
328 }
329 }
330
331
332 static void
333 BBox_Cubic_Check( FT_Pos y1,
334 FT_Pos y2,
335 FT_Pos y3,
336 FT_Pos y4,
337 FT_Pos* min,
338 FT_Pos* max )
339 {
340 /* always compare first and last points */
341 if ( y1 < *min ) *min = y1;
342 else if ( y1 > *max ) *max = y1;
343
344 if ( y4 < *min ) *min = y4;
345 else if ( y4 > *max ) *max = y4;
346
347 /* now, try to see if there are split points here */
348 if ( y1 <= y4 )
349 {
350 /* flat or ascending arc test */
351 if ( y1 <= y2 && y2 <= y4 && y1 <= y3 && y3 <= y4 )
352 return;
353 }
354 else /* y1 > y4 */
355 {
356 /* descending arc test */
357 if ( y1 >= y2 && y2 >= y4 && y1 >= y3 && y3 >= y4 )
358 return;
359 }
360
361 /* There are some split points. Find them. */
362 {
363 FT_Pos a = y4 - 3*y3 + 3*y2 - y1;
364 FT_Pos b = y3 - 2*y2 + y1;
365 FT_Pos c = y2 - y1;
366 FT_Pos d;
367 FT_Fixed t;
368
369
370 /* We need to solve `ax^2+2bx+c' here, without floating points! */
371 /* The trick is to normalize to a different representation in order */
372 /* to use our 16.16 fixed point routines. */
373 /* */
374 /* We compute FT_MulFix(b,b) and FT_MulFix(a,c) after normalization. */
375 /* These values must fit into a single 16.16 value. */
376 /* */
377 /* We normalize a, b, and c to `8.16' fixed float values to ensure */
378 /* that its product is held in a `16.16' value. */
379
380 {
381 FT_ULong t1, t2;
382 int shift = 0;
383
384
385 /* The following computation is based on the fact that for */
386 /* any value `y', if `n' is the position of the most */
387 /* significant bit of `abs(y)' (starting from 0 for the */
388 /* least significant bit), then `y' is in the range */
389 /* */
390 /* -2^n..2^n-1 */
391 /* */
392 /* We want to shift `a', `b', and `c' concurrently in order */
393 /* to ensure that they all fit in 8.16 values, which maps */
394 /* to the integer range `-2^23..2^23-1'. */
395 /* */
396 /* Necessarily, we need to shift `a', `b', and `c' so that */
397 /* the most significant bit of its absolute values is at */
398 /* _most_ at position 23. */
399 /* */
400 /* We begin by computing `t1' as the bitwise `OR' of the */
401 /* absolute values of `a', `b', `c'. */
402
403 t1 = (FT_ULong)( ( a >= 0 ) ? a : -a );
404 t2 = (FT_ULong)( ( b >= 0 ) ? b : -b );
405 t1 |= t2;
406 t2 = (FT_ULong)( ( c >= 0 ) ? c : -c );
407 t1 |= t2;
408
409 /* Now we can be sure that the most significant bit of `t1' */
410 /* is the most significant bit of either `a', `b', or `c', */
411 /* depending on the greatest integer range of the particular */
412 /* variable. */
413 /* */
414 /* Next, we compute the `shift', by shifting `t1' as many */
415 /* times as necessary to move its MSB to position 23. This */
416 /* corresponds to a value of `t1' that is in the range */
417 /* 0x40_0000..0x7F_FFFF. */
418 /* */
419 /* Finally, we shift `a', `b', and `c' by the same amount. */
420 /* This ensures that all values are now in the range */
421 /* -2^23..2^23, i.e., they are now expressed as 8.16 */
422 /* fixed-float numbers. This also means that we are using */
423 /* 24 bits of precision to compute the zeros, independently */
424 /* of the range of the original polynomial coefficients. */
425 /* */
426 /* This algorithm should ensure reasonably accurate values */
427 /* for the zeros. Note that they are only expressed with */
428 /* 16 bits when computing the extrema (the zeros need to */
429 /* be in 0..1 exclusive to be considered part of the arc). */
430
431 if ( t1 == 0 ) /* all coefficients are 0! */
432 return;
433
434 if ( t1 > 0x7FFFFFUL )
435 {
436 do
437 {
438 shift++;
439 t1 >>= 1;
440
441 } while ( t1 > 0x7FFFFFUL );
442
443 /* this loses some bits of precision, but we use 24 of them */
444 /* for the computation anyway */
445 a >>= shift;
446 b >>= shift;
447 c >>= shift;
448 }
449 else if ( t1 < 0x400000UL )
450 {
451 do
452 {
453 shift++;
454 t1 <<= 1;
455
456 } while ( t1 < 0x400000UL );
457
458 a <<= shift;
459 b <<= shift;
460 c <<= shift;
461 }
462 }
463
464 /* handle a == 0 */
465 if ( a == 0 )
466 {
467 if ( b != 0 )
468 {
469 t = - FT_DivFix( c, b ) / 2;
470 test_cubic_extrema( y1, y2, y3, y4, t, min, max );
471 }
472 }
473 else
474 {
475 /* solve the equation now */
476 d = FT_MulFix( b, b ) - FT_MulFix( a, c );
477 if ( d < 0 )
478 return;
479
480 if ( d == 0 )
481 {
482 /* there is a single split point at -b/a */
483 t = - FT_DivFix( b, a );
484 test_cubic_extrema( y1, y2, y3, y4, t, min, max );
485 }
486 else
487 {
488 /* there are two solutions; we need to filter them */
489 d = FT_SqrtFixed( (FT_Int32)d );
490 t = - FT_DivFix( b - d, a );
491 test_cubic_extrema( y1, y2, y3, y4, t, min, max );
492
493 t = - FT_DivFix( b + d, a );
494 test_cubic_extrema( y1, y2, y3, y4, t, min, max );
495 }
496 }
497 }
498 }
499
500 #endif
501
502
503 /*************************************************************************/
504 /* */
505 /* <Function> */
506 /* BBox_Cubic_To */
507 /* */
508 /* <Description> */
509 /* This function is used as a `cubic_to' emitter during */
510 /* FT_Outline_Decompose(). It checks a cubic Bezier curve with the */
511 /* current bounding box, and computes its extrema if necessary to */
512 /* update it. */
513 /* */
514 /* <Input> */
515 /* control1 :: A pointer to the first control point. */
516 /* */
517 /* control2 :: A pointer to the second control point. */
518 /* */
519 /* to :: A pointer to the destination vector. */
520 /* */
521 /* <InOut> */
522 /* user :: The address of the current walk context. */
523 /* */
524 /* <Return> */
525 /* Always 0. Needed for the interface only. */
526 /* */
527 /* <Note> */
528 /* In the case of a non-monotonous arc, we don't compute directly */
529 /* extremum coordinates, we subdivide instead. */
530 /* */
531 static int
532 BBox_Cubic_To( FT_Vector* control1,
533 FT_Vector* control2,
534 FT_Vector* to,
535 TBBox_Rec* user )
536 {
537 /* we don't need to check `to' since it is always an `on' point, thus */
538 /* within the bbox */
539
540 if ( CHECK_X( control1, user->bbox ) ||
541 CHECK_X( control2, user->bbox ) )
542 BBox_Cubic_Check( user->last.x,
543 control1->x,
544 control2->x,
545 to->x,
546 &user->bbox.xMin,
547 &user->bbox.xMax );
548
549 if ( CHECK_Y( control1, user->bbox ) ||
550 CHECK_Y( control2, user->bbox ) )
551 BBox_Cubic_Check( user->last.y,
552 control1->y,
553 control2->y,
554 to->y,
555 &user->bbox.yMin,
556 &user->bbox.yMax );
557
558 user->last = *to;
559
560 return 0;
561 }
562
563 FT_DEFINE_OUTLINE_FUNCS(bbox_interface,
564 (FT_Outline_MoveTo_Func) BBox_Move_To,
565 (FT_Outline_LineTo_Func) BBox_Move_To,
566 (FT_Outline_ConicTo_Func)BBox_Conic_To,
567 (FT_Outline_CubicTo_Func)BBox_Cubic_To,
568 0, 0
569 )
570
571 /* documentation is in ftbbox.h */
572
573 FT_EXPORT_DEF( FT_Error )
574 FT_Outline_Get_BBox( FT_Outline* outline,
575 FT_BBox *abbox )
576 {
577 FT_BBox cbox;
578 FT_BBox bbox;
579 FT_Vector* vec;
580 FT_UShort n;
581
582
583 if ( !abbox )
584 return FT_Err_Invalid_Argument;
585
586 if ( !outline )
587 return FT_Err_Invalid_Outline;
588
589 /* if outline is empty, return (0,0,0,0) */
590 if ( outline->n_points == 0 || outline->n_contours <= 0 )
591 {
592 abbox->xMin = abbox->xMax = 0;
593 abbox->yMin = abbox->yMax = 0;
594 return 0;
595 }
596
597 /* We compute the control box as well as the bounding box of */
598 /* all `on' points in the outline. Then, if the two boxes */
599 /* coincide, we exit immediately. */
600
601 vec = outline->points;
602 bbox.xMin = bbox.xMax = cbox.xMin = cbox.xMax = vec->x;
603 bbox.yMin = bbox.yMax = cbox.yMin = cbox.yMax = vec->y;
604 vec++;
605
606 for ( n = 1; n < outline->n_points; n++ )
607 {
608 FT_Pos x = vec->x;
609 FT_Pos y = vec->y;
610
611
612 /* update control box */
613 if ( x < cbox.xMin ) cbox.xMin = x;
614 if ( x > cbox.xMax ) cbox.xMax = x;
615
616 if ( y < cbox.yMin ) cbox.yMin = y;
617 if ( y > cbox.yMax ) cbox.yMax = y;
618
619 if ( FT_CURVE_TAG( outline->tags[n] ) == FT_CURVE_TAG_ON )
620 {
621 /* update bbox for `on' points only */
622 if ( x < bbox.xMin ) bbox.xMin = x;
623 if ( x > bbox.xMax ) bbox.xMax = x;
624
625 if ( y < bbox.yMin ) bbox.yMin = y;
626 if ( y > bbox.yMax ) bbox.yMax = y;
627 }
628
629 vec++;
630 }
631
632 /* test two boxes for equality */
633 if ( cbox.xMin < bbox.xMin || cbox.xMax > bbox.xMax ||
634 cbox.yMin < bbox.yMin || cbox.yMax > bbox.yMax )
635 {
636 /* the two boxes are different, now walk over the outline to */
637 /* get the Bezier arc extrema. */
638
639 FT_Error error;
640 TBBox_Rec user;
641
642 #ifdef FT_CONFIG_OPTION_PIC
643 FT_Outline_Funcs bbox_interface;
644 Init_Class_bbox_interface(&bbox_interface);
645 #endif
646
647 user.bbox = bbox;
648
649 error = FT_Outline_Decompose( outline, &bbox_interface, &user );
650 if ( error )
651 return error;
652
653 *abbox = user.bbox;
654 }
655 else
656 *abbox = bbox;
657
658 return FT_Err_Ok;
659 }
660
661
662 /* END */
A free Windows-compatible Operating System