1 | /**************************************************************************** |
2 | * |
3 | * ftbbox.c |
4 | * |
5 | * FreeType bbox computation (body). |
6 | * |
7 | * Copyright (C) 1996-2023 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 <freetype/internal/ftdebug.h> |
28 | |
29 | #include <freetype/ftbbox.h> |
30 | #include <freetype/ftimage.h> |
31 | #include <freetype/ftoutln.h> |
32 | #include <freetype/internal/ftcalc.h> |
33 | #include <freetype/internal/ftobjs.h> |
34 | |
35 | |
36 | typedef struct TBBox_Rec_ |
37 | { |
38 | FT_Vector last; |
39 | FT_BBox bbox; |
40 | |
41 | } TBBox_Rec; |
42 | |
43 | |
44 | #define FT_UPDATE_BBOX( p, bbox ) \ |
45 | FT_BEGIN_STMNT \ |
46 | if ( p->x < bbox.xMin ) \ |
47 | bbox.xMin = p->x; \ |
48 | if ( p->x > bbox.xMax ) \ |
49 | bbox.xMax = p->x; \ |
50 | if ( p->y < bbox.yMin ) \ |
51 | bbox.yMin = p->y; \ |
52 | if ( p->y > bbox.yMax ) \ |
53 | bbox.yMax = p->y; \ |
54 | FT_END_STMNT |
55 | |
56 | #define CHECK_X( p, bbox ) \ |
57 | ( p->x < bbox.xMin || p->x > bbox.xMax ) |
58 | |
59 | #define CHECK_Y( p, bbox ) \ |
60 | ( p->y < bbox.yMin || p->y > bbox.yMax ) |
61 | |
62 | |
63 | /************************************************************************** |
64 | * |
65 | * @Function: |
66 | * BBox_Move_To |
67 | * |
68 | * @Description: |
69 | * This function is used as a `move_to' emitter during |
70 | * FT_Outline_Decompose(). It simply records the destination point |
71 | * in `user->last'. We also update bbox in case contour starts with |
72 | * an implicit `on' point. |
73 | * |
74 | * @Input: |
75 | * to :: |
76 | * A pointer to the destination vector. |
77 | * |
78 | * @InOut: |
79 | * user :: |
80 | * A pointer to the current walk context. |
81 | * |
82 | * @Return: |
83 | * Always 0. Needed for the interface only. |
84 | */ |
85 | FT_CALLBACK_DEF( int ) |
86 | BBox_Move_To( const FT_Vector* to, |
87 | void* user_ ) |
88 | { |
89 | TBBox_Rec* user = (TBBox_Rec*)user_; |
90 | |
91 | |
92 | FT_UPDATE_BBOX( to, user->bbox ); |
93 | |
94 | user->last = *to; |
95 | |
96 | return 0; |
97 | } |
98 | |
99 | |
100 | /************************************************************************** |
101 | * |
102 | * @Function: |
103 | * BBox_Line_To |
104 | * |
105 | * @Description: |
106 | * This function is used as a `line_to' emitter during |
107 | * FT_Outline_Decompose(). It simply records the destination point |
108 | * in `user->last'; no further computations are necessary because |
109 | * bbox already contains both explicit ends of the line segment. |
110 | * |
111 | * @Input: |
112 | * to :: |
113 | * A pointer to the destination vector. |
114 | * |
115 | * @InOut: |
116 | * user :: |
117 | * A pointer to the current walk context. |
118 | * |
119 | * @Return: |
120 | * Always 0. Needed for the interface only. |
121 | */ |
122 | FT_CALLBACK_DEF( int ) |
123 | BBox_Line_To( const FT_Vector* to, |
124 | void* user_ ) |
125 | { |
126 | TBBox_Rec* user = (TBBox_Rec*)user_; |
127 | |
128 | |
129 | user->last = *to; |
130 | |
131 | return 0; |
132 | } |
133 | |
134 | |
135 | /************************************************************************** |
136 | * |
137 | * @Function: |
138 | * BBox_Conic_Check |
139 | * |
140 | * @Description: |
141 | * Find the extrema of a 1-dimensional conic Bezier curve and update |
142 | * a bounding range. This version uses direct computation, as it |
143 | * doesn't need square roots. |
144 | * |
145 | * @Input: |
146 | * y1 :: |
147 | * The start coordinate. |
148 | * |
149 | * y2 :: |
150 | * The coordinate of the control point. |
151 | * |
152 | * y3 :: |
153 | * The end coordinate. |
154 | * |
155 | * @InOut: |
156 | * min :: |
157 | * The address of the current minimum. |
158 | * |
159 | * max :: |
160 | * The address of the current maximum. |
161 | */ |
162 | static void |
163 | BBox_Conic_Check( FT_Pos y1, |
164 | FT_Pos y2, |
165 | FT_Pos y3, |
166 | FT_Pos* min, |
167 | FT_Pos* max ) |
168 | { |
169 | /* This function is only called when a control off-point is outside */ |
170 | /* the bbox that contains all on-points. It finds a local extremum */ |
171 | /* within the segment, equal to (y1*y3 - y2*y2)/(y1 - 2*y2 + y3). */ |
172 | /* Or, offsetting from y2, we get */ |
173 | |
174 | y1 -= y2; |
175 | y3 -= y2; |
176 | y2 += FT_MulDiv( y1, y3, y1 + y3 ); |
177 | |
178 | if ( y2 < *min ) |
179 | *min = y2; |
180 | if ( y2 > *max ) |
181 | *max = y2; |
182 | } |
183 | |
184 | |
185 | /************************************************************************** |
186 | * |
187 | * @Function: |
188 | * BBox_Conic_To |
189 | * |
190 | * @Description: |
191 | * This function is used as a `conic_to' emitter during |
192 | * FT_Outline_Decompose(). It checks a conic Bezier curve with the |
193 | * current bounding box, and computes its extrema if necessary to |
194 | * update it. |
195 | * |
196 | * @Input: |
197 | * control :: |
198 | * A pointer to a control point. |
199 | * |
200 | * to :: |
201 | * A pointer to the destination vector. |
202 | * |
203 | * @InOut: |
204 | * user :: |
205 | * The address of the current walk context. |
206 | * |
207 | * @Return: |
208 | * Always 0. Needed for the interface only. |
209 | * |
210 | * @Note: |
211 | * In the case of a non-monotonous arc, we compute directly the |
212 | * extremum coordinates, as it is sufficiently fast. |
213 | */ |
214 | FT_CALLBACK_DEF( int ) |
215 | BBox_Conic_To( const FT_Vector* control, |
216 | const FT_Vector* to, |
217 | void* user_ ) |
218 | { |
219 | TBBox_Rec* user = (TBBox_Rec*)user_; |
220 | |
221 | |
222 | /* in case `to' is implicit and not included in bbox yet */ |
223 | FT_UPDATE_BBOX( to, user->bbox ); |
224 | |
225 | if ( CHECK_X( control, user->bbox ) ) |
226 | BBox_Conic_Check( user->last.x, |
227 | control->x, |
228 | to->x, |
229 | &user->bbox.xMin, |
230 | &user->bbox.xMax ); |
231 | |
232 | if ( CHECK_Y( control, user->bbox ) ) |
233 | BBox_Conic_Check( user->last.y, |
234 | control->y, |
235 | to->y, |
236 | &user->bbox.yMin, |
237 | &user->bbox.yMax ); |
238 | |
239 | user->last = *to; |
240 | |
241 | return 0; |
242 | } |
243 | |
244 | |
245 | /************************************************************************** |
246 | * |
247 | * @Function: |
248 | * BBox_Cubic_Check |
249 | * |
250 | * @Description: |
251 | * Find the extrema of a 1-dimensional cubic Bezier curve and |
252 | * update a bounding range. This version uses iterative splitting |
253 | * because it is faster than the exact solution with square roots. |
254 | * |
255 | * @Input: |
256 | * p1 :: |
257 | * The start coordinate. |
258 | * |
259 | * p2 :: |
260 | * The coordinate of the first control point. |
261 | * |
262 | * p3 :: |
263 | * The coordinate of the second control point. |
264 | * |
265 | * p4 :: |
266 | * The end coordinate. |
267 | * |
268 | * @InOut: |
269 | * min :: |
270 | * The address of the current minimum. |
271 | * |
272 | * max :: |
273 | * The address of the current maximum. |
274 | */ |
275 | static FT_Pos |
276 | cubic_peak( FT_Pos q1, |
277 | FT_Pos q2, |
278 | FT_Pos q3, |
279 | FT_Pos q4 ) |
280 | { |
281 | FT_Pos peak = 0; |
282 | FT_Int shift; |
283 | |
284 | |
285 | /* This function finds a peak of a cubic segment if it is above 0 */ |
286 | /* using iterative bisection of the segment, or returns 0. */ |
287 | /* The fixed-point arithmetic of bisection is inherently stable */ |
288 | /* but may loose accuracy in the two lowest bits. To compensate, */ |
289 | /* we upscale the segment if there is room. Large values may need */ |
290 | /* to be downscaled to avoid overflows during bisection. */ |
291 | /* It is called with either q2 or q3 positive, which is necessary */ |
292 | /* for the peak to exist and avoids undefined FT_MSB. */ |
293 | |
294 | shift = 27 - FT_MSB( (FT_UInt32)( FT_ABS( q1 ) | |
295 | FT_ABS( q2 ) | |
296 | FT_ABS( q3 ) | |
297 | FT_ABS( q4 ) ) ); |
298 | |
299 | if ( shift > 0 ) |
300 | { |
301 | /* upscaling too much just wastes time */ |
302 | if ( shift > 2 ) |
303 | shift = 2; |
304 | |
305 | q1 *= 1 << shift; |
306 | q2 *= 1 << shift; |
307 | q3 *= 1 << shift; |
308 | q4 *= 1 << shift; |
309 | } |
310 | else |
311 | { |
312 | q1 >>= -shift; |
313 | q2 >>= -shift; |
314 | q3 >>= -shift; |
315 | q4 >>= -shift; |
316 | } |
317 | |
318 | /* for a peak to exist above 0, the cubic segment must have */ |
319 | /* at least one of its control off-points above 0. */ |
320 | while ( q2 > 0 || q3 > 0 ) |
321 | { |
322 | /* determine which half contains the maximum and split */ |
323 | if ( q1 + q2 > q3 + q4 ) /* first half */ |
324 | { |
325 | q4 = q4 + q3; |
326 | q3 = q3 + q2; |
327 | q2 = q2 + q1; |
328 | q4 = q4 + q3; |
329 | q3 = q3 + q2; |
330 | q4 = ( q4 + q3 ) >> 3; |
331 | q3 = q3 >> 2; |
332 | q2 = q2 >> 1; |
333 | } |
334 | else /* second half */ |
335 | { |
336 | q1 = q1 + q2; |
337 | q2 = q2 + q3; |
338 | q3 = q3 + q4; |
339 | q1 = q1 + q2; |
340 | q2 = q2 + q3; |
341 | q1 = ( q1 + q2 ) >> 3; |
342 | q2 = q2 >> 2; |
343 | q3 = q3 >> 1; |
344 | } |
345 | |
346 | /* check whether either end reached the maximum */ |
347 | if ( q1 == q2 && q1 >= q3 ) |
348 | { |
349 | peak = q1; |
350 | break; |
351 | } |
352 | if ( q3 == q4 && q2 <= q4 ) |
353 | { |
354 | peak = q4; |
355 | break; |
356 | } |
357 | } |
358 | |
359 | if ( shift > 0 ) |
360 | peak >>= shift; |
361 | else |
362 | peak <<= -shift; |
363 | |
364 | return peak; |
365 | } |
366 | |
367 | |
368 | static void |
369 | BBox_Cubic_Check( FT_Pos p1, |
370 | FT_Pos p2, |
371 | FT_Pos p3, |
372 | FT_Pos p4, |
373 | FT_Pos* min, |
374 | FT_Pos* max ) |
375 | { |
376 | /* This function is only called when a control off-point is outside */ |
377 | /* the bbox that contains all on-points. So at least one of the */ |
378 | /* conditions below holds and cubic_peak is called with at least one */ |
379 | /* non-zero argument. */ |
380 | |
381 | if ( p2 > *max || p3 > *max ) |
382 | *max += cubic_peak( p1 - *max, p2 - *max, p3 - *max, p4 - *max ); |
383 | |
384 | /* now flip the signs to update the minimum */ |
385 | if ( p2 < *min || p3 < *min ) |
386 | *min -= cubic_peak( *min - p1, *min - p2, *min - p3, *min - p4 ); |
387 | } |
388 | |
389 | |
390 | /************************************************************************** |
391 | * |
392 | * @Function: |
393 | * BBox_Cubic_To |
394 | * |
395 | * @Description: |
396 | * This function is used as a `cubic_to' emitter during |
397 | * FT_Outline_Decompose(). It checks a cubic Bezier curve with the |
398 | * current bounding box, and computes its extrema if necessary to |
399 | * update it. |
400 | * |
401 | * @Input: |
402 | * control1 :: |
403 | * A pointer to the first control point. |
404 | * |
405 | * control2 :: |
406 | * A pointer to the second control point. |
407 | * |
408 | * to :: |
409 | * A pointer to the destination vector. |
410 | * |
411 | * @InOut: |
412 | * user :: |
413 | * The address of the current walk context. |
414 | * |
415 | * @Return: |
416 | * Always 0. Needed for the interface only. |
417 | * |
418 | * @Note: |
419 | * In the case of a non-monotonous arc, we don't compute directly |
420 | * extremum coordinates, we subdivide instead. |
421 | */ |
422 | FT_CALLBACK_DEF( int ) |
423 | BBox_Cubic_To( const FT_Vector* control1, |
424 | const FT_Vector* control2, |
425 | const FT_Vector* to, |
426 | void* user_ ) |
427 | { |
428 | TBBox_Rec* user = (TBBox_Rec*)user_; |
429 | |
430 | |
431 | /* We don't need to check `to' since it is always an on-point, */ |
432 | /* thus within the bbox. Only segments with an off-point outside */ |
433 | /* the bbox can possibly reach new extreme values. */ |
434 | |
435 | if ( CHECK_X( control1, user->bbox ) || |
436 | CHECK_X( control2, user->bbox ) ) |
437 | BBox_Cubic_Check( user->last.x, |
438 | control1->x, |
439 | control2->x, |
440 | to->x, |
441 | &user->bbox.xMin, |
442 | &user->bbox.xMax ); |
443 | |
444 | if ( CHECK_Y( control1, user->bbox ) || |
445 | CHECK_Y( control2, user->bbox ) ) |
446 | BBox_Cubic_Check( user->last.y, |
447 | control1->y, |
448 | control2->y, |
449 | to->y, |
450 | &user->bbox.yMin, |
451 | &user->bbox.yMax ); |
452 | |
453 | user->last = *to; |
454 | |
455 | return 0; |
456 | } |
457 | |
458 | |
459 | FT_DEFINE_OUTLINE_FUNCS( |
460 | bbox_interface, |
461 | |
462 | (FT_Outline_MoveTo_Func) BBox_Move_To, /* move_to */ |
463 | (FT_Outline_LineTo_Func) BBox_Line_To, /* line_to */ |
464 | (FT_Outline_ConicTo_Func)BBox_Conic_To, /* conic_to */ |
465 | (FT_Outline_CubicTo_Func)BBox_Cubic_To, /* cubic_to */ |
466 | 0, /* shift */ |
467 | 0 /* delta */ |
468 | ) |
469 | |
470 | |
471 | /* documentation is in ftbbox.h */ |
472 | |
473 | FT_EXPORT_DEF( FT_Error ) |
474 | FT_Outline_Get_BBox( FT_Outline* outline, |
475 | FT_BBox *abbox ) |
476 | { |
477 | FT_BBox cbox = { 0x7FFFFFFFL, 0x7FFFFFFFL, |
478 | -0x7FFFFFFFL, -0x7FFFFFFFL }; |
479 | FT_BBox bbox = { 0x7FFFFFFFL, 0x7FFFFFFFL, |
480 | -0x7FFFFFFFL, -0x7FFFFFFFL }; |
481 | FT_Vector* vec; |
482 | FT_UShort n; |
483 | |
484 | |
485 | if ( !abbox ) |
486 | return FT_THROW( Invalid_Argument ); |
487 | |
488 | if ( !outline ) |
489 | return FT_THROW( Invalid_Outline ); |
490 | |
491 | /* if outline is empty, return (0,0,0,0) */ |
492 | if ( outline->n_points == 0 || outline->n_contours <= 0 ) |
493 | { |
494 | abbox->xMin = abbox->xMax = 0; |
495 | abbox->yMin = abbox->yMax = 0; |
496 | |
497 | return 0; |
498 | } |
499 | |
500 | /* We compute the control box as well as the bounding box of */ |
501 | /* all `on' points in the outline. Then, if the two boxes */ |
502 | /* coincide, we exit immediately. */ |
503 | |
504 | vec = outline->points; |
505 | |
506 | for ( n = 0; n < outline->n_points; n++ ) |
507 | { |
508 | FT_UPDATE_BBOX( vec, cbox ); |
509 | |
510 | if ( FT_CURVE_TAG( outline->tags[n] ) == FT_CURVE_TAG_ON ) |
511 | FT_UPDATE_BBOX( vec, bbox ); |
512 | |
513 | vec++; |
514 | } |
515 | |
516 | /* test two boxes for equality */ |
517 | if ( cbox.xMin < bbox.xMin || cbox.xMax > bbox.xMax || |
518 | cbox.yMin < bbox.yMin || cbox.yMax > bbox.yMax ) |
519 | { |
520 | /* the two boxes are different, now walk over the outline to */ |
521 | /* get the Bezier arc extrema. */ |
522 | |
523 | FT_Error error; |
524 | TBBox_Rec user; |
525 | |
526 | |
527 | user.bbox = bbox; |
528 | |
529 | error = FT_Outline_Decompose( outline, &bbox_interface, &user ); |
530 | if ( error ) |
531 | return error; |
532 | |
533 | *abbox = user.bbox; |
534 | } |
535 | else |
536 | *abbox = bbox; |
537 | |
538 | return FT_Err_Ok; |
539 | } |
540 | |
541 | |
542 | /* END */ |
543 | |