rgraves
/
freetype2
forked from minhngoc25a/freetype2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
freetype2/src/base/ftbbox.c

433 lines
17 KiB
C
Raw Normal View History

- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
/***************************************************************************/
/* */
/* ftbbox.c */
/* */
/* FreeType bbox computation (body). */
/* */
/* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
/* modified and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
Some formatting. Fixed some data types/added header files to remove compiler warnings. Added trivial input data check to FT_Outline_Get_BBox(). Fixed type1z -> type1 file inclusions.
2000-10-26 12:04:16 +02:00
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
/*************************************************************************/
/* */
/* This component has a _single_ role: to compute exact outline bounding */
/* boxes. */
/* */
/*************************************************************************/
#include <freetype/ftbbox.h>
#include <freetype/ftimage.h>
#include <freetype/ftoutln.h>
Some formatting. Fixed some data types/added header files to remove compiler warnings. Added trivial input data check to FT_Outline_Get_BBox(). Fixed type1z -> type1 file inclusions.
2000-10-26 12:04:16 +02:00
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
typedef struct TBBox_Rec_
{
FT_Vector last;
FT_BBox bbox;
} TBBox_Rec;
/*************************************************************************/
/* */
/* <Function> */
/* BBox_Move_To */
/* */
/* <Description> */
/* This function is used as a `move_to' and `line_to' emitter during */
Some formatting. Fixed some data types/added header files to remove compiler warnings. Added trivial input data check to FT_Outline_Get_BBox(). Fixed type1z -> type1 file inclusions.
2000-10-26 12:04:16 +02:00
/* FT_Outline_Decompose(). It simply records the destination point */
Remove redundant code; fix computation of `last'.
2000-11-03 08:34:29 +01:00
/* in `user->last'; no further computations are necessary since we */
/* the cbox as the starting bbox which must be refined. */
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
/* */
/* <Input> */
/* to :: A pointer to the destination vector. */
/* */
/* <InOut> */
/* user :: A pointer to the current walk context. */
/* */
/* <Return> */
Some formatting. Fixed some data types/added header files to remove compiler warnings. Added trivial input data check to FT_Outline_Get_BBox(). Fixed type1z -> type1 file inclusions.
2000-10-26 12:04:16 +02:00
/* Always 0. Needed for the interface only. */
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
/* */
static
int BBox_Move_To( FT_Vector* to,
TBBox_Rec* user )
{
user->last = *to;
return 0;
}
#define CHECK_X( p, bbox ) \
( p->x < bbox.xMin || p->x > bbox.xMax )
#define CHECK_Y( p, bbox ) \
( p->y < bbox.yMin || p->y > bbox.yMax )
/*************************************************************************/
/* */
/* <Function> */
/* BBox_Conic_Check */
/* */
/* <Description> */
/* Finds the extrema of a 1-dimensional conic Bezier curve and update */
/* a bounding range. This version uses direct computation, as it */
/* doesn't need square roots. */
/* */
/* <Input> */
/* y1 :: The start coordinate. */
/* y2 :: The coordinate of the control point. */
/* y3 :: The end coordinate. */
/* */
/* <InOut> */
/* min :: The address of the current minimum. */
/* max :: The address of the current maximum. */
/* */
static
void BBox_Conic_Check( FT_Pos y1,
FT_Pos y2,
FT_Pos y3,
FT_Pos* min,
FT_Pos* max )
{
Remove redundant code; fix computation of `last'.
2000-11-03 08:34:29 +01:00
if ( y1 == y3 )
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
{
if ( y2 == y1 ) /* Flat arc */
goto Suite;
}
else if ( y1 < y3 )
{
if ( y2 >= y1 && y2 <= y3 ) /* Ascending arc */
goto Suite;
}
else
{
if ( y2 >= y3 && y2 <= y1 ) /* Descending arc */
{
y2 = y1;
y1 = y3;
y3 = y2;
goto Suite;
}
}
y1 = y3 = FT_MulDiv( y2 - y1, y2 - y1, y1 - 2*y2 + y3 );
Suite:
if ( y1 < *min ) *min = y1;
if ( y3 > *max ) *max = y3;
}
/*************************************************************************/
/* */
/* <Function> */
/* BBox_Conic_To */
/* */
/* <Description> */
/* This function is used as a `conic_to' emitter during */
/* FT_Raster_Decompose(). It checks a conic Bezier curve with the */
/* current bounding box, and computes its extrema if necessary to */
/* update it. */
/* */
/* <Input> */
/* control :: A pointer to a control point. */
/* to :: A pointer to the destination vector. */
/* */
/* <InOut> */
/* user :: The address of the current walk context. */
/* */
/* <Return> */
Some formatting. Fixed some data types/added header files to remove compiler warnings. Added trivial input data check to FT_Outline_Get_BBox(). Fixed type1z -> type1 file inclusions.
2000-10-26 12:04:16 +02:00
/* Always 0. Needed for the interface only. */
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
/* */
/* <Note> */
/* In the case of a non-monotonous arc, we compute directly the */
/* extremum coordinates, as it is sufficiently fast. */
/* */
static
int BBox_Conic_To( FT_Vector* control,
FT_Vector* to,
TBBox_Rec* user )
{
removed redundant checks.
2000-11-04 10:41:45 +01:00
/* we don't need to check `to' since it is always an `on' point, thus */
/* within the bbox */
if ( CHECK_X( control, user->bbox ) )
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
BBox_Conic_Check( user->last.x,
control->x,
to->x,
&user->bbox.xMin,
&user->bbox.xMax );
removed redundant checks.
2000-11-04 10:41:45 +01:00
if ( CHECK_Y( control, user->bbox ) )
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
BBox_Conic_Check( user->last.y,
control->y,
to->y,
&user->bbox.yMin,
&user->bbox.yMax );
Remove redundant code; fix computation of `last'.
2000-11-03 08:34:29 +01:00
user->last = *to;
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
return 0;
}
/*************************************************************************/
/* */
/* <Function> */
/* BBox_Cubic_Check */
/* */
/* <Description> */
/* Finds the extrema of a 1-dimensional cubic Bezier curve and */
/* updates a bounding range. This version uses splitting because we */
/* don't want to use square roots and extra accuracies. */
/* */
/* <Input> */
/* p1 :: The start coordinate. */
/* p2 :: The coordinate of the first control point. */
/* p3 :: The coordinate of the second control point. */
/* p4 :: The end coordinate. */
/* */
/* <InOut> */
/* min :: The address of the current minimum. */
/* max :: The address of the current maximum. */
/* */
static
void BBox_Cubic_Check( FT_Pos p1,
FT_Pos p2,
FT_Pos p3,
FT_Pos p4,
FT_Pos* min,
FT_Pos* max )
{
FT_Pos stack[33], *arc;
arc = stack;
arc[0] = p1;
arc[1] = p2;
arc[2] = p3;
arc[3] = p4;
do
{
FT_Pos y1 = arc[0];
FT_Pos y2 = arc[1];
FT_Pos y3 = arc[2];
FT_Pos y4 = arc[3];
if ( y1 == y4 )
{
if ( y1 == y2 && y1 == y3 ) /* Flat */
goto Test;
}
else if ( y1 < y4 )
{
if ( y2 >= y1 && y2 <= y4 && y3 >= y1 && y3 <= y4 ) /* Ascending */
goto Test;
}
else
{
if ( y2 >= y4 && y2 <= y1 && y3 >= y4 && y3 <= y1 ) /* Descending */
{
y2 = y1;
y1 = y4;
y4 = y2;
goto Test;
}
}
/* Unknown direction, split the arc in two */
arc[6] = y4;
arc[1] = y1 = ( y1 + y2 ) / 2;
arc[5] = y4 = ( y4 + y3 ) / 2;
y2 = ( y2 + y3 ) / 2;
arc[2] = y1 = ( y1 + y2 ) / 2;
arc[4] = y4 = ( y4 + y2 ) / 2;
arc[3] = ( y1 + y4 ) / 2;
arc += 3;
goto Suite;
Test:
if ( y1 < *min ) *min = y1;
if ( y4 > *max ) *max = y4;
arc -= 3;
Suite:
;
Some formatting. Fixed some data types/added header files to remove compiler warnings. Added trivial input data check to FT_Outline_Get_BBox(). Fixed type1z -> type1 file inclusions.
2000-10-26 12:04:16 +02:00
} while ( arc >= stack );
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
}
/*************************************************************************/
/* */
/* <Function> */
/* BBox_Cubic_To */
/* */
/* <Description> */
/* This function is used as a `cubic_to' emitter during */
/* FT_Raster_Decompose(). It checks a cubic Bezier curve with the */
/* current bounding box, and computes its extrema if necessary to */
/* update it. */
/* */
/* <Input> */
/* control1 :: A pointer to the first control point. */
/* control2 :: A pointer to the second control point. */
/* to :: A pointer to the destination vector. */
/* */
/* <InOut> */
/* user :: The address of the current walk context. */
/* */
/* <Return> */
Some formatting. Fixed some data types/added header files to remove compiler warnings. Added trivial input data check to FT_Outline_Get_BBox(). Fixed type1z -> type1 file inclusions.
2000-10-26 12:04:16 +02:00
/* Always 0. Needed for the interface only. */
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
/* */
/* <Note> */
/* In the case of a non-monotonous arc, we don't compute directly */
/* extremum coordinates, we subdivise instead. */
/* */
static
int BBox_Cubic_To( FT_Vector* control1,
FT_Vector* control2,
FT_Vector* to,
TBBox_Rec* user )
{
removed redundant checks.
2000-11-04 10:41:45 +01:00
/* we don't need to check `to' since it is always an `on' point, thus */
/* within the bbox */
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
if ( CHECK_X( control1, user->bbox ) ||
removed redundant checks.
2000-11-04 10:41:45 +01:00
CHECK_X( control2, user->bbox ) )
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
BBox_Cubic_Check( user->last.x,
control1->x,
control2->x,
to->x,
&user->bbox.xMin,
&user->bbox.xMax );
if ( CHECK_Y( control1, user->bbox ) ||
removed redundant checks.
2000-11-04 10:41:45 +01:00
CHECK_Y( control2, user->bbox ) )
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
BBox_Cubic_Check( user->last.y,
control1->y,
control2->y,
to->y,
&user->bbox.yMin,
&user->bbox.yMax );
Remove redundant code; fix computation of `last'.
2000-11-03 08:34:29 +01:00
user->last = *to;
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
return 0;
}
All function comments are now removed from source files (and moved to the header files if necessary). Some minor fixes to have `make multi' run successfully (with gcc and g++). Fixing compiler warnings.
2000-11-07 18:21:11 +01:00
/* documentation is in ftbbox.h */
major reformatting of the sources: FT_EXPORT_DEF => FT_EXPORT FT_EXPORT_FUNC => FT_EXPORT_DEF BASE_DEF => FT_BASE BASE_FUNC => FT_BASE_DEF LOCAL_DEF => FT_LOCAL LOCAL_FUNC => FT_LOCAL_DEF LOCAL_FUNC_X => FT_CALLBACK_DEF LOCAL_DEF_X => FT_CALLBACK_TABLE FT_CPLUSPLUS => FT_CALLBACK_TABLE_DEF
2000-11-04 02:55:49 +01:00
FT_EXPORT_DEF( FT_Error ) FT_Outline_Get_BBox( FT_Outline* outline,
Complementing David's changes with formatting, adding documentation, etc. More `*'-convention formatting, adding the `a' resp. `an' prefix to variables.
2000-11-07 07:30:29 +01:00
FT_BBox *abbox )
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
{
Some formatting. Fixed some data types/added header files to remove compiler warnings. Added trivial input data check to FT_Outline_Get_BBox(). Fixed type1z -> type1 file inclusions.
2000-10-26 12:04:16 +02:00
FT_BBox cbox;
FT_BBox bbox;
FT_Vector* vec;
FT_UShort n;
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
Some formatting. Fixed some data types/added header files to remove compiler warnings. Added trivial input data check to FT_Outline_Get_BBox(). Fixed type1z -> type1 file inclusions.
2000-10-26 12:04:16 +02:00
if ( !abbox )
return FT_Err_Invalid_Argument;
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
if ( !outline )
return FT_Err_Invalid_Outline;
Some formatting. Fixed some data types/added header files to remove compiler warnings. Added trivial input data check to FT_Outline_Get_BBox(). Fixed type1z -> type1 file inclusions.
2000-10-26 12:04:16 +02:00
/* if outline is empty, return (0,0,0,0) */
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
if ( outline->n_points == 0 || outline->n_contours <= 0 )
{
abbox->xMin = abbox->xMax = 0;
abbox->yMin = abbox->yMax = 0;
return 0;
}
/* We compute the control box as well as the bounding box of */
/* all `on' points in the outline. Then, if the two boxes */
/* coincide, we exit immediately. */
vec = outline->points;
bbox.xMin = bbox.xMax = cbox.xMin = cbox.xMax = vec->x;
bbox.yMin = bbox.yMax = cbox.yMin = cbox.yMax = vec->y;
for ( n = 1; n < outline->n_points; n++ )
{
FT_Pos x = vec->x;
FT_Pos y = vec->y;
/* update control box */
if ( x < cbox.xMin ) cbox.xMin = x;
if ( x > cbox.xMax ) cbox.xMax = x;
if ( y < cbox.yMin ) cbox.yMin = y;
if ( y > cbox.yMax ) cbox.yMax = y;
if ( FT_CURVE_TAG( outline->tags[n] ) == FT_Curve_Tag_On )
{
/* update bbox for `on' points only */
if ( x < bbox.xMin ) bbox.xMin = x;
if ( x > bbox.xMax ) bbox.xMax = x;
if ( y < bbox.yMin ) bbox.yMin = y;
if ( y > bbox.yMax ) bbox.yMax = y;
}
vec++;
}
/* test two boxes for equality */
if ( cbox.xMin < bbox.xMin || cbox.xMax > bbox.xMax ||
cbox.yMin < bbox.yMin || cbox.yMax > bbox.yMax )
{
/* the two boxes are different, now walk over the outline to */
/* get the Bezier arc extrema. */
static const FT_Outline_Funcs interface =
{
(FT_Outline_MoveTo_Func) BBox_Move_To,
(FT_Outline_LineTo_Func) BBox_Move_To,
(FT_Outline_ConicTo_Func)BBox_Conic_To,
minor fixes. Add more gcc warnings for development on UNIX.
2000-11-06 00:41:08 +01:00
(FT_Outline_CubicTo_Func)BBox_Cubic_To,
0, 0
- reviving the "ftbbox" component, used to compute exact bounding box computations - minor update to docmaker.py, more is coming
2000-10-26 02:06:35 +02:00
};
FT_Error error;
TBBox_Rec user;
user.bbox = bbox;
error = FT_Outline_Decompose( outline, &interface, &user );
if ( error )
return error;
*abbox = user.bbox;
}
else
*abbox = bbox;
return FT_Err_Ok;
}
/* END */