Edit
kc3-lang/freetype/src/base/ftsynth.c
Werner Lemberg
- src/base/ftsynth.c
-
/***************************************************************************/ /* */ /* 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 */