| /***************************************************************************/ |
| /* */ |
| /* ftsynth.c */ |
| /* */ |
| /* FreeType synthesizing code for emboldening and slanting (body). */ |
| /* */ |
| /* Copyright 2000-2001 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. */ |
| /* */ |
| /***************************************************************************/ |
| |
| |
| #include <ft2build.h> |
| #include FT_INTERNAL_OBJECTS_H |
| #include FT_INTERNAL_CALC_H |
| #include FT_OUTLINE_H |
| #include FT_SYNTHESIS_H |
| |
| |
| #define FT_BOLD_THRESHOLD 0x0100 |
| |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /**** ****/ |
| /**** EXPERIMENTAL OBLIQUING SUPPORT ****/ |
| /**** ****/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| FT_EXPORT_DEF( FT_Error ) |
| FT_Outline_Oblique( FT_GlyphSlot original, |
| FT_Outline* outline, |
| FT_Pos* advance ) |
| { |
| FT_Matrix transform; |
| |
| FT_UNUSED( original ); |
| /* we don't touch the advance width */ |
| FT_UNUSED( advance ); |
| |
| |
| |
| /* For italic, simply apply a shear transform, with an angle */ |
| /* of about 12 degrees. */ |
| |
| transform.xx = 0x10000L; |
| transform.yx = 0x00000L; |
| |
| transform.xy = 0x06000L; |
| transform.yy = 0x10000L; |
| |
| FT_Outline_Transform( outline, &transform ); |
| |
| return 0; |
| } |
| |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /**** ****/ |
| /**** EXPERIMENTAL EMBOLDENING/OUTLINING SUPPORT ****/ |
| /**** ****/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| |
| /* Compute the norm of a vector */ |
| |
| #ifdef FT_CONFIG_OPTION_OLD_CALCS |
| |
| static FT_Pos |
| ft_norm( FT_Vector* vec ) |
| { |
| FT_Int64 t1, t2; |
| |
| |
| MUL_64( vec->x, vec->x, t1 ); |
| MUL_64( vec->y, vec->y, t2 ); |
| ADD_64( t1, t2, t1 ); |
| |
| return (FT_Pos)SQRT_64( t1 ); |
| } |
| |
| #else /* FT_CONFIG_OPTION_OLD_CALCS */ |
| |
| static FT_Pos |
| ft_norm( FT_Vector* vec ) |
| { |
| FT_F26Dot6 u, v, d; |
| FT_Int shift; |
| FT_ULong H, L, L2, hi, lo, med; |
| |
| |
| u = vec->x; if ( u < 0 ) u = -u; |
| v = vec->y; if ( v < 0 ) v = -v; |
| |
| if ( u < v ) |
| { |
| d = u; |
| u = v; |
| v = d; |
| } |
| |
| /* check that we are not trying to normalize zero! */ |
| if ( u == 0 ) |
| return 0; |
| |
| /* compute (u*u + v*v) on 64 bits with two 32-bit registers [H:L] */ |
| hi = (FT_ULong)u >> 16; |
| lo = (FT_ULong)u & 0xFFFF; |
| med = hi * lo; |
| |
| H = hi * hi + ( med >> 15 ); |
| med <<= 17; |
| L = lo * lo + med; |
| if ( L < med ) |
| H++; |
| |
| hi = (FT_ULong)v >> 16; |
| lo = (FT_ULong)v & 0xFFFF; |
| med = hi * lo; |
| |
| H += hi * hi + ( med >> 15 ); |
| med <<= 17; |
| L2 = lo * lo + med; |
| if ( L2 < med ) |
| H++; |
| |
| L += L2; |
| if ( L < L2 ) |
| H++; |
| |
| /* if the value is smaller than 32 bits */ |
| shift = 0; |
| if ( H == 0 ) |
| { |
| while ( ( L & 0xC0000000UL ) == 0 ) |
| { |
| L <<= 2; |
| shift++; |
| } |
| return ( FT_Sqrt32( L ) >> shift ); |
| } |
| else |
| { |
| while ( H ) |
| { |
| L = ( L >> 2 ) | ( H << 30 ); |
| H >>= 2; |
| shift++; |
| } |
| return ( FT_Sqrt32( L ) << shift ); |
| } |
| } |
| |
| #endif /* FT_CONFIG_OPTION_OLD_CALCS */ |
| |
| |
| static int |
| ft_test_extrema( FT_Outline* outline, |
| int n ) |
| { |
| FT_Vector *prev, *cur, *next; |
| FT_Pos product; |
| FT_Int c, first, last; |
| |
| |
| /* we need to compute the `previous' and `next' point */ |
| /* for these extrema. */ |
| cur = outline->points + n; |
| prev = cur - 1; |
| next = cur + 1; |
| |
| first = 0; |
| for ( c = 0; c < outline->n_contours; c++ ) |
| { |
| last = outline->contours[c]; |
| |
| if ( n == first ) |
| prev = outline->points + last; |
| |
| if ( n == last ) |
| next = outline->points + first; |
| |
| first = last + 1; |
| } |
| |
| product = FT_MulDiv( cur->x - prev->x, /* in.x */ |
| next->y - cur->y, /* out.y */ |
| 0x40 ) |
| - |
| FT_MulDiv( cur->y - prev->y, /* in.y */ |
| next->x - cur->x, /* out.x */ |
| 0x40 ); |
| |
| if ( product ) |
| product = product > 0 ? 1 : -1; |
| |
| return product; |
| } |
| |
| |
| /* Compute the orientation of path filling. It differs between TrueType */ |
| /* and Type1 formats. We could use the `ft_outline_reverse_fill' flag, */ |
| /* but it is better to re-compute it directly (it seems that this flag */ |
| /* isn't correctly set for some weird composite glyphs currently). */ |
| /* */ |
| /* We do this by computing bounding box points, and computing their */ |
| /* curvature. */ |
| /* */ |
| /* The function returns either 1 or -1. */ |
| /* */ |
| static int |
| ft_get_orientation( FT_Outline* outline ) |
| { |
| FT_BBox box; |
| FT_BBox indices; |
| int n, last; |
| |
| |
| indices.xMin = -1; |
| indices.yMin = -1; |
| indices.xMax = -1; |
| indices.yMax = -1; |
| |
| box.xMin = box.yMin = 32767; |
| box.xMax = box.yMax = -32768; |
| |
| /* is it empty ? */ |
| if ( outline->n_contours < 1 ) |
| return 1; |
| |
| last = outline->contours[outline->n_contours - 1]; |
| |
| for ( n = 0; n <= last; n++ ) |
| { |
| FT_Pos x, y; |
| |
| |
| x = outline->points[n].x; |
| if ( x < box.xMin ) |
| { |
| box.xMin = x; |
| indices.xMin = n; |
| } |
| if ( x > box.xMax ) |
| { |
| box.xMax = x; |
| indices.xMax = n; |
| } |
| |
| y = outline->points[n].y; |
| if ( y < box.yMin ) |
| { |
| box.yMin = y; |
| indices.yMin = n; |
| } |
| if ( y > box.yMax ) |
| { |
| box.yMax = y; |
| indices.yMax = n; |
| } |
| } |
| |
| /* test orientation of the xmin */ |
| n = ft_test_extrema( outline, indices.xMin ); |
| if ( n ) |
| goto Exit; |
| |
| n = ft_test_extrema( outline, indices.yMin ); |
| if ( n ) |
| goto Exit; |
| |
| n = ft_test_extrema( outline, indices.xMax ); |
| if ( n ) |
| goto Exit; |
| |
| n = ft_test_extrema( outline, indices.yMax ); |
| if ( !n ) |
| n = 1; |
| |
| Exit: |
| return n; |
| } |
| |
| |
| FT_EXPORT_DEF( FT_Error ) |
| FT_Outline_Embolden( FT_GlyphSlot original, |
| FT_Outline* outline, |
| FT_Pos* advance ) |
| { |
| FT_Vector u, v; |
| FT_Vector* points; |
| FT_Vector cur, prev, next; |
| FT_Pos distance; |
| FT_Face face = FT_SLOT_FACE( original ); |
| int c, n, first, orientation; |
| |
| FT_UNUSED( advance ); |
| |
| |
| /* compute control distance */ |
| distance = FT_MulFix( face->units_per_EM / 60, |
| face->size->metrics.y_scale ); |
| |
| orientation = ft_get_orientation( &original->outline ); |
| |
| points = original->outline.points; |
| |
| first = 0; |
| for ( c = 0; c < outline->n_contours; c++ ) |
| { |
| int last = outline->contours[c]; |
| |
| |
| prev = points[last]; |
| |
| for ( n = first; n <= last; n++ ) |
| { |
| FT_Pos norm, delta, d; |
| FT_Vector in, out; |
| |
| |
| cur = points[n]; |
| if ( n < last ) next = points[n + 1]; |
| else next = points[first]; |
| |
| /* compute the in and out vectors */ |
| in.x = cur.x - prev.x; |
| in.y = cur.y - prev.y; |
| |
| out.x = next.x - cur.x; |
| out.y = next.y - cur.y; |
| |
| /* compute U and V */ |
| norm = ft_norm( &in ); |
| u.x = orientation * FT_DivFix( in.y, norm ); |
| u.y = orientation * -FT_DivFix( in.x, norm ); |
| |
| norm = ft_norm( &out ); |
| v.x = orientation * FT_DivFix( out.y, norm ); |
| v.y = orientation * -FT_DivFix( out.x, norm ); |
| |
| d = distance; |
| |
| if ( ( outline->tags[n] & FT_Curve_Tag_On ) == 0 ) |
| d *= 2; |
| |
| /* Check discriminant for parallel vectors */ |
| delta = FT_MulFix( u.x, v.y ) - FT_MulFix( u.y, v.x ); |
| if ( delta > FT_BOLD_THRESHOLD || delta < -FT_BOLD_THRESHOLD ) |
| { |
| /* Move point -- compute A and B */ |
| FT_Pos x, y, A, B; |
| |
| |
| A = d + FT_MulFix( cur.x, u.x ) + FT_MulFix( cur.y, u.y ); |
| B = d + FT_MulFix( cur.x, v.x ) + FT_MulFix( cur.y, v.y ); |
| |
| x = FT_MulFix( A, v.y ) - FT_MulFix( B, u.y ); |
| y = FT_MulFix( B, u.x ) - FT_MulFix( A, v.x ); |
| |
| outline->points[n].x = distance + FT_DivFix( x, delta ); |
| outline->points[n].y = distance + FT_DivFix( y, delta ); |
| } |
| else |
| { |
| /* Vectors are nearly parallel */ |
| FT_Pos x, y; |
| |
| |
| x = distance + cur.x + FT_MulFix( d, u.x + v.x ) / 2; |
| y = distance + cur.y + FT_MulFix( d, u.y + v.y ) / 2; |
| |
| outline->points[n].x = x; |
| outline->points[n].y = y; |
| } |
| |
| prev = cur; |
| } |
| |
| first = last + 1; |
| } |
| |
| if ( advance ) |
| *advance = ( *advance + distance * 4 ) & -64; |
| |
| return 0; |
| } |
| |
| |
| /* END */ |
