diff options
Diffstat (limited to 'Build/source/texk/dvisvgm/dvisvgm-src/libs/ff-woff/fontforge/stemdb.c')
-rw-r--r-- | Build/source/texk/dvisvgm/dvisvgm-src/libs/ff-woff/fontforge/stemdb.c | 6068 |
1 files changed, 0 insertions, 6068 deletions
diff --git a/Build/source/texk/dvisvgm/dvisvgm-src/libs/ff-woff/fontforge/stemdb.c b/Build/source/texk/dvisvgm/dvisvgm-src/libs/ff-woff/fontforge/stemdb.c deleted file mode 100644 index bdded86c222..00000000000 --- a/Build/source/texk/dvisvgm/dvisvgm-src/libs/ff-woff/fontforge/stemdb.c +++ /dev/null @@ -1,6068 +0,0 @@ -/* Copyright (C) 2005-2012 by George Williams and Alexey Kryukov */ -/* - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. - - * The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO - * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -#include "fontforge.h" -#include "edgelist2.h" -#include "stemdb.h" - -#include <math.h> -#include <utype.h> - -#define GLYPH_DATA_DEBUG 0 -#define PI 3.14159265358979323846264338327 - -/* A diagonal end is like the top or bottom of a slash. Should we add a vertical stem at the end? */ -/* A diagonal corner is like the bottom of circumflex. Should we add a horizontal stem? */ -int hint_diagonal_ends = 0, - hint_diagonal_intersections = 0, - hint_bounding_boxes = 1, - detect_diagonal_stems = 0; - -float stem_slope_error = .05061454830783555773, /* 2.9 degrees */ - stub_slope_error = .317649923862967983; /* 18.2 degrees */ - -static double dist_error_hv = 3.5; -static double dist_error_diag = 5.5; -/* It's easy to get horizontal/vertical lines aligned properly */ -/* it is more difficult to get diagonal ones done */ -/* The "A" glyph in Apple's Times.dfont(Roman) is off by 6 in one spot */ -static double dist_error_curve = 22; -/* The maximum possible distance between the edge of an active zone for */ -/* a curved spline segment and the spline itself */ - -struct st { - Spline *s; - double st, lt; -}; - -static int GetBlueFuzz(SplineFont *sf) { - char *str, *end; - - if ( sf == NULL || sf->private == NULL || - (str=PSDictHasEntry( sf->private,"BlueFuzz" )) == NULL || !isdigit( str[0] )) -return 1; -return strtod( str, &end ); -} - -static int IsUnitHV( BasePoint *unit,int strict ) { - double angle = atan2( unit->y,unit->x ); - double deviation = ( strict ) ? stem_slope_error : stub_slope_error; - - if ( fabs( angle ) >= PI/2 - deviation && fabs( angle ) <= PI/2 + deviation ) -return( 2 ); - else if ( fabs( angle ) <= deviation || fabs( angle ) >= PI - deviation ) -return( 1 ); - -return( 0 ); -} - -static int UnitCloserToHV( BasePoint *u1,BasePoint *u2 ) { - double adiff1, adiff2; - - adiff1 = fabs( atan2( u1->y,u1->x )); - adiff2 = fabs( atan2( u2->y,u2->x )); - - if ( adiff1 > PI*.25 && adiff1 < PI*.75 ) - adiff1 = fabs( adiff1 - PI*.5 ); - else if ( adiff1 >= PI*.75 ) - adiff1 = PI - adiff1; - - if ( adiff2 > PI*.25 && adiff2 < PI*.75 ) - adiff2 = fabs( adiff2 - PI*.5 ); - else if ( adiff2 >= PI*.75 ) - adiff2 = PI - adiff2; - - if ( adiff1 < adiff2 ) -return( 1 ); - else if ( adiff1 > adiff2 ) -return( -1 ); - else -return( 0 ); -} - -static double GetUnitAngle( BasePoint *u1,BasePoint *u2 ) { - double dx, dy; - - dy = u1->x*u2->y - u1->y*u2->x; - dx = u1->x*u2->x + u1->y*u2->y; -return( atan2( dy,dx )); -} - -static int UnitsOrthogonal( BasePoint *u1,BasePoint *u2,int strict ) { - double angle, deviation = ( strict ) ? stem_slope_error : stub_slope_error; - - angle = GetUnitAngle( u1,u2 ); - -return( fabs( angle ) >= PI/2 - deviation && fabs( angle ) <= PI/2 + deviation ); -} - -int UnitsParallel( BasePoint *u1,BasePoint *u2,int strict ) { - double angle, deviation = ( strict ) ? stem_slope_error : stub_slope_error; - - angle = GetUnitAngle( u1,u2 ); - -return( fabs( angle ) <= deviation || fabs( angle ) >= PI - deviation ); -} - -static int IsInflectionPoint( struct glyphdata *gd,struct pointdata *pd ) { - SplinePoint *sp = pd->sp; - double CURVATURE_THRESHOLD = 1e-9; - struct spline *prev, *next; - double in, out; - - if ( sp->prev == NULL || sp->next == NULL || !pd->colinear ) -return( false ); - - /* point of a single-point contour can't be an inflection point. */ - if ( sp->prev->from == sp ) -return( false ); - - prev = sp->prev; - in = 0; - while ( prev != NULL && fabs(in) < CURVATURE_THRESHOLD ) { - in = SplineCurvature( prev,1 ); - if ( fabs( in ) < CURVATURE_THRESHOLD ) in = SplineCurvature( prev, 0 ); - if ( fabs( in ) < CURVATURE_THRESHOLD ) prev = prev->from->prev; - if ( gd->points[prev->to->ptindex].colinear ) - break; - } - - next = sp->next; - out = 0; - while ( next != NULL && fabs( out ) < CURVATURE_THRESHOLD ) { - out = SplineCurvature( next,0 ); - if ( fabs( out ) < CURVATURE_THRESHOLD ) out = SplineCurvature( next, 1 ); - if ( fabs( out ) < CURVATURE_THRESHOLD ) next = next->to->next; - if ( gd->points[next->from->ptindex].colinear ) - break; - } - - if ( in==0 || out==0 || ( prev != sp->prev && next != sp->next )) -return( false ); - - in/=fabs(in); - out/=fabs(out); - -return ( in*out < 0 ); -} - -static int SplineFigureOpticalSlope(Spline *s,int start_at_from,BasePoint *dir) { - /* Sometimes splines have tiny control points, and to the eye the slope */ - /* of the spline has nothing to do with that specified by the cps. */ - /* So see if the spline is straightish and figure the slope based on */ - /* some average direction */ - /* dir is a input output parameter. */ - /* it should be initialized to the unit vector determined by the appropriate cp */ - /* if the function returns true, it will be set to a unit vector in the average direction */ - BasePoint pos, *base, average_dir, normal; - double t, len, incr, off; - double dx, dy, ax, ay, d, a; - - /* The vector is already nearly vertical/horizontal, no need to modify*/ - if ( IsUnitHV( dir,true )) -return( false ); - - if ( start_at_from ) { - incr = -.1; - base = &s->from->me; - } else { - incr = .1; - base = &s->to->me; - } - - t = .5-incr; - memset(&average_dir,0,sizeof(average_dir)); - while ( t>0 && t<1.0 ) { - pos.x = ((s->splines[0].a*t+s->splines[0].b)*t+s->splines[0].c)*t+s->splines[0].d; - pos.y = ((s->splines[1].a*t+s->splines[1].b)*t+s->splines[1].c)*t+s->splines[1].d; - - average_dir.x += (pos.x-base->x); average_dir.y += (pos.y-base->y); - t += incr; - } - - len = sqrt( pow( average_dir.x,2 ) + pow( average_dir.y,2 )); - if ( len==0 ) -return( false ); - average_dir.x /= len; average_dir.y /= len; - normal.x = average_dir.y; normal.y = - average_dir.x; - - t = .5-incr; - while ( t>0 && t<1.0 ) { - pos.x = ((s->splines[0].a*t+s->splines[0].b)*t+s->splines[0].c)*t+s->splines[0].d; - pos.y = ((s->splines[1].a*t+s->splines[1].b)*t+s->splines[1].c)*t+s->splines[1].d; - off = (pos.x-base->x)*normal.x + (pos.y-base->y)*normal.y; - if ( off<-dist_error_hv || off>dist_error_hv ) -return( false ); - t += incr; - } - - if ( UnitsParallel( dir,&normal,true )) { - /* prefer the direction which is closer to horizontal/vertical */ - if ( (dx=dir->x)<0 ) dx = -dx; - if ( (dy=dir->y)<0 ) dy = -dy; - d = (dx<dy) ? dx : dy; - if ( (ax=average_dir.x)<0 ) ax = -ax; - if ( (ay=average_dir.y)<0 ) ay = -ay; - a = (ax<ay) ? ax : ay; - if ( d<a ) -return( false ); - } - - *dir = average_dir; -return( true ); -} - -static int IsSplinePeak( struct glyphdata *gd,struct pointdata *pd,int outer,int is_x,int flags ); - -static void PointInit( struct glyphdata *gd,SplinePoint *sp, SplineSet *ss ) { - struct pointdata *pd, *prevpd=NULL, *nextpd=NULL; - double len, same; - int hv; - - if ( sp->ptindex >= gd->pcnt ) -return; - pd = &gd->points[sp->ptindex]; - pd->sp = sp; - pd->ss = ss; - pd->x_extr = pd->y_extr = 0; - pd->base = sp->me; - pd->ttfindex = sp->ttfindex; - pd->nextcnt = pd->prevcnt = 0; - pd->nextstems = pd->prevstems = NULL; - pd->next_is_l = pd->prev_is_l = NULL; - - if ( !sp->nonextcp && gd->order2 && sp->nextcpindex < gd->realcnt ) { - - nextpd = &gd->points[sp->nextcpindex]; - nextpd->ss = ss; - nextpd->x_extr = nextpd->y_extr = 0; - nextpd->base = sp->nextcp; - nextpd->ttfindex = sp->nextcpindex; - } - if ( !sp->noprevcp && gd->order2 && sp->prev != NULL && - sp->prev->from->nextcpindex < gd->realcnt ) { - - nextpd = &gd->points[sp->prev->from->nextcpindex]; - nextpd->ss = ss; - nextpd->x_extr = nextpd->y_extr = 0; - nextpd->base = sp->prevcp; - nextpd->ttfindex = sp->prev->from->nextcpindex; - } - - if ( sp->next==NULL ) { - pd->nextunit.x = ss->first->me.x - sp->me.x; - pd->nextunit.y = ss->first->me.y - sp->me.y; - pd->nextlinear = true; - } else if ( sp->next->knownlinear ) { - pd->nextunit.x = sp->next->to->me.x - sp->me.x; - pd->nextunit.y = sp->next->to->me.y - sp->me.y; - pd->nextlinear = true; - } else if ( sp->nonextcp ) { - pd->nextunit.x = sp->next->to->prevcp.x - sp->me.x; - pd->nextunit.y = sp->next->to->prevcp.y - sp->me.y; - } else { - pd->nextunit.x = sp->nextcp.x - sp->me.x; - pd->nextunit.y = sp->nextcp.y - sp->me.y; - } - len = sqrt( pow( pd->nextunit.x,2 ) + pow( pd->nextunit.y,2 )); - if ( len==0 ) - pd->nextzero = true; - else { - pd->nextlen = len; - pd->nextunit.x /= len; - pd->nextunit.y /= len; - if ( sp->next!=NULL && !sp->next->knownlinear ) - SplineFigureOpticalSlope(sp->next,true,&pd->nextunit); - hv = IsUnitHV( &pd->nextunit,true ); - if ( hv == 2 ) { - pd->nextunit.x = 0; pd->nextunit.y = pd->nextunit.y>0 ? 1 : -1; - } else if ( hv == 1 ) { - pd->nextunit.y = 0; pd->nextunit.x = pd->nextunit.x>0 ? 1 : -1; - } - if ( pd->nextunit.y==0 ) pd->next_hor = true; - else if ( pd->nextunit.x==0 ) pd->next_ver = true; - - if ( nextpd != NULL ) { - nextpd->prevunit.x = -pd->nextunit.x; - nextpd->prevunit.y = -pd->nextunit.y; - } - } - - if ( sp->prev==NULL ) { - pd->prevunit.x = ss->last->me.x - sp->me.x; - pd->prevunit.y = ss->last->me.y - sp->me.y; - pd->prevlinear = true; - } else if ( sp->prev->knownlinear ) { - pd->prevunit.x = sp->prev->from->me.x - sp->me.x; - pd->prevunit.y = sp->prev->from->me.y - sp->me.y; - pd->prevlinear = true; - } else if ( sp->noprevcp ) { - pd->prevunit.x = sp->prev->from->nextcp.x - sp->me.x; - pd->prevunit.y = sp->prev->from->nextcp.y - sp->me.y; - } else { - pd->prevunit.x = sp->prevcp.x - sp->me.x; - pd->prevunit.y = sp->prevcp.y - sp->me.y; - } - len = sqrt( pow( pd->prevunit.x,2 ) + pow( pd->prevunit.y,2 )); - if ( len==0 ) - pd->prevzero = true; - else { - pd->prevlen = len; - pd->prevunit.x /= len; - pd->prevunit.y /= len; - if ( sp->prev!=NULL && !sp->prev->knownlinear ) - SplineFigureOpticalSlope(sp->prev,false,&pd->prevunit); - hv = IsUnitHV( &pd->prevunit,true ); - if ( hv == 2 ) { - pd->prevunit.x = 0; pd->prevunit.y = pd->prevunit.y>0 ? 1 : -1; - } else if ( hv == 1 ) { - pd->prevunit.y = 0; pd->prevunit.x = pd->prevunit.x>0 ? 1 : -1; - } - if ( pd->prevunit.y==0 ) pd->prev_hor = true; - else if ( pd->prevunit.x==0 ) pd->prev_ver = true; - - if ( prevpd != NULL ) { - prevpd->nextunit.x = -pd->prevunit.x; - prevpd->nextunit.y = -pd->prevunit.y; - } - } - { - same = pd->prevunit.x*pd->nextunit.x + pd->prevunit.y*pd->nextunit.y; - if ( same<-.95 ) - pd->colinear = true; - } - if (( pd->prev_hor || pd->next_hor ) && pd->colinear ) { - if ( IsSplinePeak( gd,pd,false,false,1 )) pd->y_extr = 1; - else if ( IsSplinePeak( gd,pd,true,false,1 )) pd->y_extr = 2; - } else if (( pd->prev_ver || pd->next_ver ) && pd->colinear ) { - if ( IsSplinePeak( gd,pd,true,true,1 )) pd->x_extr = 1; - else if ( IsSplinePeak( gd,pd,false,true,1 )) pd->x_extr = 2; - } else { - if (( pd->nextunit.y < 0 && pd->prevunit.y < 0 ) || ( pd->nextunit.y > 0 && pd->prevunit.y > 0 )) { - if ( IsSplinePeak( gd,pd,false,false,2 )) pd->y_corner = 1; - else if ( IsSplinePeak( gd,pd,true,false,2 )) pd->y_corner = 2; - } - if (( pd->nextunit.x < 0 && pd->prevunit.x < 0 ) || ( pd->nextunit.x > 0 && pd->prevunit.x > 0 )) { - if ( IsSplinePeak( gd,pd,true,true,2 )) pd->x_corner = 1; - else if ( IsSplinePeak( gd,pd,false,true,2 )) pd->x_corner = 2; - } - } - if ( hint_diagonal_intersections ) { - if (( pd->y_corner || pd->y_extr ) && - RealNear( pd->nextunit.x,-pd->prevunit.x ) && - RealNear( pd->nextunit.y,pd->prevunit.y ) && !pd->nextzero) - pd->symetrical_h = true; - else if (( pd->x_corner || pd->x_extr ) && - RealNear( pd->nextunit.y,-pd->prevunit.y ) && - RealNear( pd->nextunit.x,pd->prevunit.x ) && !pd->nextzero) - pd->symetrical_v = true; - } -} - -static int BBoxIntersectsLine(Spline *s,Spline *line) { - double t,x,y; - DBounds b; - - b.minx = b.maxx = s->from->me.x; - b.miny = b.maxy = s->from->me.y; - if ( s->to->me.x<b.minx ) b.minx = s->to->me.x; - else if ( s->to->me.x>b.maxx ) b.maxx = s->to->me.x; - if ( s->to->me.y<b.miny ) b.miny = s->to->me.y; - else if ( s->to->me.y>b.maxy ) b.maxy = s->to->me.y; - if ( s->to->prevcp.x<b.minx ) b.minx = s->to->prevcp.x; - else if ( s->to->prevcp.x>b.maxx ) b.maxx = s->to->prevcp.x; - if ( s->to->prevcp.y<b.miny ) b.miny = s->to->prevcp.y; - else if ( s->to->prevcp.y>b.maxy ) b.maxy = s->to->prevcp.y; - if ( s->from->nextcp.x<b.minx ) b.minx = s->from->nextcp.x; - else if ( s->from->nextcp.x>b.maxx ) b.maxx = s->from->nextcp.x; - if ( s->from->nextcp.y<b.miny ) b.miny = s->from->nextcp.y; - else if ( s->from->nextcp.y>b.maxy ) b.maxy = s->from->nextcp.y; - - if ( line->splines[0].c!=0 ) { - t = (b.minx-line->splines[0].d)/line->splines[0].c; - y = line->splines[1].c*t+line->splines[1].d; - if ( y>=b.miny && y<=b.maxy ) -return( true ); - t = (b.maxx-line->splines[0].d)/line->splines[0].c; - y = line->splines[1].c*t+line->splines[1].d; - if ( y>=b.miny && y<=b.maxy ) -return( true ); - } - if ( line->splines[1].c!=0 ) { - t = (b.miny-line->splines[1].d)/line->splines[1].c; - x = line->splines[0].c*t+line->splines[0].d; - if ( x>=b.minx && x<=b.maxx ) -return( true ); - t = (b.maxy-line->splines[1].d)/line->splines[1].c; - x = line->splines[0].c*t+line->splines[0].d; - if ( x>=b.minx && x<=b.maxx ) -return( true ); - } -return( false ); -} - -static int stcmp(const void *_p1, const void *_p2) { - const struct st *stpt1 = _p1, *stpt2 = _p2; - if ( stpt1->lt>stpt2->lt ) -return( 1 ); - else if ( stpt1->lt<stpt2->lt ) -return( -1 ); - -return( 0 ); -} - -static int line_pt_cmp( const void *_p1, const void *_p2 ) { - struct pointdata * const *pd1 = _p1, * const *pd2 = _p2; - struct linedata *line; - double ppos1=0,ppos2=0; - - if ( (*pd1)->prevline != NULL && - ( (*pd1)->prevline == (*pd2)->prevline || (*pd1)->prevline == (*pd2)->nextline )) - line = (*pd1)->prevline; - else if ( (*pd1)->nextline != NULL && - ( (*pd1)->nextline == (*pd2)->prevline || (*pd1)->nextline == (*pd2)->nextline )) - line = (*pd1)->nextline; - else -return( 0 ); - - ppos1 = ( (*pd1)->sp->me.x - line->online.x ) * line->unit.x + - ( (*pd1)->sp->me.y - line->online.y ) * line->unit.y; - ppos2 = ( (*pd2)->sp->me.x - line->online.x ) * line->unit.x + - ( (*pd2)->sp->me.y - line->online.y ) * line->unit.y; - - if ( ppos1>ppos2 ) -return( 1 ); - else if ( ppos1<ppos2 ) -return( -1 ); - else -return( 0 ); -} - -static int segment_cmp(const void *_s1, const void *_s2) { - const struct segment *s1 = _s1, *s2 = _s2; - if ( s1->start<s2->start ) -return( -1 ); - else if ( s1->start>s2->start ) -return( 1 ); - -return( 0 ); -} - -static int proj_cmp(const void *_p1, const void *_p2) { - struct pointdata * const *p1 = _p1, * const *p2 = _p2; - if ( (*p1)->projection<(*p2)->projection ) -return( -1 ); - else if ( (*p1)->projection>(*p2)->projection ) -return( 1 ); - -return( 0 ); -} - -static void AssignStemToPoint( struct pointdata *pd,struct stemdata *stem,int is_next, int left ) { - struct stemdata ***stems; - int i, *stemcnt, **is_l; - - stems = ( is_next ) ? &pd->nextstems : &pd->prevstems; - stemcnt = ( is_next ) ? &pd->nextcnt : &pd->prevcnt; - is_l = ( is_next ) ? &pd->next_is_l : &pd->prev_is_l; - for ( i=0; i<*stemcnt; i++ ) { - if ((*stems)[i] == stem ) -return; - } - - *stems = realloc( *stems,( *stemcnt+1 )*sizeof( struct stemdata *)); - *is_l = realloc( *is_l, ( *stemcnt+1 )*sizeof( int )); - (*stems)[*stemcnt] = stem; - (*is_l )[*stemcnt] = left; - (*stemcnt)++; -} - -int IsStemAssignedToPoint( struct pointdata *pd,struct stemdata *stem,int is_next ) { - struct stemdata **stems; - int i, stemcnt; - - stems = ( is_next ) ? pd->nextstems : pd->prevstems; - stemcnt = ( is_next ) ? pd->nextcnt : pd->prevcnt; - - for ( i=0; i<stemcnt; i++ ) { - if ( stems[i] == stem ) -return( i ); - } -return( -1 ); -} - -static int GetValidPointDataIndex( struct glyphdata *gd,SplinePoint *sp, - struct stemdata *stem ) { - - struct pointdata *tpd; - - if ( sp == NULL ) -return( -1 ); - if ( sp->ttfindex < gd->realcnt ) -return( sp->ttfindex ); - if ( !sp->nonextcp && sp->nextcpindex < gd->realcnt ) { - tpd = &gd->points[sp->nextcpindex]; - if ( IsStemAssignedToPoint( tpd,stem,false ) != -1 ) -return( sp->nextcpindex ); - } - if ( !sp->noprevcp && sp->prev != NULL && - sp->prev->from->nextcpindex < gd->realcnt ) { - tpd = &gd->points[sp->prev->from->nextcpindex]; - if ( IsStemAssignedToPoint( tpd,stem,true ) != -1 ) -return( sp->prev->from->nextcpindex ); - } -return( -1 ); -} - -static int LineType(struct st *st,int i, int cnt,Spline *line) { - SplinePoint *sp; - BasePoint nextcp, prevcp, here; - double dn, dp; - - if ( st[i].st>.01 && st[i].st<.99 ) -return( 0 ); /* Not near an end-point, just a normal line */ - if ( i+1>=cnt ) -return( 0 ); /* No following spline */ - if ( st[i+1].st>.01 && st[i+1].st<.99 ) -return( 0 ); /* Following spline not near an end-point, can't */ - /* match to this one, just a normal line */ - if ( st[i].st<.5 && st[i+1].st>.5 ) { - if ( st[i+1].s->to->next!=st[i].s ) -return( 0 ); - sp = st[i].s->from; - } else if ( st[i].st>.5 && st[i+1].st<.5 ) { - if ( st[i].s->to->next!=st[i+1].s ) -return( 0 ); - sp = st[i].s->to; - } else -return( 0 ); - - if ( !sp->nonextcp ) - nextcp = sp->nextcp; - else - nextcp = sp->next->to->me; - if ( !sp->noprevcp ) - prevcp = sp->prevcp; - else - prevcp = sp->prev->from->me; - here.x = line->splines[0].c*(st[i].st+st[i+1].st)/2 + line->splines[0].d; - here.y = line->splines[1].c*(st[i].st+st[i+1].st)/2 + line->splines[1].d; - - nextcp.x -= here.x; nextcp.y -= here.y; - prevcp.x -= here.x; prevcp.y -= here.y; - - dn = nextcp.x*line->splines[1].c - nextcp.y*line->splines[0].c; - dp = prevcp.x*line->splines[1].c - prevcp.y*line->splines[0].c; - if ( dn*dp<0 ) /* splines away move on opposite sides of the line */ -return( 1 ); /* Treat this line and the next as one */ - /* We assume that a rounding error gave us one erroneous intersection (or we went directly through the endpoint) */ - else -return( 2 ); /* Ignore both this line and the next */ - /* Intersects both in a normal fashion */ -} - -static int MonotonicOrder(Spline **sspace,Spline *line,struct st *stspace) { - Spline *s; - int i,j,k,cnt; - BasePoint pts[9]; - extended lts[10], sts[10]; - - for ( i=j=0; (s=sspace[j])!=NULL; ++j ) { - if ( BBoxIntersectsLine(s,line) ) { - /* Lines parallel to the direction we are testing just get in the */ - /* way and don't add any useful info */ - if ( s->islinear && - RealNear(line->splines[0].c*s->splines[1].c, - line->splines[1].c*s->splines[0].c)) - continue; - if ( SplinesIntersect(line,s,pts,lts,sts)<=0 ) - continue; - for ( k=0; sts[k]!=-1; ++k ) { - if ( sts[k]>=0 && sts[k]<=1 ) { - stspace[i].s = s; - stspace[i].lt = lts[k]; - stspace[i++].st = sts[k]; - } - } - } - } - stspace[i].s = NULL; - cnt = i; - qsort(stspace,cnt,sizeof(struct st),stcmp); -return( cnt ); -} - -static Spline *MonotonicFindAlong(Spline *line,struct st *stspace,int cnt, - Spline *findme, double *other_t) { - Spline *s; - int i; - int eo; /* I do horizontal/vertical by winding number */ - /* But figuring winding number with respect to a */ - /* diagonal line is hard. So I use even-odd */ - /* instead. */ - - eo = 0; - for ( i=0; i<cnt; ++i ) { - s = stspace[i].s; - if ( s==findme ) { - if ( (eo&1) && i>0 ) { - *other_t = stspace[i-1].st; -return( stspace[i-1].s ); - } else if ( !(eo&1) && i+1<cnt ) { - *other_t = stspace[i+1].st; -return( stspace[i+1].s ); - } - fprintf( stderr, "MonotonicFindAlong: Ran out of intersections.\n" ); -return( NULL ); - } - if ( i+1<cnt && stspace[i+1].s==findme ) - ++eo; - else switch ( LineType(stspace,i,cnt,line) ) { - case 0: /* Normal spline */ - ++eo; - break; - case 1: /* Intersects at end-point & next entry is other side */ - ++eo; /* And the two sides continue in approximately the */ - ++i; /* same direction */ - break; - case 2: /* Intersects at end-point & next entry is other side */ - ++i; /* And the two sides go in opposite directions */ - break; - default: - break; -} - } - fprintf( stderr, "MonotonicFindAlong: Never found our spline.\n" ); -return( NULL ); -} - -static int MonotonicFindStemBounds(Spline *line,struct st *stspace,int cnt, - double fudge,struct stemdata *stem ) { - int i,j; - int eo; /* I do horizontal/vertical by winding number */ - /* But figuring winding number with respect to a */ - /* diagonal line is hard. So I use even-odd */ - /* instead. */ - double pos, npos; - double lmin = ( stem->lmin < -fudge ) ? stem->lmin : -fudge; - double lmax = ( stem->lmax > fudge ) ? stem->lmax : fudge; - double rmin = ( stem->rmin < -fudge ) ? stem->rmin : -fudge; - double rmax = ( stem->rmax > fudge ) ? stem->rmax : fudge; - lmin -= .0001; lmax += .0001; rmin -= .0001; rmax += .0001; - - eo = 0; - for ( i=0; i<cnt; ++i ) { - pos = (line->splines[0].c*stspace[i].lt + line->splines[0].d - stem->left.x)*stem->l_to_r.x + - (line->splines[1].c*stspace[i].lt + line->splines[1].d - stem->left.y)*stem->l_to_r.y; - npos = 1e4; - if ( i+1<cnt ) - npos = (line->splines[0].c*stspace[i+1].lt + line->splines[0].d - stem->left.x)*stem->l_to_r.x + - (line->splines[1].c*stspace[i+1].lt + line->splines[1].d - stem->left.y)*stem->l_to_r.y; - - if ( pos>=lmin && pos<=lmax ) { - if ( (eo&1) && i>0 ) - j = i-1; - else if ( !(eo&1) && i+1<cnt ) - j = i+1; - else -return( false ); - pos = (line->splines[0].c*stspace[j].lt + line->splines[0].d - stem->right.x)*stem->l_to_r.x + - (line->splines[1].c*stspace[j].lt + line->splines[1].d - stem->right.y)*stem->l_to_r.y; - if ( pos >= rmin && pos <= rmax ) -return( true ); - } - if ( i+1 < cnt && npos >= lmin && npos <= lmax ) - ++eo; - else switch ( LineType(stspace,i,cnt,line) ) { - case 0: /* Normal spline */ - ++eo; - break; - case 1: /* Intersects at end-point & next entry is other side */ - ++eo; /* And the two sides continue in approximately the */ - ++i; /* same direction */ - break; - case 2: /* Intersects at end-point & next entry is other side */ - ++i; /* And the two sides go in opposite directions */ - break; - default: - break; - } - } -return( false ); -} - -static int MatchWinding(struct monotonic ** space,int i,int nw,int winding,int which,int idx) { - struct monotonic *m; - int j,cnt=0; - - if (( nw<0 && winding>0 ) || (nw>0 && winding<0)) { - winding = nw; - for ( j=i-1; j>=0; --j ) { - m = space[j]; - winding += ((&m->xup)[which] ? 1 : -1 ); - if ( winding==0 ) { - if ( cnt == idx ) -return( j ); - cnt++; - } - } - } else { - winding = nw; - for ( j=i+1; space[j]!=NULL; ++j ) { - m = space[j]; - winding += ((&m->xup)[which] ? 1 : -1 ); - if ( winding==0 ) { - if ( cnt == idx ) -return( j ); - cnt++; - } - } - } -return( -1 ); -} - -static int FindMatchingHVEdge( struct glyphdata *gd,struct pointdata *pd, - int is_next,Spline **edges,double *other_t,double *dist ) { - - double test, t, start, end; - int which; - Spline *s; - Monotonic *m; - int winding, nw, i, j, ret=0; - struct monotonic **space; - BasePoint *dir, d, hv; - - /* Things are difficult if we go exactly through the point. Move off */ - /* to the side a tiny bit and hope that doesn't matter */ - if ( is_next==2 ) { - /* Consider the case of the bottom of the circumflex (or a chevron) */ - /* Think of it as a flattend breve. It is symetrical and we want to */ - /* note the vertical distance between the two points that define */ - /* the bottom, so treat them as a funky stem */ - /* \ \ / / */ - /* \ \ / / */ - /* \ \ / / */ - /* \ + / */ - /* \ / */ - /* + */ - hv.x = pd->symetrical_h ? 1.0 : 0.0; - hv.y = pd->symetrical_v ? 1.0 : 0.0; - dir = &hv; - t = .001; - s = pd->sp->next; /* Could just as easily be prev */ - } else if ( is_next ) { - s = pd->sp->next; - t = .001; - dir = &pd->nextunit; - } else { - s = pd->sp->prev; - t = .999; - dir = &pd->prevunit; - } - if (( d.x = dir->x )<0 ) d.x = -d.x; - if (( d.y = dir->y )<0 ) d.y = -d.y; - which = d.x<d.y; /* closer to vertical */ - - if ( s==NULL ) /* Somehow we got an open contour? */ -return( 0 ); - - test = ((s->splines[which].a*t+s->splines[which].b)*t+s->splines[which].c)*t+s->splines[which].d; - MonotonicFindAt(gd->ms,which,test,space = gd->space); - - winding = 0; - for ( i=0; space[i]!=NULL; ++i ) { - m = space[i]; - nw = ((&m->xup)[which] ? 1 : -1 ); - if ( m->s == s && t>=m->tstart && t<=m->tend ) { - start = m->other; - break; - } - winding += nw; - } - if ( space[i]==NULL ) { - fprintf( stderr, "FindMatchinHVEdge didn't\n" ); -return( 0 ); - } - - j = MatchWinding(space,i,nw,winding,which,0); - if ( j!=-1 ) { - other_t[0] = space[j]->t; - end = space[j]->other; - dist[0] = end - start; - if ( dist[0] < 0 ) dist[0] = -dist[0]; - edges[0] = space[j]->s; - ret++; - } - if ( ret > 0 && is_next != 2 && ( pd->x_extr == 1 || pd->y_extr == 1 )) { - j = MatchWinding(space,i,nw,winding,which,1); - if ( j!=-1 ) { - other_t[ret] = space[j]->t; - end = space[j]->other; - dist[ret] = end - start; - if ( dist[ret] < 0 ) dist[ret] = -dist[ret]; - edges[ret] = space[j]->s; - ret++; - } - } -return( ret ); -} - -static BasePoint PerturbAlongSpline( Spline *s,BasePoint *bp,double t ) { - BasePoint perturbed; - - for (;;) { - perturbed.x = ((s->splines[0].a*t+s->splines[0].b)*t+s->splines[0].c)*t+s->splines[0].d; - perturbed.y = ((s->splines[1].a*t+s->splines[1].b)*t+s->splines[1].c)*t+s->splines[1].d; - if ( !RealWithin( perturbed.x,bp->x,.01 ) || !RealWithin( perturbed.y,bp->y,.01 )) - break; - if ( t<.5 ) { - t *= 2; - if ( t>.5 ) - break; - } else { - t = 1- 2*(1-t); - if ( t<.5 ) - break; - } - } -return( perturbed ); -} - -static void MakeVirtualLine(struct glyphdata *gd,BasePoint *perturbed, - BasePoint *dir,Spline *myline,SplinePoint *end1, SplinePoint *end2) { - - BasePoint norm, absnorm; - SplineSet *spl; - Spline *s, *first; - double t1, t2; - int i, cnt; - - if ( gd->stspace==NULL ) { - for ( i=0; i<2; ++i ) { - cnt = 0; - for ( spl=gd->sc->layers[gd->layer].splines; spl!=NULL; spl=spl->next ) { - first = NULL; - if ( spl->first->prev!=NULL ) { - for ( s=spl->first->next; s!=first; s=s->to->next ) { - if ( first==NULL ) first = s; - if ( i ) - gd->sspace[cnt] = s; - ++cnt; - } - } - } - if ( !i ) { - gd->scnt = cnt; - gd->sspace = malloc((cnt+1)*sizeof(Spline *)); - } else - gd->sspace[cnt] = NULL; - } - gd->stspace = malloc((3*cnt+2)*sizeof(struct st)); - SplineCharFindBounds(gd->sc,&gd->size); - gd->size.minx -= 10; gd->size.miny -= 10; - gd->size.maxx += 10; gd->size.maxy += 10; - } - - norm.x = -dir->y; - norm.y = dir->x; - absnorm = norm; - if ( absnorm.x<0 ) absnorm.x = -absnorm.x; - if ( absnorm.y<0 ) absnorm.y = -absnorm.y; - - memset(myline,0,sizeof(*myline)); - memset(end1,0,sizeof(*end1)); - memset(end2,0,sizeof(*end2)); - myline->knownlinear = myline->islinear = true; - - if ( absnorm.x > absnorm.y ) { - /* Greater change in x than in y */ - t1 = (gd->size.minx-perturbed->x)/norm.x; - t2 = (gd->size.maxx-perturbed->x)/norm.x; - myline->splines[0].d = gd->size.minx; - myline->splines[0].c = gd->size.maxx-gd->size.minx; - myline->splines[1].d = perturbed->y+t1*norm.y; - myline->splines[1].c = (t2-t1)*norm.y; - } else { - t1 = (gd->size.miny-perturbed->y)/norm.y; - t2 = (gd->size.maxy-perturbed->y)/norm.y; - myline->splines[1].d = gd->size.miny; - myline->splines[1].c = gd->size.maxy-gd->size.miny; - myline->splines[0].d = perturbed->x+t1*norm.x; - myline->splines[0].c = (t2-t1)*norm.x; - } - end1->me.x = myline->splines[0].d; - end2->me.x = myline->splines[0].d + myline->splines[0].c; - end1->me.y = myline->splines[1].d; - end2->me.y = myline->splines[1].d + myline->splines[1].c; - end1->nextcp = end1->prevcp = end1->me; - end2->nextcp = end2->prevcp = end2->me; - end1->nonextcp = end1->noprevcp = end2->nonextcp = end2->noprevcp = true; - end1->next = myline; end2->prev = myline; - myline->from = end1; myline->to = end2; -} - -static int FindMatchingEdge( struct glyphdata *gd, struct pointdata *pd, - int is_next,Spline **edges ) { - - BasePoint *dir, vert, perturbed, diff; - Spline myline; - SplinePoint end1, end2; - double *other_t = is_next==2 ? &pd->both_e_t : is_next ? pd->next_e_t : pd->prev_e_t; - double *dist = is_next ? pd->next_dist : pd->prev_dist; - double t ; - Spline *s; - int cnt; - - dist[0] = 0; dist[1] = 0; - if (( is_next && ( pd->next_hor || pd->next_ver )) || - ( !is_next && ( pd->prev_hor || pd->prev_ver )) || - is_next == 2 ) -return( FindMatchingHVEdge(gd,pd,is_next,edges,other_t,dist)); - - if ( is_next ) { - dir = &pd->nextunit; - t = .001; - s = pd->sp->next; - } else { - dir = &pd->prevunit; - t = .999; - s = pd->sp->prev; - } - /* For spline segments which have slope close enough to the font's italic */ - /* slant look for an opposite edge along the horizontal direction, rather */ - /* than along the normal for the point's next/previous unit. This allows */ - /* us e. g. to detect serifs in italic fonts */ - if ( gd->has_slant ) { - if ( UnitsParallel( dir,&gd->slant_unit,true )) { - vert.x = 0; vert.y = 1; - dir = | - } - } - - if ( s==NULL || ( gd->only_hv && !IsUnitHV( dir,false ))) -return( 0 ); - - diff.x = s->to->me.x-s->from->me.x; diff.y = s->to->me.y-s->from->me.y; - if ( diff.x<.03 && diff.x>-.03 && diff.y<.03 && diff.y>-.03 ) -return( 0 ); - - /* Don't base the line on the current point, we run into rounding errors */ - /* where lines that should intersect it don't. Instead perturb it a tiny*/ - /* bit in the direction along the spline */ - perturbed = PerturbAlongSpline( s,&pd->sp->me,t ); - - MakeVirtualLine(gd,&perturbed,dir,&myline,&end1,&end2); - /* prev_e_t = next_e_t = both_e_t =. This is where these guys are set */ - cnt = MonotonicOrder(gd->sspace,&myline,gd->stspace); - edges[0] = MonotonicFindAlong(&myline,gd->stspace,cnt,s,other_t); -return( edges[0] != NULL ); -} - -static int StillStem(struct glyphdata *gd,double fudge,BasePoint *pos,struct stemdata *stem ) { - Spline myline; - SplinePoint end1, end2; - int cnt, ret; - - MakeVirtualLine( gd,pos,&stem->unit,&myline,&end1,&end2 ); - cnt = MonotonicOrder( gd->sspace,&myline,gd->stspace ); - ret = MonotonicFindStemBounds( &myline,gd->stspace,cnt,fudge,stem ); -return( ret ); -} - -static int CornerCorrectSide( struct pointdata *pd,int x_dir,int is_l ) { - int corner = ( x_dir ) ? pd->x_corner : pd->y_corner; - int start = (( x_dir && is_l ) || ( !x_dir && !is_l )); - double unit_p, unit_n; - - unit_p = (&pd->prevunit.x)[!x_dir]; - unit_n = (&pd->nextunit.x)[!x_dir]; -return( ( start && ( - ( corner == 1 && unit_p > 0 && unit_n > 0 ) || - ( corner == 2 && unit_p < 0 && unit_n < 0 ))) || - ( !start && ( - ( corner == 1 && unit_p < 0 && unit_n < 0 ) || - ( corner == 2 && unit_p > 0 && unit_n > 0 )))); -} - -static int IsCorrectSide( struct glyphdata *gd,struct pointdata *pd, - int is_next,int is_l,BasePoint *dir ) { - - Spline *sbase, myline; - SplinePoint *sp = pd->sp, end1, end2; - BasePoint perturbed; - int i, hv, is_x, ret = false, winding = 0, cnt, eo; - double t, test; - struct monotonic **space, *m; - - hv = IsUnitHV( dir,true ); - if (( hv == 2 && pd->x_corner ) || ( hv == 1 && pd->y_corner )) -return( CornerCorrectSide( pd,( hv == 2 ),is_l )); - - sbase = ( is_next ) ? sp->next : sp->prev; - t = ( is_next ) ? 0.001 : 0.999; - perturbed = PerturbAlongSpline( sbase,&sp->me,t ); - - if ( hv ) { - is_x = ( hv == 2 ); - test = ( is_x ) ? perturbed.y : perturbed.x; - MonotonicFindAt( gd->ms,is_x,test,space = gd->space ); - for ( i=0; space[i]!=NULL; ++i ) { - m = space[i]; - winding = ((&m->xup)[is_x] ? 1 : -1 ); - if ( m->s == sbase ) - break; - } - if ( space[i]!=NULL ) - ret = (( is_l && winding == 1 ) || ( !is_l && winding == -1 )); - } else { - MakeVirtualLine( gd,&perturbed,dir,&myline,&end1,&end2 ); - cnt = MonotonicOrder( gd->sspace,&myline,gd->stspace ); - eo = -1; - is_x = fabs( dir->y ) > fabs( dir->x ); - /* If a diagonal stem is more vertical than horizontal, then our */ - /* virtual line will go from left to right. It will first intersect */ - /* the left side of the stem, if the stem also points north-east. */ - /* In any other case the virtual line will first intersect the right */ - /* side. */ - i = ( is_x && dir->y > 0 ) ? 0 : cnt-1; - while ( i >= 0 && i <= cnt-1 ) { - eo = ( eo != 1 ) ? 1 : 0; - if ( gd->stspace[i].s == sbase ) - break; - if ( is_x && dir->y > 0 ) i++; - else i--; - } - ret = ( is_l == eo ); - } -return( ret ); -} - -/* In TrueType I want to make sure that everything on a diagonal line remains */ -/* on the same line. Hence we compute the line. Also we are interested in */ -/* points that are on the intersection of two lines */ -static struct linedata *BuildLine(struct glyphdata *gd,struct pointdata *pd,int is_next ) { - int i; - BasePoint *dir, *base, *start, *end; - struct pointdata **pspace = gd->pspace, *pd2; - int pcnt=0, is_l, hv; - double dist_error; - struct linedata *line; - double off, firstoff, lastoff, lmin=0, lmax=0; - - dir = is_next ? &pd->nextunit : &pd->prevunit; - is_l = IsCorrectSide( gd,pd,is_next,true,dir ); - dist_error = ( IsUnitHV( dir,true )) ? dist_error_hv : dist_error_diag ; /* Diagonals are harder to align */ - if ( dir->x==0 && dir->y==0 ) -return( NULL ); - base = &pd->sp->me; - - for ( i= (pd - gd->points)+1; i<gd->pcnt; ++i ) if ( gd->points[i].sp!=NULL ) { - pd2 = &gd->points[i]; - off = ( pd2->sp->me.x - base->x )*dir->y - - ( pd2->sp->me.y - base->y )*dir->x; - if ( off <= lmax - 2*dist_error || off >= lmin + 2*dist_error ) - continue; - if ( off < 0 && off < lmin ) lmin = off; - else if ( off > 0 && off > lmax ) lmax = off; - - if ((( UnitsParallel( dir,&pd2->nextunit,true ) && pd2->nextline==NULL ) && - IsCorrectSide( gd,pd2,true,is_l,dir )) || - (( UnitsParallel( dir,&pd2->prevunit,true ) && pd2->prevline==NULL ) && - IsCorrectSide( gd,pd2,false,is_l,dir ))) - pspace[pcnt++] = pd2; - } - - if ( pcnt==0 ) -return( NULL ); - if ( pcnt==1 ) { - /* if the line consists of just these two points, only count it as */ - /* a true line if the two immediately follow each other */ - if (( pd->sp->next->to != pspace[0]->sp || !pd->sp->next->knownlinear ) && - ( pd->sp->prev->from != pspace[0]->sp || !pd->sp->prev->knownlinear )) -return( NULL ); - } - - line = &gd->lines[gd->linecnt++]; - line->pcnt = pcnt+1; - line->points = malloc((pcnt+1)*sizeof(struct pointdata *)); - line->points[0] = pd; - line->unit = *dir; - line->is_left = is_l; - if ( dir->x < 0 || dir->y == -1 ) { - line->unit.x = -line->unit.x; - line->unit.y = -line->unit.y; - } - line->online = *base; - if ( is_next ) { - pd->nextline = line; - if ( pd->colinear ) pd->prevline = line; - } else { - pd->prevline = line; - if ( pd->colinear ) pd->nextline = line; - } - for ( i=0; i<pcnt; ++i ) { - if ( UnitsParallel( dir,&pspace[i]->nextunit,true ) && pspace[i]->nextline==NULL ) { - pspace[i]->nextline = line; - if ( pspace[i]->colinear ) - pspace[i]->prevline = line; - } - if ( UnitsParallel( dir,&pspace[i]->prevunit,true ) && pspace[i]->prevline==NULL ) { - pspace[i]->prevline = line; - if ( pspace[i]->colinear ) - pspace[i]->nextline = line; - } - line->points[i+1] = pspace[i]; - } - qsort( line->points,line->pcnt,sizeof( struct pointdata * ),line_pt_cmp ); - start = &line->points[0]->sp->me; - end = &line->points[pcnt]->sp->me; - /* Now recalculate the line unit vector basing on its starting and */ - /* terminal points */ - line->unit.x = ( end->x - start->x ); - line->unit.y = ( end->y - start->y ); - line->length = sqrt( pow( line->unit.x,2 ) + pow( line->unit.y,2 )); - line->unit.x /= line->length; - line->unit.y /= line->length; - hv = IsUnitHV( &line->unit,true ); - if ( hv == 2 ) { - line->unit.x = 0; line->unit.y = 1; - } else if ( hv == 1 ) { - line->unit.x = 1; line->unit.y = 0; - } else if ( gd->has_slant && UnitsParallel( &line->unit,&gd->slant_unit,true )) { - firstoff = ( start->x - base->x )*gd->slant_unit.y - - ( start->y - base->y )*gd->slant_unit.x; - lastoff = ( end->x - base->x )*gd->slant_unit.y - - ( end->y - base->y )*gd->slant_unit.x; - if ( fabs( firstoff ) < 2*dist_error && fabs( lastoff ) < 2*dist_error ) - line->unit = gd->slant_unit; - } -return( line ); -} - -static BasePoint MiddleUnit( BasePoint *unit1, BasePoint *unit2 ) { - BasePoint u1, u2, ret; - double hyp; - int hv; - - u1 = *unit1; u2 = *unit2; - if ( u1.x*u2.x + u1.y*u2.y < 0 ) { - u2.x = -u2.x; u2.y = -u2.y; - } - ret.x = ( u1.x + u2.x )/2; - ret.y = ( u1.y + u2.y )/2; - hyp = sqrt( pow( ret.x,2 ) + pow( ret.y,2 )); - ret.x /= hyp; - ret.y /= hyp; - - hv = IsUnitHV( &ret,true ); - if ( hv ) { - ret.x = ( hv == 1 ) ? 1 : 0; - ret.y = ( hv == 1 ) ? 0 : 1; - } -return( ret ); -} - -static uint8 IsStubOrIntersection( struct glyphdata *gd, BasePoint *dir1, - struct pointdata *pd1, struct pointdata *pd2, int is_next1, int is_next2 ) { - int i; - int exc=0; - double dist, off, ext, norm1, norm2, opp, angle; - double mid_err = ( stem_slope_error + stub_slope_error )/2; - SplinePoint *sp1, *sp2, *nsp; - BasePoint hvdir, *dir2, *odir1, *odir2; - struct pointdata *npd; - struct linedata *line; - - sp1 = pd1->sp; sp2 = pd2->sp; - dir2 = ( is_next2 ) ? &pd2->nextunit : &pd2->prevunit; - hvdir.x = ( int ) rint( dir1->x ); - hvdir.y = ( int ) rint( dir1->y ); - - line = is_next2 ? pd2->nextline : pd2->prevline; - if ( !IsUnitHV( dir2,true ) && line != NULL ) - dir2 = &line->unit; - - odir1 = ( is_next1 ) ? &pd1->prevunit : &pd1->nextunit; - odir2 = ( is_next2 ) ? &pd2->prevunit : &pd2->nextunit; - - angle = fabs( GetUnitAngle( dir1,dir2 )); - if ( angle > (double)stub_slope_error*1.5 && angle < PI - (double)stub_slope_error*1.5 ) -return( 0 ); - - /* First check if it is a slightly slanted line or a curve which joins */ - /* a straight line under an angle close to 90 degrees. There are many */ - /* glyphs where circles or curved features are intersected by or */ - /* connected to vertical or horizontal straight stems (the most obvious */ - /* cases are Greek Psi and Cyrillic Yu), and usually it is highly desired to */ - /* mark such an intersection with a hint */ - norm1 = ( sp1->me.x - sp2->me.x ) * odir2->x + - ( sp1->me.y - sp2->me.y ) * odir2->y; - norm2 = ( sp2->me.x - sp1->me.x ) * odir1->x + - ( sp2->me.y - sp1->me.y ) * odir1->y; - /* if this is a real stub or intersection, then vectors on both sides */ - /* of out going-to-be stem should point in the same direction. So */ - /* the following value should be positive */ - opp = dir1->x * dir2->x + dir1->y * dir2->y; - if (( angle <= mid_err || angle >= PI - mid_err ) && - opp > 0 && norm1 < 0 && norm2 < 0 && UnitsParallel( odir1,odir2,true ) && - ( UnitsOrthogonal( dir1,odir1,false ) || UnitsOrthogonal( dir2,odir1,false ))) -return( 2 ); - if (( angle <= mid_err || angle >= PI - mid_err ) && - opp > 0 && (( norm1 < 0 && pd1->colinear && - IsUnitHV( dir1,true ) && UnitsOrthogonal( dir1,odir2,false )) || - ( norm2 < 0 && pd2->colinear && - IsUnitHV( dir2,true ) && UnitsOrthogonal( dir2,odir1,false )))) -return( 4 ); - - /* Now check if our 2 points form a serif termination or a feature stub */ - /* The check is pretty dumb: it returns 'true' if all the following */ - /* conditions are met: */ - /* - both the points belong to the same contour; */ - /* - there are no more than 3 other points between them; */ - /* - anyone of those intermediate points is positioned by such a way */ - /* that it falls inside the stem formed by our 2 base point and */ - /* the vector we are checking and its distance from the first point */ - /* along that vector is not larger than the stem width; */ - /* - none of the intermediate points is parallel to the vector direction */ - /* (otherwise we should have checked against that point instead) */ - if ( !UnitsParallel( dir1,&hvdir,false )) -return( 0 ); - - dist = ( sp1->me.x - sp2->me.x ) * dir1->y - - ( sp1->me.y - sp2->me.y ) * dir1->x; - nsp = sp1; - - for ( i=0; i<4; i++ ) { - if (( is_next1 && nsp->prev == NULL ) || ( !is_next1 && nsp->next == NULL )) -return( 0 ); - - nsp = ( is_next1 ) ? nsp->prev->from : nsp->next->to; - if ( ( i>0 && nsp == sp1 ) || nsp == sp2 ) - break; - - npd = &gd->points[nsp->ptindex]; - if (UnitsParallel( &npd->nextunit,&hvdir,false ) || - UnitsParallel( &npd->prevunit,&hvdir,false )) - break; - - ext = ( sp1->me.x - nsp->me.x ) * hvdir.x + - ( sp1->me.y - nsp->me.y ) * hvdir.y; - if ( ext < 0 ) ext = -ext; - if (( dist > 0 && ext > dist ) || ( dist < 0 && ext < dist )) - break; - - off = ( sp1->me.x - nsp->me.x ) * hvdir.y - - ( sp1->me.y - nsp->me.y ) * hvdir.x; - if (( dist > 0 && ( off <= 0 || off >= dist )) || - ( dist < 0 && ( off >= 0 || off <= dist ))) - exc++; - } - - if ( nsp == sp2 && exc == 0 ) -return( 1 ); - -return( 0 ); -} - -/* We normalize all stem unit vectors so that they point between 90 and 270 */ -/* degrees, as this range is optimal for sorting diagonal stems. This means */ -/* that vertical stems will normally point top to bottom, but for diagonal */ -/* stems (even if their angle is actually very close to vertical) the opposite */ -/* direction is also possible. Sometimes we "normalize" such stems converting */ -/* them to vertical. In such a case we have to swap their edges too. */ -static void SwapEdges( struct glyphdata *gd,struct stemdata *stem ) { - BasePoint tpos; - struct pointdata *tpd; - struct linedata *tl; - struct stem_chunk *chunk; - double toff; - int i, j, temp; - - tpos = stem->left; stem->left = stem->right; stem->right = tpos; - toff = stem->lmin; stem->lmin = stem->rmax; stem->rmax = toff; - toff = stem->rmin; stem->rmin = stem->lmax; stem->lmax = toff; - tl = stem->leftline; stem->leftline = stem->rightline; stem->rightline = tl; - - for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - tpd = chunk->l; chunk->l = chunk->r; chunk->r = tpd; - temp = chunk->lpotential; chunk->lpotential = chunk->rpotential; chunk->rpotential = temp; - temp = chunk->lnext; chunk->lnext = chunk->rnext; chunk->rnext = temp; - temp = chunk->ltick; chunk->ltick = chunk->rtick; chunk->rtick = temp; - - tpd = chunk->l; - if ( tpd != NULL ) { - for ( j=0; j<tpd->nextcnt; j++ ) - if ( tpd->nextstems[j] == stem ) - tpd->next_is_l[j] = true; - for ( j=0; j<tpd->prevcnt; j++ ) - if ( tpd->prevstems[j] == stem ) - tpd->prev_is_l[j] = true; - } - - tpd = chunk->r; - if ( tpd != NULL ) { - for ( j=0; j<tpd->nextcnt; j++ ) - if ( tpd->nextstems[j] == stem ) - tpd->next_is_l[j] = false; - for ( j=0; j<tpd->prevcnt; j++ ) - if ( tpd->prevstems[j] == stem ) - tpd->prev_is_l[j] = false; - } - } - - /* In case of a quadratic contour invert assignments to stem sides */ - /* also for off-curve points */ - if ( gd->order2 ) { - for ( i=0; i<gd->realcnt; i++ ) if ( gd->points[i].sp == NULL ) { - tpd = &gd->points[i]; - for ( j=0; j<tpd->nextcnt; j++ ) - if ( tpd->nextstems[j] == stem ) - tpd->next_is_l[j] = !tpd->next_is_l[j]; - for ( j=0; j<tpd->prevcnt; j++ ) - if ( tpd->prevstems[j] == stem ) - tpd->prev_is_l[j] = !tpd->prev_is_l[j]; - } - } -} - -static int StemFitsHV( struct stemdata *stem,int is_x,uint8 mask ) { - int i,cnt; - double loff,roff; - double lmin=0,lmax=0,rmin=0,rmax=0; - struct stem_chunk *chunk; - - cnt = stem->chunk_cnt; - - for ( i=0 ; i<stem->chunk_cnt; i++ ) { - if( stem->chunks[i].stub & mask ) - break; - } - if ( i == stem->chunk_cnt ) -return( false ); - if ( stem->chunk_cnt == 1 ) -return( true ); - - for ( i=0;i<cnt;i++ ) { - chunk = &stem->chunks[i]; - - if ( chunk->l != NULL ) { - loff = ( chunk->l->sp->me.x - stem->left.x ) * !is_x - - ( chunk->l->sp->me.y - stem->left.y ) * is_x; - if ( loff < lmin ) lmin = loff; - else if ( loff > lmax ) lmax = loff; - } - if ( chunk->r != NULL ) { - roff = ( chunk->r->sp->me.x - stem->right.x ) * !is_x - - ( chunk->r->sp->me.y - stem->right.y ) * is_x; - if ( roff < rmin ) rmin = roff; - else if ( roff > rmax ) rmax = roff; - } - } - if ((( lmax - lmin ) < 2*dist_error_hv ) && (( rmax - rmin ) < 2*dist_error_hv )) -return( true ); -return( false ); -} - -static int LineFitsHV( struct linedata *line ) { - int i,cnt,is_x,hv; - double off,min=0,max=0; - struct pointdata *pd; - - cnt = line->pcnt; - hv = IsUnitHV( &line->unit,true ); - if ( hv ) -return( true ); - - hv = IsUnitHV( &line->unit,false ); - if ( !hv ) -return( false ); - - is_x = ( hv == 1 ) ? 1 : 0; - for ( i=0;i<cnt;i++ ) { - pd = line->points[i]; - - off = ( pd->base.x - line->online.x ) * !is_x - - ( pd->base.y - line->online.y ) * is_x; - if ( off < min ) min = off; - else if ( off > max ) max = off; - } - if (( max - min ) < 2*dist_error_hv ) -return( true ); -return( false ); -} - -static int OnStem( struct stemdata *stem,BasePoint *test,int left ) { - double dist_error, off; - BasePoint *dir = &stem->unit; - double max=0, min=0; - - /* Diagonals are harder to align */ - dist_error = IsUnitHV( dir,true ) ? dist_error_hv : dist_error_diag; - if ( !stem->positioned ) dist_error = dist_error * 2; - if ( dist_error > stem->width/2 ) dist_error = stem->width/2; - if ( left ) { - off = (test->x - stem->left.x)*dir->y - (test->y - stem->left.y)*dir->x; - max = stem->lmax; min = stem->lmin; - } else { - off = (test->x - stem->right.x)*dir->y - (test->y - stem->right.y)*dir->x; - max = stem->rmax; min = stem->rmin; - } - - if ( off > ( max - dist_error ) && off < ( min + dist_error ) ) -return( true ); - -return( false ); -} - -static int BothOnStem( struct stemdata *stem,BasePoint *test1,BasePoint *test2, - int force_hv,int strict,int cove ) { - double dist_error, off1, off2; - BasePoint dir = stem->unit; - int hv, hv_strict; - double lmax=0, lmin=0, rmax=0, rmin=0; - - hv = ( force_hv ) ? IsUnitHV( &dir,false ) : IsUnitHV( &dir,true ); - hv_strict = ( force_hv ) ? IsUnitHV( &dir,true ) : hv; - if ( force_hv ) { - if ( force_hv != hv ) -return( false ); - if ( !hv_strict && !StemFitsHV( stem,( hv == 1 ),7 )) -return( false ); - if ( !hv_strict ) { - dir.x = ( force_hv == 2 ) ? 0 : 1; - dir.y = ( force_hv == 2 ) ? 1 : 0; - } - } - /* Diagonals are harder to align */ - dist_error = ( hv ) ? dist_error_hv : dist_error_diag; - if ( !strict ) { - dist_error = dist_error * 2; - lmax = stem->lmax; lmin = stem->lmin; - rmax = stem->rmax; rmin = stem->rmin; - } - if ( dist_error > stem->width/2 ) dist_error = stem->width/2; - - off1 = (test1->x-stem->left.x)*dir.y - (test1->y-stem->left.y)*dir.x; - off2 = (test2->x-stem->right.x)*dir.y - (test2->y-stem->right.y)*dir.x; - if (off1 > ( lmax - dist_error ) && off1 < ( lmin + dist_error ) && - off2 > ( rmax - dist_error ) && off2 < ( rmin + dist_error )) { - /* For some reasons in my patch from Feb 24 2008 I prohibited snapping */ - /* to stems point pairs which together form a bend, if at least */ - /* one point from the pair doesn't have exactly the same position as */ - /* the stem edge. Unfortunately I don't remember why I did this, but */ - /* this behavior has at least one obviously negative effect: it */ - /* prevents building a stem from chunks which describe an ark */ - /* intersected by some straight lines, even if the intersections lie */ - /* closely enough to the ark extremum. So don't apply this test */ - /* at least if the force_hv flag is on (which means either the */ - /* chunk or the stem itself is not exactly horizontal/vertical) */ - if ( !cove || force_hv || off1 == 0 || off2 == 0 ) -return( true ); - } - - off2 = (test2->x-stem->left.x)*dir.y - (test2->y-stem->left.y)*dir.x; - off1 = (test1->x-stem->right.x)*dir.y - (test1->y-stem->right.y)*dir.x; - if (off2 > ( lmax - dist_error ) && off2 < ( lmin + dist_error ) && - off1 > ( rmax - dist_error ) && off1 < ( rmin + dist_error )) { - if ( !cove || force_hv || off1 == 0 || off2 == 0 ) -return( true ); - } - -return( false ); -} - -static int RecalcStemOffsets( struct stemdata *stem,BasePoint *dir,int left,int right ) { - double off, err; - double lmin=0, lmax=0, rmin=0, rmax=0; - struct stem_chunk *chunk; - int i; - - if ( !left && !right ) -return( false ); - err = ( IsUnitHV( dir,true )) ? dist_error_hv : dist_error_diag; - - if ( stem->chunk_cnt > 1 ) for ( i=0; i<stem->chunk_cnt; i++ ) { - chunk = &stem->chunks[i]; - if ( left && chunk->l != NULL ) { - off = ( chunk->l->sp->me.x - stem->left.x )*dir->y - - ( chunk->l->sp->me.y - stem->left.y )*dir->x; - if ( off < lmin ) lmin = off; - else if ( off > lmax ) lmax = off; - } - if ( right && chunk->r != NULL ) { - off = ( chunk->r->sp->me.x - stem->right.x )*dir->y + - ( chunk->r->sp->me.y - stem->right.y )*dir->x; - if ( off < rmin ) rmin = off; - else if ( off > rmax ) rmax = off; - } - } - if ( lmax - lmin < 2*err && rmax - rmin < 2*err ) { - stem->lmin = lmin; stem->lmax = lmax; - stem->rmin = rmin; stem->rmax = rmax; -return( true ); - } -return( false ); -} - -static void SetStemUnit( struct stemdata *stem,BasePoint dir ) { - double width; - - width = ( stem->right.x - stem->left.x ) * dir.y - - ( stem->right.y - stem->left.y ) * dir.x; - if ( width < 0 ) { - width = -width; - dir.x = -dir.x; - dir.y = -dir.y; - } - stem->unit = dir; - stem->width = width; - - /* Guess at which normal we want */ - stem->l_to_r.x = dir.y; stem->l_to_r.y = -dir.x; - /* If we guessed wrong, use the other */ - if (( stem->right.x-stem->left.x )*stem->l_to_r.x + - ( stem->right.y-stem->left.y )*stem->l_to_r.y < 0 ) { - stem->l_to_r.x = -stem->l_to_r.x; - stem->l_to_r.y = -stem->l_to_r.y; - } - - /* Recalculate left/right offsets relatively to new vectors */ - RecalcStemOffsets( stem,&dir,true,true ); -} - -static struct stem_chunk *AddToStem( struct glyphdata *gd,struct stemdata *stem, - struct pointdata *pd1,struct pointdata *pd2,int is_next1, int is_next2, int cheat ) { - - int is_potential1 = false, is_potential2 = true; - struct stem_chunk *chunk=NULL; - BasePoint *dir = &stem->unit; - BasePoint *test; - int lincr = 1, rincr = 1; - double off, dist_error; - double loff = 0, roff = 0; - double min = 0, max = 0; - int i, in, ip, cpidx; - struct pointdata *pd, *npd, *ppd; - - if ( cheat || stem->positioned ) is_potential2 = false; - /* Diagonals are harder to align */ - dist_error = IsUnitHV( dir,true ) ? 2*dist_error_hv : 2*dist_error_diag; - if ( dist_error > stem->width/2 ) dist_error = stem->width/2; - max = stem->lmax; - min = stem->lmin; - - /* The following swaps "left" and "right" points in case we have */ - /* started checking relatively to a wrong edge */ - if ( pd1 != NULL ) { - test = &pd1->base; - off = ( test->x - stem->left.x )*dir->y - - ( test->y - stem->left.y )*dir->x; - if (( !stem->ghost && - ( off < ( max - dist_error ) || off > ( min + dist_error ))) || - ( RealNear( stem->unit.x, 1) && stem->ghost && stem->width == 21 ) || - ( RealNear( stem->unit.x,0 ) && stem->ghost && stem->width == 20 )) { - pd = pd1; pd1 = pd2; pd2 = pd; - in = is_next1; is_next1 = is_next2; is_next2 = in; - ip = is_potential1; is_potential1 = is_potential2; is_potential2 = ip; - } - } - - if ( pd1 == NULL ) lincr = 0; - if ( pd2 == NULL ) rincr = 0; - /* Now run through existing stem chunks and see if the chunk we are */ - /* going to add doesn't duplicate an existing one.*/ - for ( i=stem->chunk_cnt-1; i>=0; --i ) { - chunk = &stem->chunks[i]; - if ( chunk->l == pd1 ) lincr = 0; - if ( chunk->r == pd2 ) rincr = 0; - - if (( chunk->l == pd1 || pd1 == NULL ) && ( chunk->r == pd2 || pd2 == NULL )) { - if ( !is_potential1 ) chunk->lpotential = false; - if ( !is_potential2 ) chunk->rpotential = false; - break; - } else if (( chunk->l == pd1 && chunk->r == NULL ) || ( chunk->r == pd2 && chunk->l == NULL )) { - if ( chunk->l == NULL ) { - chunk->l = pd1; - chunk->lpotential = is_potential1; - chunk->lnext = is_next1; - chunk->ltick = lincr; - } else if ( chunk->r == NULL ) { - chunk->r = pd2; - chunk->rpotential = is_potential2; - chunk->rnext = is_next2; - chunk->rtick = rincr; - } - break; - } - } - - if ( i<0 ) { - stem->chunks = realloc(stem->chunks,(stem->chunk_cnt+1)*sizeof(struct stem_chunk)); - chunk = &stem->chunks[stem->chunk_cnt++]; - chunk->parent = stem; - - chunk->l = pd1; chunk->lpotential = is_potential1; - chunk->r = pd2; chunk->rpotential = is_potential2; - chunk->ltick = lincr; chunk->rtick = rincr; - - chunk->lnext = is_next1; - chunk->rnext = is_next2; - chunk->stemcheat = cheat; - chunk->stub = chunk->is_ball = false; - chunk->l_e_idx = chunk->r_e_idx = 0; - } - - if ( pd1!=NULL ) { - loff = ( pd1->base.x - stem->left.x ) * stem->l_to_r.x + - ( pd1->base.y - stem->left.y ) * stem->l_to_r.y; - if ( is_next1==1 || is_next1==2 || pd1->colinear ) { - AssignStemToPoint( pd1,stem,true,true ); - /* For quadratic layers assign the stem not only to */ - /* spline points, but to their control points as well */ - /* (this may be important for TTF instructions */ - if ( gd->order2 && !pd1->sp->nonextcp && pd1->sp->nextcpindex < gd->realcnt ) { - cpidx = pd1->sp->nextcpindex; - npd = &gd->points[cpidx]; - if ( OnStem( stem,&npd->base,true )) - AssignStemToPoint( npd,stem,false,true ); - } - } - if ( is_next1==0 || is_next1==2 || pd1->colinear ) { - AssignStemToPoint( pd1,stem,false,true ); - if ( gd->order2 && !pd1->sp->noprevcp && pd1->sp->prev != NULL && - pd1->sp->prev->from->nextcpindex < gd->realcnt ) { - cpidx = pd1->sp->prev->from->nextcpindex; - ppd = &gd->points[cpidx]; - if ( OnStem( stem,&ppd->base,true )) - AssignStemToPoint( ppd,stem,true,true ); - } - } - } - if ( pd2!=NULL ) { - roff = ( pd2->base.x - stem->right.x ) * stem->l_to_r.x + - ( pd2->base.y - stem->right.y ) * stem->l_to_r.y; - if ( is_next2==1 || is_next2==2 || pd2->colinear ) { - AssignStemToPoint( pd2,stem,true,false ); - if ( gd->order2 && !pd2->sp->nonextcp && pd2->sp->nextcpindex < gd->realcnt ) { - cpidx = pd2->sp->nextcpindex; - npd = &gd->points[cpidx]; - if ( OnStem( stem,&npd->base,false )) - AssignStemToPoint( npd,stem,false,false ); - } - } - if ( is_next2==0 || is_next2==2 || pd2->colinear ) { - AssignStemToPoint( pd2,stem,false,false ); - if ( gd->order2 && !pd2->sp->noprevcp && pd2->sp->prev != NULL && - pd2->sp->prev->from->nextcpindex < gd->realcnt ) { - cpidx = pd2->sp->prev->from->nextcpindex; - ppd = &gd->points[cpidx]; - if ( OnStem( stem,&ppd->base,false )) - AssignStemToPoint( ppd,stem,true,false ); - } - } - } - if ( loff < stem->lmin ) stem->lmin = loff; - else if ( loff > stem->lmax ) stem->lmax = loff; - if ( roff < stem->rmin ) stem->rmin = roff; - else if ( roff > stem->rmax ) stem->rmax = roff; - stem->lpcnt += lincr; stem->rpcnt += rincr; -return( chunk ); -} - -static struct stemdata *FindStem( struct glyphdata *gd,struct pointdata *pd, - struct pointdata *pd2,BasePoint *dir,int is_next2,int de ) { - - int i, cove, test_left, hv, stemcnt; - struct stemdata *stem; - BasePoint newdir; - - stemcnt = ( is_next2 ) ? pd2->nextcnt : pd2->prevcnt; - - for ( i=0; i<stemcnt; i++ ) { - stem = ( is_next2 ) ? pd2->nextstems[i] : pd2->prevstems[i]; - test_left = ( is_next2 ) ? !pd2->next_is_l[i] : !pd2->prev_is_l[i]; - - if (UnitsParallel( &stem->unit,dir,true ) && - OnStem( stem,&pd->sp->me,test_left )) -return( stem ); - } - - cove = ( dir->x == 0 && pd->x_extr + pd2->x_extr == 3 ) || - ( dir->y == 0 && pd->y_extr + pd2->y_extr == 3 ); - - /* First pass to check for strict matches */ - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - /* Ghost hints and BBox hits are usually generated after all other */ - /* hint types, but we can get them here in case we are generating */ - /* glyph data for a predefined hint layout. In this case they should */ - /* be excluded from the following tests */ - if ( stem->ghost || stem->bbox ) - continue; - - if ( UnitsParallel( &stem->unit,dir,true ) && - BothOnStem( stem,&pd->sp->me,&pd2->sp->me,false,true,cove )) { - return( stem ); - } - } - /* One more pass. At this stage larger deviations are allowed */ - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( stem->ghost || stem->bbox ) - continue; - - if ( UnitsParallel( &stem->unit,dir,true ) && - BothOnStem( stem,&pd->sp->me,&pd2->sp->me,false,false,cove )) { -return( stem ); - } - } - if ( de ) -return( NULL ); - - hv = IsUnitHV( dir,false ); - if ( !hv ) -return( NULL ); - - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( stem->ghost || stem->bbox ) - continue; - if ( hv && BothOnStem( stem,&pd->base,&pd2->base,hv,false,cove )) { - newdir.x = ( hv == 2 ) ? 0 : 1; - newdir.y = ( hv == 2 ) ? 1 : 0; - if ( hv == 2 && stem->unit.y < 0 ) - SwapEdges( gd,stem ); - if ( stem->unit.x != newdir.x ) - SetStemUnit( stem,newdir ); -return( stem ); - } - } -return( NULL ); -} - -static struct stemdata *NewStem( struct glyphdata *gd,BasePoint *dir, - BasePoint *pos1, BasePoint *pos2 ) { - - struct stemdata * stem = &gd->stems[gd->stemcnt++]; - double width; - - stem->unit = *dir; - if ( dir->x < 0 || dir->y == -1 ) { - stem->unit.x = -stem->unit.x; - stem->unit.y = -stem->unit.y; - } - width = ( pos2->x - pos1->x ) * stem->unit.y - - ( pos2->y - pos1->y ) * stem->unit.x; - if ( width > 0 ) { - stem->left = *pos1; - stem->right = *pos2; - stem->width = width; - } else { - stem->left = *pos2; - stem->right = *pos1; - stem->width = -width; - } - /* Guess at which normal we want */ - stem->l_to_r.x = dir->y; stem->l_to_r.y = -dir->x; - /* If we guessed wrong, use the other */ - if (( stem->right.x-stem->left.x )*stem->l_to_r.x + - ( stem->right.y-stem->left.y )*stem->l_to_r.y < 0 ) { - stem->l_to_r.x = -stem->l_to_r.x; - stem->l_to_r.y = -stem->l_to_r.y; - } - stem->leftidx = stem->rightidx = -1; - stem->leftline = stem->rightline = NULL; - stem->lmin = stem->lmax = 0; - stem->rmin = stem->rmax = 0; - stem->ldone = stem->rdone = false; - stem->lpcnt = stem->rpcnt = 0; - stem->chunks = NULL; - stem->chunk_cnt = 0; - stem->ghost = stem->bbox = false; - stem->positioned = false; - stem->blue = -1; -return( stem ); -} - -static int ParallelToDir( struct pointdata *pd,int checknext,BasePoint *dir, - BasePoint *opposite,SplinePoint *basesp,uint8 is_stub ) { - - BasePoint n, o, *base = &basesp->me; - SplinePoint *sp; - double angle, mid_err = ( stem_slope_error + stub_slope_error )/2; - - sp = pd->sp; - n = ( checknext ) ? pd->nextunit : pd->prevunit; - - angle = fabs( GetUnitAngle( dir,&n )); - if (( !is_stub && angle > stem_slope_error && angle < PI - stem_slope_error ) || - ( is_stub & 1 && angle > stub_slope_error*1.5 && angle < PI - stub_slope_error*1.5 ) || - ( is_stub & 6 && angle > mid_err && angle < PI - mid_err )) -return( false ); - - /* Now sp must be on the same side of the spline as opposite */ - o.x = opposite->x-base->x; o.y = opposite->y-base->y; - n.x = sp->me.x-base->x; n.y = sp->me.y-base->y; - if ( ( o.x*dir->y - o.y*dir->x )*( n.x*dir->y - n.y*dir->x ) < 0 ) -return( false ); - -return( true ); -} - -static int NearlyParallel( BasePoint *dir,Spline *other, double t ) { - BasePoint odir; - double olen; - - odir.x = (3*other->splines[0].a*t+2*other->splines[0].b)*t+other->splines[0].c; - odir.y = (3*other->splines[1].a*t+2*other->splines[1].b)*t+other->splines[1].c; - olen = sqrt( pow( odir.x,2 ) + pow( odir.y,2 )); - if ( olen==0 ) -return( false ); - odir.x /= olen; odir.y /= olen; -return( UnitsParallel( dir,&odir,false )); -} - -static double NormalDist( BasePoint *to, BasePoint *from, BasePoint *perp ) { - double len = (to->x-from->x)*perp->y - (to->y-from->y)*perp->x; - if ( len<0 ) len = -len; -return( len ); -} - -static struct stemdata *FindOrMakeHVStem( struct glyphdata *gd, - struct pointdata *pd,struct pointdata *pd2,int is_h,int require_existing ) { - int i,cove = false; - struct stemdata *stem; - BasePoint dir; - - dir.x = ( is_h ) ? 1 : 0; - dir.y = ( is_h ) ? 0 : 1; - if ( pd2 != NULL ) - cove = ( dir.x == 0 && pd->x_extr + pd2->x_extr == 3 ) || - ( dir.y == 0 && pd->y_extr + pd2->y_extr == 3 ); - - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( IsUnitHV( &stem->unit,true ) && - ( pd2 != NULL && BothOnStem( stem,&pd->sp->me,&pd2->sp->me,false,false,cove ))) - break; - } - if ( i==gd->stemcnt ) stem=NULL; - - if ( stem == NULL && pd2 != NULL && !require_existing ) - stem = NewStem( gd,&dir,&pd->sp->me,&pd2->sp->me ); -return( stem ); -} - -static int IsDiagonalEnd( struct glyphdata *gd, - struct pointdata *pd1,struct pointdata *pd2,int is_next,int require_existing ) { - /* suppose we have something like */ - /* *--* */ - /* \ \ */ - /* \ \ */ - /* Then let's create a vertical stem between the two points */ - /* (and a horizontal stem if the thing is rotated 90 degrees) */ - double width, length1, length2, dist1, dist2; - BasePoint *pt1, *pt2, *dir1, *dir2, *prevdir1, *prevdir2; - SplinePoint *prevsp1, *prevsp2; - struct pointdata *prevpd1, *prevpd2; - int hv; - - if ( pd1->colinear || pd2->colinear ) -return( false ); - pt1 = &pd1->sp->me; pt2 = &pd2->sp->me; - /* Both key points of a diagonal end stem should have nearly the same */ - /* coordinate by x or y (otherwise we can't determine by which axis */ - /* it should be hinted) */ - if ( pt1->x >= pt2->x - dist_error_hv && pt1->x <= pt2->x + dist_error_hv ) { - width = pd1->sp->me.y - pd2->sp->me.y; - hv = 1; - } else if ( pt1->y >= pt2->y - dist_error_hv && pt1->y <= pt2->y + dist_error_hv ) { - width = pd1->sp->me.x - pd2->sp->me.x; - hv = 2; - } else -return( false ); - - dir1 = ( is_next ) ? &pd1->nextunit : &pd1->prevunit; - dir2 = ( is_next ) ? &pd2->prevunit : &pd2->nextunit; - if ( IsUnitHV( dir1,true )) /* Must be diagonal */ -return( false ); - prevsp1 = ( is_next ) ? pd1->sp->next->to : pd1->sp->prev->from; - prevsp2 = ( is_next ) ? pd2->sp->prev->from : pd2->sp->next->to; - prevpd1 = &gd->points[prevsp1->ptindex]; - prevpd2 = &gd->points[prevsp2->ptindex]; - prevdir1 = ( is_next ) ? &prevpd1->prevunit : &prevpd1->nextunit; - prevdir2 = ( is_next ) ? &prevpd2->nextunit : &prevpd2->prevunit; - /* Ensure we have got a real diagonal, i. e. its sides are parallel */ - if ( !UnitsParallel( dir1,dir2,true ) || !UnitsParallel( prevdir1,prevdir2,true )) -return( false ); - - /* Diagonal width should be smaller than its length */ - length1 = pow(( prevsp1->me.x - pt1->x ),2 ) + pow(( prevsp1->me.y - pt1->y ),2 ); - length2 = pow(( prevsp2->me.x - pt2->x ),2 ) + pow(( prevsp2->me.y - pt2->y ),2 ); - if ( length2 < length1 ) length1 = length2; - if ( pow( width,2 ) > length1 ) -return( false ); - - /* Finally exclude too short diagonals where the distance between key */ - /* points of one edge at the direction orthogonal to the unit vector */ - /* of the stem we are about to add is smaller than normal HV stem */ - /* fudge. Such diagonals may be later turned into HV stems, and we will */ - /* result into getting two coincident hints */ - dist1 = ( hv == 1 ) ? prevsp1->me.y - pt1->y : prevsp1->me.x - pt1->x; - dist2 = ( hv == 1 ) ? prevsp2->me.y - pt2->y : prevsp2->me.x - pt2->x; - if ( dist1 < 0 ) dist1 = -dist1; - if ( dist2 < 0 ) dist2 = -dist2; - if ( dist1 < 2*dist_error_hv && dist2 < 2*dist_error_hv ) -return( false ); - -return( hv ); -} - -static struct stemdata *TestStem( struct glyphdata *gd,struct pointdata *pd, - BasePoint *dir,SplinePoint *match,int is_next,int is_next2,int require_existing,uint8 is_stub,int eidx ) { - struct pointdata *pd2; - struct stemdata *stem, *destem; - struct stem_chunk *chunk; - struct linedata *otherline; - double width; - struct linedata *line, *line2; - BasePoint *mdir, middle; - int de=false, hv, l_changed; - - width = ( match->me.x - pd->sp->me.x )*dir->y - - ( match->me.y - pd->sp->me.y )*dir->x; - if ( width < 0 ) width = -width; - if ( width < .5 ) -return( NULL ); /* Zero width stems aren't interesting */ - if (( is_next && pd->sp->next->to==match ) || ( !is_next && pd->sp->prev->from==match )) -return( NULL ); /* Don't want a stem between two splines that intersect */ - - pd2 = &gd->points[match->ptindex]; - - line = is_next ? pd->nextline : pd->prevline; - mdir = is_next2 ? &pd2->nextunit : &pd2->prevunit; - line2 = is_next2 ? pd2->nextline : pd2->prevline; - if ( !IsUnitHV( mdir,true ) && line2 != NULL ) - mdir = &line2->unit; - if ( mdir->x==0 && mdir->y==0 ) -return( NULL ); /* cannot determine the opposite point's direction */ - - if ( !UnitsParallel( mdir,dir,true ) && !is_stub ) -return( NULL ); /* Cannot make a stem if edges are not parallel (unless it is a serif) */ - - if ( is_stub & 1 && !IsUnitHV( dir,true )) { - /* For serifs we prefer the vector which is closer to horizontal/vertical */ - middle = MiddleUnit( dir,mdir ); - if ( UnitCloserToHV( &middle,dir ) == 1 && UnitCloserToHV( &middle,mdir ) == 1 ) - dir = &middle; - else if ( UnitCloserToHV( mdir,dir ) == 1 ) - dir = mdir; - if ( !IsUnitHV( dir,true ) && - ( hint_diagonal_ends || require_existing )) - de = IsDiagonalEnd( gd,pd,pd2,is_next,require_existing ); - } - - stem = FindStem( gd,pd,pd2,dir,is_next2,de ); - destem = NULL; - if ( de ) - destem = FindOrMakeHVStem( gd,pd,pd2,( de == 1 ),require_existing ); - - if ( stem == NULL && !require_existing ) - stem = NewStem( gd,dir,&pd->sp->me,&match->me ); - if ( stem != NULL ) { - chunk = AddToStem( gd,stem,pd,pd2,is_next,is_next2,false ); - if ( chunk != NULL ) { - chunk->stub = is_stub; - chunk->l_e_idx = chunk->r_e_idx = eidx; - } - - if ( chunk != NULL && gd->linecnt > 0 ) { - hv = IsUnitHV( &stem->unit,true ); - /* For HV stems allow assigning a line to a stem edge only */ - /* if that line also has an exactly HV vector */ - if ( line != NULL && (( !hv && - UnitsParallel( &stem->unit,&line->unit,true ) && - RecalcStemOffsets( stem,&line->unit,true,true )) || - ( hv && line->unit.x == stem->unit.x && line->unit.y == stem->unit.y ))) { - - otherline = NULL; l_changed = false; - if (( stem->leftline == NULL || - stem->leftline->length < line->length ) && chunk->l == pd ) { - - stem->leftline = line; - l_changed = true; - otherline = stem->rightline; - } else if (( stem->rightline == NULL || - stem->rightline->length < line->length ) && chunk->r == pd ) { - - stem->rightline = line; - l_changed = true; - otherline = stem->leftline; - } - /* If lines are attached to both sides of a diagonal stem, */ - /* then prefer the longer line */ - if ( !hv && l_changed && !stem->positioned && - ( otherline == NULL || ( otherline->length < line->length ))) - SetStemUnit( stem,line->unit ); - } - if ( line2 != NULL && (( !hv && - UnitsParallel( &stem->unit,&line2->unit,true ) && - RecalcStemOffsets( stem,&line2->unit,true,true )) || - ( hv && line2->unit.x == stem->unit.x && line2->unit.y == stem->unit.y ))) { - - otherline = NULL; l_changed = false; - if (( stem->leftline == NULL || - stem->leftline->length < line2->length ) && chunk->l == pd2 ) { - - stem->leftline = line2; - l_changed = true; - otherline = stem->rightline; - } else if (( stem->rightline == NULL || - stem->rightline->length < line2->length ) && chunk->r == pd2 ) { - - stem->rightline = line2; - l_changed = true; - otherline = stem->leftline; - } - if ( !hv && l_changed && !stem->positioned && - ( otherline == NULL || ( otherline->length < line2->length ))) - SetStemUnit( stem,line2->unit ); - } - } - } - - if ( destem != NULL ) - AddToStem( gd,destem,pd,pd2,is_next,!is_next,1 ); -return( stem ); -} - -static double FindSameSlope(Spline *s,BasePoint *dir,double close_to) { - double a, b, c, desc; - double t1, t2; - double d1, d2; - - if ( s==NULL ) -return( -1e4 ); - - a = dir->x*s->splines[1].a*3 - dir->y*s->splines[0].a*3; - b = dir->x*s->splines[1].b*2 - dir->y*s->splines[0].b*2; - c = dir->x*s->splines[1].c - dir->y*s->splines[0].c ; - if ( a!=0 ) { - desc = b*b - 4*a*c; - if ( desc<0 ) -return( -1e4 ); - desc = sqrt(desc); - t1 = (-b+desc)/(2*a); - t2 = (-b-desc)/(2*a); - if ( (d1=t1-close_to)<0 ) d1 = -d1; - if ( (d2=t2-close_to)<0 ) d2 = -d2; - if ( d2<d1 && t2>=-.001 && t2<=1.001 ) - t1 = t2; - } else if ( b!=0 ) - t1 = -c/b; - else -return( -1e4 ); - -return( t1 ); -} - -/* This function is used when generating stem data for preexisting */ -/* stem hints. If we already know the desired hint position, then we */ -/* can safely assign to this hint any points which meet other conditions */ -/* but have no corresponding position at the opposite edge. */ -static int HalfStemNoOpposite( struct glyphdata *gd,struct pointdata *pd, - struct stemdata *stem,BasePoint *dir,int is_next ) { - int i, ret=0, allowleft, allowright, hv, corner; - struct stemdata *tstem; - - for ( i=0; i<gd->stemcnt; ++i ) { - tstem = &gd->stems[i]; - if ( tstem->bbox || !tstem->positioned || tstem == stem ) - continue; - allowleft = ( !tstem->ghost || tstem->width == 20 ); - allowright = ( !tstem->ghost || tstem->width == 21 ); - hv = IsUnitHV( &tstem->unit,true ); - corner = (( pd->x_corner && hv == 2 ) || ( pd->y_corner && hv == 1 )); - - if ( UnitsParallel( &tstem->unit,dir,true ) || tstem->ghost || corner ) { - if ( OnStem( tstem,&pd->sp->me,true ) && allowleft ) { - if ( IsCorrectSide( gd,pd,is_next,true,&tstem->unit )) { - AddToStem( gd,tstem,pd,NULL,is_next,false,false ); - ret++; - } - } else if ( OnStem( tstem,&pd->sp->me,false ) && allowright ) { - if ( IsCorrectSide( gd,pd,is_next,false,&tstem->unit )) { - AddToStem( gd,tstem,NULL,pd,false,is_next,false ); - ret++; - } - } - } - } -return( ret ); -} - -static struct stemdata *HalfStem( struct glyphdata *gd,struct pointdata *pd, - BasePoint *dir,Spline *other,double other_t,int is_next,int eidx ) { - /* Find the spot on other where the slope is the same as dir */ - double t1; - double width; - BasePoint match; - struct stemdata *stem = NULL, *tstem; - struct pointdata *pd2 = NULL, *tpd; - int i; - - t1 = FindSameSlope( other,dir,other_t ); - if ( t1==-1e4 ) -return( NULL ); - if ( t1<0 && other->from->prev!=NULL && gd->points[other->from->ptindex].colinear ) { - other = other->from->prev; - t1 = FindSameSlope(other,dir,1.0); - } else if ( t1>1 && other->to->next!=NULL && gd->points[other->to->ptindex].colinear ) { - other = other->to->next; - t1 = FindSameSlope(other,dir,0.0); - } - - if ( t1<-.001 || t1>1.001 ) -return( NULL ); - - /* Ok. the opposite edge has the right slope at t1 */ - /* Now see if we can make a one sided stem out of these two */ - match.x = ((other->splines[0].a*t1+other->splines[0].b)*t1+other->splines[0].c)*t1+other->splines[0].d; - match.y = ((other->splines[1].a*t1+other->splines[1].b)*t1+other->splines[1].c)*t1+other->splines[1].d; - - width = (match.x-pd->sp->me.x)*dir->y - (match.y-pd->sp->me.y)*dir->x; - /* offset = (match.x-pd->sp->me.x)*dir->x + (match.y-pd->sp->me.y)*dir->y;*/ - if ( width<.5 && width>-.5 ) -return( NULL ); /* Zero width stems aren't interesting */ - - if ( isnan(t1)) - IError( "NaN value in HalfStem" ); - - if ( is_next ) { - pd->nextedges[eidx] = other; - pd->next_e_t[eidx] = t1; - } else { - pd->prevedges[eidx] = other; - pd->prev_e_t[eidx] = t1; - } - - /* In my experience the only case where this function may be useful */ - /* is when it occasionally finds a real spline point which for some */ - /* reasons has been neglected by other tests and yet forms a valid */ - /* pair for the first point. So run through points and see if we */ - /* have actually got just a position on spline midway between to points, */ - /* or it is a normal point allowing to make a normal stem chunk */ - for ( i=0; i<gd->pcnt; ++i ) { - tpd = &gd->points[i]; - if ( tpd->sp != NULL && tpd->sp->me.x == match.x && tpd->sp->me.y == match.y ) { - pd2 = tpd; - break; - } - } - for ( i=0; i<gd->stemcnt; ++i ) { - tstem = &gd->stems[i]; - if ( UnitsParallel( &tstem->unit,dir,true ) && - BothOnStem( tstem,&pd->base,&match,false,false,false )) { - stem = tstem; - break; - } - } - if ( stem == NULL ) - stem = NewStem(gd,dir,&pd->sp->me,&match); - - AddToStem( gd,stem,pd,pd2,is_next,false,false ); -return( stem ); -} - -static int ConnectsAcross( struct glyphdata *gd,SplinePoint *sp, - int is_next,Spline *findme,int eidx ) { - struct pointdata *pd = &gd->points[sp->ptindex]; - Spline *other, *test; - BasePoint dir; - - other = ( is_next ) ? pd->nextedges[eidx] : pd->prevedges[eidx]; - - if ( other==findme ) -return( true ); - if ( other==NULL ) -return( false ); - - dir.x = ( is_next ) ? -pd->nextunit.x : pd->prevunit.x; - dir.y = ( is_next ) ? -pd->nextunit.y : pd->prevunit.y; - test = other->to->next; - while ( test!=NULL && test != other && - gd->points[test->from->ptindex].nextunit.x * dir.x + - gd->points[test->from->ptindex].nextunit.y * dir.y > 0 ) { - if ( test==findme ) -return( true ); - test = test->to->next; - } - - dir.x = ( is_next ) ? pd->nextunit.x : -pd->prevunit.x; - dir.y = ( is_next ) ? pd->nextunit.y : -pd->prevunit.y; - test = other->from->prev; - while ( test!=NULL && test != other && - gd->points[test->to->ptindex].prevunit.x * dir.x + - gd->points[test->to->ptindex].prevunit.y * dir.y > 0 ) { - if ( test==findme ) -return( true ); - test = test->from->prev; - } -return( false ); -} - -static int ConnectsAcrossToStem( struct glyphdata *gd,struct pointdata *pd, - int is_next,struct stemdata *target,int is_l,int eidx ) { - - Spline *other, *test; - BasePoint dir; - struct pointdata *tpd; - int ecnt, stemidx; - - ecnt = ( is_next ) ? pd->next_e_cnt : pd->prev_e_cnt; - if ( ecnt < eidx + 1 ) -return( false ); - other = ( is_next ) ? pd->nextedges[eidx] : pd->prevedges[eidx]; - - test = other; - dir.x = ( is_next ) ? pd->nextunit.x : -pd->prevunit.x; - dir.y = ( is_next ) ? pd->nextunit.y : -pd->prevunit.y; - do { - tpd = &gd->points[test->to->ptindex]; - stemidx = IsStemAssignedToPoint( tpd,target,false ); - if ( stemidx != -1 && tpd->prev_is_l[stemidx] == !is_l && - IsSplinePeak( gd,tpd,rint( target->unit.y ),rint( target->unit.y ),7 )) -return( true ); - - test = test->to->next; - } while ( test!=NULL && test != other && stemidx == -1 && - ( tpd->prevunit.x * dir.x + tpd->prevunit.y * dir.y >= 0 )); - - test = other; - dir.x = ( is_next ) ? -pd->nextunit.x : pd->prevunit.x; - dir.y = ( is_next ) ? -pd->nextunit.y : pd->prevunit.y; - do { - tpd = &gd->points[test->from->ptindex]; - stemidx = IsStemAssignedToPoint( tpd,target,true ); - if ( stemidx != -1 && tpd->next_is_l[stemidx] == !is_l && - IsSplinePeak( gd,tpd,rint( target->unit.y ),rint( target->unit.y ),7 )) -return( true ); - - test = test->from->prev; - } while ( test!=NULL && test != other && stemidx == -1 && - ( tpd->nextunit.x * dir.x + tpd->nextunit.y * dir.y >= 0 )); -return( false ); -} - -static double RecalcT( Spline *base,SplinePoint *from, SplinePoint *to, double curt ) { - double baselen, fromlen, tolen, ret; - Spline *cur; - - baselen = SplineLength( base ); - fromlen = baselen * curt; - tolen = baselen * ( 1 - curt ); - - cur = base->from->prev; - while ( cur != NULL && cur->to != from ) { - fromlen += SplineLength( cur ); - cur = cur->from->prev; - } - cur = base->to->next; - while ( cur!= NULL && cur->from != to ) { - tolen += SplineLength( cur ); - cur = cur->to->next; - } - ret = fromlen/( fromlen + tolen ); -return( ret ); -} - -static int BuildStem( struct glyphdata *gd,struct pointdata *pd,int is_next, - int require_existing,int has_existing,int eidx ) { - BasePoint *dir; - Spline *other, *cur; - double t; - double tod, fromd, dist; - SplinePoint *testpt, *topt, *frompt; - struct linedata *line; - struct pointdata *testpd, *topd, *frompd; - int tp, fp, t_needs_recalc=false, ret=0; - uint8 tstub=0, fstub=0; - BasePoint opposite; - struct stemdata *stem=NULL; - - if ( is_next ) { - dir = &pd->nextunit; - other = pd->nextedges[eidx]; - cur = pd->sp->next; - t = pd->next_e_t[eidx]; - dist = pd->next_dist[eidx]; - } else { - dir = &pd->prevunit; - other = pd->prevedges[eidx]; - cur = pd->sp->prev; - t = pd->prev_e_t[eidx]; - dist = pd->prev_dist[eidx]; - } - topt = other->to; frompt = other->from; - topd = &gd->points[topt->ptindex]; - frompd = &gd->points[frompt->ptindex]; - - line = is_next ? pd->nextline : pd->prevline; - if ( !IsUnitHV( dir,true ) && line != NULL) - dir = &line->unit; - - if ( other==NULL ) -return( 0 ); - - opposite.x = ((other->splines[0].a*t+other->splines[0].b)*t+other->splines[0].c)*t+other->splines[0].d; - opposite.y = ((other->splines[1].a*t+other->splines[1].b)*t+other->splines[1].c)*t+other->splines[1].d; - - if ( eidx == 0 ) tstub = IsStubOrIntersection( gd,dir,pd,topd,is_next,false ); - if ( eidx == 0 ) fstub = IsStubOrIntersection( gd,dir,pd,frompd,is_next,true ); - tp = ParallelToDir( topd,false,dir,&opposite,pd->sp,tstub ); - fp = ParallelToDir( frompd,true,dir,&opposite,pd->sp,fstub ); - - /* if none of the opposite points is parallel to the needed vector, then */ - /* give it one more chance by skipping those points and looking at the next */ - /* and previous one. This can be useful in situations where the opposite */ - /* edge cannot be correctly detected just because there are too many points */ - /* on the spline (which is a very common situation for poorly designed */ - /* fonts or fonts with quadratic splines). */ - /* But do that only for colinear spline segments and ensure that there are */ - /* no bends between two splines. */ - if ( !tp && ( !fp || t > 0.5 ) && - topd->colinear && &other->to->next != NULL ) { - testpt = topt->next->to; - testpd = &gd->points[testpt->ptindex]; - BasePoint *initdir = &topd->prevunit; - while ( !tp && topd->colinear && pd->sp != testpt && other->from != testpt && ( - testpd->prevunit.x * initdir->x + - testpd->prevunit.y * initdir->y > 0 )) { - - topt = testpt; topd = testpd; - tp = ParallelToDir( topd,false,dir,&opposite,pd->sp,false ); - testpt = topt->next->to; - testpd = &gd->points[testpt->ptindex]; - } - if ( tp ) t_needs_recalc = true; - } - if ( !fp && ( !fp || t < 0.5 ) && - frompd->colinear && &other->from->prev != NULL ) { - testpt = frompt->prev->from; - testpd = &gd->points[testpt->ptindex]; - BasePoint *initdir = &frompd->prevunit; - while ( !fp && frompd->colinear && pd->sp != testpt && other->to != testpt && ( - testpd->prevunit.x * initdir->x + - testpd->prevunit.y * initdir->y > 0 )) { - - frompt = testpt; frompd = testpd; - fp = ParallelToDir( frompd,true,dir,&opposite,pd->sp,false ); - testpt = frompt->prev->from; - testpd = &gd->points[testpt->ptindex]; - } - if ( fp ) t_needs_recalc = true; - } - if ( t_needs_recalc ) - t = RecalcT( other,frompt,topt,t ); - if ( !tp && !fp ) { - if ( has_existing ) - ret = HalfStemNoOpposite( gd,pd,NULL,dir,is_next ); -return( ret ); - } - - /* We have several conflicting metrics for getting the "better" stem */ - /* Generally we prefer the stem with the smaller width (but not always. See tilde) */ - /* Generally we prefer the stem formed by the point closer to the intersection */ - tod = (1-t)*NormalDist( &topt->me,&pd->sp->me,dir ); - fromd = t*NormalDist( &frompt->me,&pd->sp->me,dir ); - - if ( tp && (( tod<fromd ) || - ( !fp && ( tod<2*fromd || dist < topd->prev_dist[eidx] || - ConnectsAcross( gd,frompt,true,cur,eidx ) || NearlyParallel( dir,other,t ))))) { - stem = TestStem( gd,pd,dir,topt,is_next,false,require_existing,tstub,eidx ); - } - if ( stem == NULL && fp && (( fromd<tod ) || - ( !tp && ( fromd<2*tod || dist < frompd->next_dist[eidx] || - ConnectsAcross( gd,topt,false,cur,eidx ) || NearlyParallel( dir,other,t ))))) { - stem = TestStem( gd,pd,dir,frompt,is_next,true,require_existing,fstub,eidx ); - } - if ( eidx == 0 && stem == NULL && !require_existing && cur!=NULL && - !other->knownlinear && !cur->knownlinear ) - stem = HalfStem( gd,pd,dir,other,t,is_next,eidx ); - if ( stem != NULL ) ret = 1; - if ( has_existing ) - ret += HalfStemNoOpposite( gd,pd,stem,dir,is_next ); -return( ret ); -} - -static void AssignLinePointsToStems( struct glyphdata *gd ) { - struct pointdata *pd; - struct stemdata *stem; - struct linedata *line; - struct stem_chunk *chunk; - int i, j, stem_hv, line_hv, needs_hv=false; - - for ( i=0; i<gd->stemcnt; ++i ) if ( !gd->stems[i].toobig ) { - stem = &gd->stems[i]; - stem_hv = IsUnitHV( &stem->unit,true ); - needs_hv = ( stem_hv || ( stem->chunk_cnt == 1 && - stem->chunks[0].stub && IsUnitHV( &stem->unit,false ))); - - if ( stem->leftline != NULL ) { - line = stem->leftline; - line_hv = ( needs_hv && LineFitsHV( line )); - - if ( needs_hv && !line_hv ) - stem->leftline = NULL; - else { - for ( j=0; j<line->pcnt; j++ ) { - pd = line->points[j]; - if ( pd->prevline == line && OnStem( stem,&pd->base,true ) && - IsStemAssignedToPoint( pd,stem,false ) == -1) { - chunk = AddToStem( gd,stem,pd,NULL,false,false,false ); - chunk->lpotential = true; - } if ( pd->nextline == line && OnStem( stem,&pd->base,true ) && - IsStemAssignedToPoint( pd,stem,true ) == -1 ) { - chunk = AddToStem( gd,stem,pd,NULL,true,false,false ); - chunk->lpotential = true; - } - } - } - } - if ( stem->rightline != NULL ) { - line = stem->rightline; - line_hv = ( needs_hv && LineFitsHV( line )); - - if ( needs_hv && !line_hv ) - stem->rightline = NULL; - else { - for ( j=0; j<line->pcnt; j++ ) { - pd = line->points[j]; - if ( pd->prevline == line && OnStem( stem,&pd->base,false ) && - IsStemAssignedToPoint( pd,stem,false ) == -1 ) { - chunk = AddToStem( gd,stem,NULL,pd,false,false,false ); - chunk->rpotential = true; - } if ( pd->nextline == line && OnStem( stem,&pd->base,false ) && - IsStemAssignedToPoint( pd,stem,true ) == -1 ) { - chunk = AddToStem( gd,stem,NULL,pd,false,true,false ); - chunk->rpotential = true; - } - } - } - } - } -} - -static struct stemdata *DiagonalCornerStem( struct glyphdata *gd, - struct pointdata *pd,int require_existing ) { - Spline *other = pd->bothedge; - struct pointdata *pfrom = NULL, *pto = NULL, *pd2 = NULL; - double width, length; - struct stemdata *stem; - - pfrom = &gd->points[other->from->ptindex]; - pto = &gd->points[other->to->ptindex]; - if ( pd->symetrical_h && pto->symetrical_h && pd->both_e_t>.9 ) - pd2 = pto; - else if ( pd->symetrical_h && pfrom->symetrical_h && pd->both_e_t<.1 ) - pd2 = pfrom; - else if ( pd->symetrical_v && pto->symetrical_v && pd->both_e_t>.9 ) - pd2 = pto; - else if ( pd->symetrical_v && pfrom->symetrical_v && pd->both_e_t<.1 ) - pd2 = pfrom; - else if ( pd->symetrical_h && other->islinear && other->splines[1].c==0 ) { - pd2 = pfrom; - } else if ( pd->symetrical_v && other->islinear && other->splines[0].c==0 ) { - pd2 = pfrom; - } else -return( NULL ); - - if ( pd->symetrical_v ) - width = (pd->sp->me.x-pd2->sp->me.x); - else - width = (pd->sp->me.y-pd2->sp->me.y); - length = (pd->sp->next->to->me.x-pd->sp->me.x)*(pd->sp->next->to->me.x-pd->sp->me.x) + - (pd->sp->next->to->me.y-pd->sp->me.y)*(pd->sp->next->to->me.y-pd->sp->me.y); - if ( width*width>length ) -return( NULL ); - - stem = FindOrMakeHVStem(gd,pd,pd2,pd->symetrical_h,require_existing); -return( stem ); -} - -static int chunk_cmp( const void *_p1, const void *_p2 ) { - const struct stem_chunk *ch1 = _p1, *ch2 = _p2; - - struct stemdata *stem; - double loff1=0,roff1=0,loff2=0,roff2=0; - - stem = ch1->parent; - if ( stem==NULL ) -return( 0 ); - - if ( ch1->l != NULL ) - loff1 = ( ch1->l->sp->me.x - stem->left.x ) * stem->unit.x + - ( ch1->l->sp->me.y - stem->left.y ) * stem->unit.y; - if ( ch1->r != NULL ) - roff1 = ( ch1->r->sp->me.x - stem->right.x ) * stem->unit.x + - ( ch1->r->sp->me.y - stem->right.y ) * stem->unit.y; - if ( ch2->l != NULL ) - loff2 = ( ch2->l->sp->me.x - stem->left.x ) * stem->unit.x + - ( ch2->l->sp->me.y - stem->left.y ) * stem->unit.y; - if ( ch2->r != NULL ) - roff2 = ( ch2->r->sp->me.x - stem->right.x ) * stem->unit.x + - ( ch2->r->sp->me.y - stem->right.y ) * stem->unit.y; - - if ( loff1>loff2 ) -return( 1 ); - else if ( loff1<loff2 ) -return( -1 ); - else { - if ( roff1>roff2 ) -return( 1 ); - else if ( roff1<roff2 ) -return( -1 ); - else -return( 0 ); - } -} - -static int stem_cmp( const void *_p1, const void *_p2 ) { - struct stemdata * const *st1 = _p1, * const *st2 = _p2; - double start1, end1, start2, end2; - - if ( fabs( (*st1)->unit.x ) > fabs( (*st1)->unit.y )) { - start1 = (*st1)->right.y; end1 = (*st1)->left.y; - start2 = (*st2)->right.y; end2 = (*st2)->left.y; - } else { - start1 = (*st1)->left.x; end1 = (*st1)->right.x; - start2 = (*st2)->left.x; end2 = (*st2)->right.x; - } - - if ( start1 > start2 ) -return( 1 ); - else if ( start1 < start2 ) -return( -1 ); - else { - if ( end1 > end2 ) -return( 1 ); - else if ( end1 < end2 ) -return( -1 ); - else -return( 0 ); - } -} - -static void FixupT( struct pointdata *pd,int stemidx,int isnext, int eidx ) { - /* When we calculated "next/prev_e_t" we deliberately did not use pd1->me */ - /* (because things get hard at intersections) so our t is only an approx-*/ - /* imation. We can do a lot better now */ - Spline *s; - Spline myline; - SplinePoint end1, end2; - double width,t,sign, len, dot; - BasePoint pts[9]; - extended lts[10], sts[10]; - BasePoint diff; - struct stemdata *stem ; - - if ( pd == NULL || stemidx == -1 ) -return; - stem = ( isnext ) ? pd->nextstems[stemidx] : pd->prevstems[stemidx]; - width = ( stem->right.x - stem->left.x )*stem->unit.y - - ( stem->right.y-stem->left.y )*stem->unit.x; - s = ( isnext ) ? pd->nextedges[eidx] : pd->prevedges[eidx]; - if ( s==NULL ) -return; - diff.x = s->to->me.x-s->from->me.x; - diff.y = s->to->me.y-s->from->me.y; - if ( diff.x<.001 && diff.x>-.001 && diff.y<.001 && diff.y>-.001 ) -return; /* Zero length splines give us NaNs */ - len = sqrt( pow( diff.x,2 ) + pow( diff.y,2 )); - dot = ( diff.x*stem->unit.x + diff.y*stem->unit.y )/len; - if ( dot < .0004 && dot > -.0004 ) -return; /* It's orthogonal to our stem */ - - if (( stem->unit.x==1 || stem->unit.x==-1 ) && s->knownlinear ) - t = (pd->sp->me.x-s->from->me.x)/(s->to->me.x-s->from->me.x); - else if (( stem->unit.y==1 || stem->unit.y==-1 ) && s->knownlinear ) - t = (pd->sp->me.y-s->from->me.y)/(s->to->me.y-s->from->me.y); - else { - memset(&myline,0,sizeof(myline)); - memset(&end1,0,sizeof(end1)); - memset(&end2,0,sizeof(end2)); - sign = (( isnext && pd->next_is_l[stemidx] ) || ( !isnext && pd->prev_is_l[stemidx] )) ? 1 : -1; - myline.knownlinear = myline.islinear = true; - end1.me = pd->sp->me; - end2.me.x = pd->sp->me.x+1.1*sign*width*stem->l_to_r.x; - end2.me.y = pd->sp->me.y+1.1*sign*width*stem->l_to_r.y; - end1.nextcp = end1.prevcp = end1.me; - end2.nextcp = end2.prevcp = end2.me; - end1.nonextcp = end1.noprevcp = end2.nonextcp = end2.noprevcp = true; - end1.next = &myline; end2.prev = &myline; - myline.from = &end1; myline.to = &end2; - myline.splines[0].d = end1.me.x; - myline.splines[0].c = end2.me.x-end1.me.x; - myline.splines[1].d = end1.me.y; - myline.splines[1].c = end2.me.y-end1.me.y; - if ( SplinesIntersect(&myline,s,pts,lts,sts)<=0 ) -return; - t = sts[0]; - } - if ( isnan(t)) - IError( "NaN value in FixupT" ); - if ( isnext ) - pd->next_e_t[eidx] = t; - else - pd->prev_e_t[eidx] = t; -} - -/* flags: 1 -- accept curved extrema, 2 -- accept angles, */ -/* 4 -- analyze segments (not just single points) */ -static int IsSplinePeak( struct glyphdata *gd,struct pointdata *pd, - int outer,int is_x,int flags ) { - - double base, next, prev, nextctl, prevctl, unit_p, unit_n; - Spline *s, *snext, *sprev; - struct monotonic **space, *m; - int wprev, wnext, i, desired; - SplinePoint *sp = pd->sp; - - base = ((real *) &sp->me.x)[!is_x]; - nextctl = sp->nonextcp ? base : ((real *) &sp->nextcp.x)[!is_x]; - prevctl = sp->noprevcp ? base : ((real *) &sp->prevcp.x)[!is_x]; - next = prev = base; - snext = sp->next; sprev = sp->prev; - - if ( snext->to == NULL || sprev->from == NULL ) -return( false ); - if (!( flags & 2) && ( sp->nonextcp || sp->noprevcp )) -return( false ); - else if (!( flags & 1 ) && ( pd->colinear )) -return( false ); - - if ( flags & 4 ) { - while ( snext->to->next != NULL && snext->to != sp && next == base ) { - next = ((real *) &snext->to->me.x)[!is_x]; - snext = snext->to->next; - } - - while ( sprev->from->prev != NULL && sprev->from != sp && prev == base ) { - prev = ((real *) &sprev->from->me.x)[!is_x]; - sprev = sprev->from->prev; - } - } else { - next = ((real *) &snext->to->me.x)[!is_x]; - prev = ((real *) &sprev->from->me.x)[!is_x]; - } - - if ( prev<base && next<base && nextctl<=base && prevctl<=base ) - desired = ( outer ) ? -1 : 1; - else if ( prev>base && next>base && prevctl>=base && nextctl>=base ) - desired = ( outer ) ? 1 : -1; - else -return( false ); - - MonotonicFindAt( gd->ms,is_x,((real *) &sp->me.x)[is_x],space = gd->space ); - wprev = wnext = 0; - for ( i=0; space[i]!=NULL; ++i ) { - m = space[i]; - s = m->s; - - if ( s->from == sp ) - wnext = ((&m->xup)[is_x] ? 1 : -1 ); - else if ( s->to == sp ) - wprev = ((&m->xup)[is_x] ? 1 : -1 ); - } - - if ( wnext != 0 && wprev != 0 && wnext != wprev ) { - unit_p = (&pd->prevunit.x)[!is_x]; - unit_n = (&pd->nextunit.x)[!is_x]; - if ( unit_p < unit_n && ( - ( outer && wprev == 1 ) || ( !outer && wprev == -1 ))) -return( desired ); - else if ( unit_p > unit_n && ( - ( outer && wnext == 1 ) || ( !outer && wnext == -1 ))) -return( desired ); - } else { - if ( wnext == desired || wprev == desired ) -return( desired ); - } - -return( false ); -} - -static struct pointdata *FindClosestOpposite( - struct stemdata *stem,struct stem_chunk **chunk,SplinePoint *sp,int *next ) { - - struct pointdata *pd, *ret=NULL; - struct stem_chunk *testchunk; - double test, proj=1e4; - int i, is_l; - - for ( i=0; i<stem->chunk_cnt; ++i ) { - testchunk = &stem->chunks[i]; - pd = NULL; - if ( testchunk->l != NULL && testchunk->l->sp==sp ) { - pd = testchunk->r; - is_l = false; - } else if ( testchunk->r != NULL && testchunk->r->sp==sp ) { - pd = testchunk->l; - is_l = true; - } - - if ( pd != NULL ) { - test = ( pd->sp->me.x-sp->me.x ) * stem->unit.x + - ( pd->sp->me.y-sp->me.y ) * stem->unit.y; - if ( test < 0 ) test = -test; - if ( test < proj ) { - ret = pd; - proj = test; - *chunk = testchunk; - } - } - } - if ( ret != NULL ) - *next = ( is_l ) ? (*chunk)->lnext : (*chunk)->rnext; -return( ret ); -} - -static int ValueChunk( struct glyphdata *gd,struct vchunk *vchunks, - int chcnt,int idx,int l_base ) { - - int peak1=0, peak2=0, val=0; - int i, is_x, base_next, opp_next; - struct pointdata *base, *opp, *frompd, *topd; - struct stem_chunk *chunk = vchunks[idx].chunk, *tchunk; - struct stemdata *stem = chunk->parent; - double norm, dist; - Spline *sbase, *sopp, *other; - - /* If a stem was already present before generating glyph data, */ - /* then it should always be preferred in case of a conflict */ - if ( stem->positioned || chunk->stemcheat ) val++; - - if ( l_base ) { - base = chunk->l; opp = chunk->r; - base_next = chunk->lnext; opp_next = chunk->rnext; - } else { - base = chunk->r; opp = chunk->l; - base_next = chunk->rnext; opp_next = chunk->lnext; - } - sbase = ( base_next ) ? base->sp->next : base->sp->prev; - sopp = ( opp_next ) ? opp->sp->next : opp->sp->prev; - other = ( opp_next ) ? opp->nextedges[0] : opp->prevedges[0]; - - /* If there are 2 conflicting chunks belonging to different stems but */ - /* based on the same point, then we have to decide which stem is "better" */ - /* for that point. We compare stems (or rather chunks) by assigning a */ - /* value to each of them and then prefer the stem whose value is positive. */ - /* A chunk gets a +1 value bonus in the following cases: */ - /* - The stem is vertical/horizontal and splines are curved in the same */ - /* direction at both sides of the chunk; */ - /* - A stem has both its width and the distance between the opposite points */ - /* smaller than another stem; */ - /* - The common side of two stems is a straight line formed by two points */ - /* and the opposite point can be projected to line segment between those */ - /* two points. */ - if ( IsUnitHV( &stem->unit,true ) && !sbase->knownlinear ) { - is_x = (int) rint( stem->unit.y ); - peak1 = ( is_x ) ? base->x_extr : base->y_extr; - peak2 = ( is_x ) ? opp->x_extr : opp->y_extr; - - dist = ( base->base.x - opp->base.x )*stem->unit.x + - ( base->base.y - opp->base.y )*stem->unit.y; - - /* Are there any stems attached to the same base point which */ - /* are narrower than the distance between two points forming the */ - /* given chunk? */ - for ( i=0; i<chcnt; i++ ) { - tchunk = vchunks[i].chunk; - if ( tchunk == NULL || tchunk == chunk || chunk->l == NULL || chunk->r == NULL ) - continue; - norm = tchunk->parent->width; - if ( norm < fabs( dist )) - break; - } - - /* If both points are curved in the same direction, then check also */ - /* the "line of sight" between those points (if there are interventing */ - /* splines, then it is not a real feature bend)*/ - if ( i == chcnt && peak1 + peak2 == 3 && ConnectsAcross( gd,base->sp,opp_next,sopp,0 )) - val++; - } - - frompd = &gd->points[sbase->from->ptindex]; - topd = &gd->points[sbase->to->ptindex]; - - if (IsStemAssignedToPoint( frompd,stem,true ) != -1 && - IsStemAssignedToPoint( topd,stem,false ) != -1 ) - if ( other == sbase ) val++; - - dist = vchunks[idx].dist; - for ( i=0; i<chcnt; i++ ) { - tchunk = vchunks[i].chunk; - if ( tchunk == NULL || tchunk == chunk || - ( vchunks[idx].parallel && !vchunks[i].parallel )) - continue; - if ( vchunks[i].dist <= dist || tchunk->parent->width <= stem->width ) - break; - } - if ( i==chcnt ) val++; - - /* If just one of the checked chunks has both its sides parallel */ - /* to the stem direction, then we consider it is always worth to be output. */ - /* This check was introduced to avoid situations where a stem marking */ - /* a feature termination can be preferred to another stem which controls */ - /* the main part of the same feature */ - if ( vchunks[idx].parallel ) { - for ( i=0; i<chcnt; i++ ) { - if ( vchunks[i].chunk == NULL || vchunks[i].chunk == chunk ) - continue; - if ( vchunks[i].parallel ) - break; - } - if ( i == chcnt ) val++; - } - -return( val ); -} - -static void CheckPotential( struct glyphdata *gd,struct pointdata *pd,int is_next ) { - int i, j, is_l, next1, stemcnt, val; - int val_cnt=0; - BasePoint *lunit, *runit; - struct stemdata **stems; - struct vchunk *vchunks; - struct stem_chunk *cur; - - stemcnt = ( is_next ) ? pd->nextcnt : pd->prevcnt; - stems = ( is_next ) ? pd->nextstems : pd->prevstems; - vchunks = calloc( stemcnt,sizeof( VChunk )); - - for ( i=0; i<stemcnt; i++ ) { - is_l = ( is_next ) ? pd->next_is_l[i] : pd->prev_is_l[i]; - FindClosestOpposite( stems[i],&vchunks[i].chunk,pd->sp,&next1 ); - if ( vchunks[i].chunk == NULL ) - continue; - cur = vchunks[i].chunk; - if ( vchunks[i].value > 0 ) val_cnt++; - vchunks[i].dist = pow( cur->l->base.x - cur->r->base.x,2 ) + - pow( cur->l->base.y - cur->r->base.y,2 ); - lunit = ( cur->lnext ) ? &cur->l->nextunit : &cur->l->prevunit; - runit = ( cur->rnext ) ? &cur->r->nextunit : &cur->r->prevunit; - vchunks[i].parallel = UnitsParallel( lunit,&stems[i]->unit,2 ) && - UnitsParallel( runit,&stems[i]->unit,2 ); - } - - for ( i=0; i<stemcnt; i++ ) if ( vchunks[i].chunk != NULL ) { - vchunks[i].value = ValueChunk( gd,vchunks,stemcnt,i,is_l ); - if ( vchunks[i].value ) val_cnt++; - } - - /* If we was unable to figure out any reasons for which at least */ - /* one of the checked chunks should really be output, then keep */ - /* all the 'potential' flags as they are and do nothing */ - if ( val_cnt > 0 ) { - for ( i=0; i<stemcnt; i++ ) if ( vchunks[i].chunk != NULL ) { - is_l = ( is_next ) ? pd->next_is_l[i] : pd->prev_is_l[i]; - val = vchunks[i].value; - for ( j=0; j<stems[i]->chunk_cnt; j++ ) { - cur = &stems[i]->chunks[j]; - if ( is_l && cur->l == pd ) { - if ( val > 0 ) cur->lpotential = false; - else cur->lpotential = true; - } else if ( !is_l && cur->r == pd ) { - if ( val > 0 ) cur->rpotential = false; - else cur->rpotential = true; - } - } - } - } - free( vchunks ); -} - -static int StemIsActiveAt( struct glyphdata *gd,struct stemdata *stem,double stempos ) { - BasePoint pos,cpos,mpos; - int which; - double test; - double lmin, lmax, rmin, rmax, loff, roff, minoff, maxoff; - struct monotonic **space, *m; - int winding, nw, closest, i, j; - - pos.x = stem->left.x + stempos*stem->unit.x; - pos.y = stem->left.y + stempos*stem->unit.y; - - if ( IsUnitHV( &stem->unit,true )) { - which = stem->unit.x==0; - MonotonicFindAt(gd->ms,which,((real *) &pos.x)[which],space = gd->space); - test = ((real *) &pos.x)[!which]; - - lmin = ( stem->lmax - 2*dist_error_hv < -dist_error_hv ) ? - stem->lmax - 2*dist_error_hv : -dist_error_hv; - lmax = ( stem->lmin + 2*dist_error_hv > dist_error_hv ) ? - stem->lmin + 2*dist_error_hv : dist_error_hv; - rmin = ( stem->rmax - 2*dist_error_hv < -dist_error_hv ) ? - stem->rmax - 2*dist_error_hv : -dist_error_hv; - rmax = ( stem->rmin + 2*dist_error_hv > dist_error_hv ) ? - stem->rmin + 2*dist_error_hv : dist_error_hv; - minoff = test + ( lmin * stem->unit.y - lmax * stem->unit.x ); - maxoff = test + ( lmax * stem->unit.y - lmin * stem->unit.x ); - - winding = 0; closest = -1; - for ( i=0; space[i]!=NULL; ++i ) { - m = space[i]; - nw = ((&m->xup)[which] ? 1 : -1 ); - if ( m->other >= minoff && m->other <= maxoff && nw == 1 ) { - closest = i; - break; - } else if ( m->other > maxoff ) - break; - winding += nw; - } - if ( closest < 0 ) -return( false ); - - cpos.x = ( which ) ? m->other : pos.x ; - cpos.y = ( which ) ? pos.y : m->other ; - loff = ( cpos.x - stem->left.x ) * stem->unit.y - - ( cpos.y - stem->left.y ) * stem->unit.x; - if ( loff > lmax || loff < lmin ) -return( false ); - - j = MatchWinding(space,i,nw,winding,which,0); - if ( j==-1 ) -return( false ); - m = space[j]; - - mpos.x = ( which ) ? m->other : pos.x ; - mpos.y = ( which ) ? pos.y : m->other ; - roff = ( mpos.x - stem->right.x ) * stem->unit.y - - ( mpos.y - stem->right.y ) * stem->unit.x; - if ( roff >= rmin && roff <= rmax ) -return( true ); -return( false ); - } else { -return( StillStem( gd,dist_error_diag,&pos,stem )); - } -} - -/* This function is used to check the distance between a hint's edge */ -/* and a spline and determine the extet where this hint can be */ -/* considered "active". */ -static int WalkSpline( struct glyphdata *gd, struct pointdata *pd,int gonext, - struct stemdata *stem,int is_l,int force_ac,BasePoint *res ) { - - int i, curved; - double off, dist, min, max; - double incr, err; - double t, ratio, width; - Spline *s; - BasePoint *base, *nunit, pos, good; - SplinePoint *sp, *nsp; - struct pointdata *npd; - - err = ( IsUnitHV( &stem->unit,true )) ? dist_error_hv : dist_error_diag; - width = stem->width; - ratio = gd->emsize/( 6 * width ); - if ( err > width/2) err = width/2; - - sp = pd->sp; - base = ( is_l ) ? &stem->left : &stem->right; - min = ( is_l ) ? stem->lmax - 2*err : stem->rmax - 2*err; - max = ( is_l ) ? stem->lmin + 2*err : stem->rmin + 2*err; - - s = ( gonext ) ? sp->next : sp->prev; - nsp = ( gonext ) ? s->to : s->from; - npd = &gd->points[nsp->ptindex]; - nunit = ( gonext ) ? &npd->prevunit : &npd->nextunit; - good = sp->me; - - off = ( nsp->me.x - base->x )*stem->l_to_r.x + - ( nsp->me.y - base->y )*stem->l_to_r.y; - /* Some splines have tiny control points and are almost flat */ - /* think of them as lines then rather than treating them as curves */ - /* figure out how long they remain within a few orthoganal units of */ - /* the point */ - /* We used to check the distance between a control point and a spline */ - /* and consider the segment "flat" if this distance is smaller than */ - /* the normal allowed "error" value. However this method doesn't produce */ - /* consistent results if the spline is not long enough (as usual for */ - /* fonts with quadratic splines). So now we consider a spline "flat" */ - /* only if it never deviates too far from the hint's edge and both */ - /* its terminal points are snappable to the same hint */ - curved = ( IsStemAssignedToPoint( npd,stem,gonext ) == -1 && - ( off < min || off > max || !UnitsParallel( &stem->unit,nunit,true ))); - - /* If a spline does deviate from the edge too far to consider it flat, */ - /* then we calculate the extent where the spline and the edge are still */ - /* close enough to consider the hint active at this zone. If the hint is */ - /* still active at the end of the spline, we can check some subsequent splines */ - /* too. This method produces better effect than any "magic" manipulations */ - /* with control point coordinates, because it takes into account just the */ - /* spline configuration rather than point positions */ - if ( curved ) { - max = err = dist_error_curve; - min = -dist_error_curve; - /* The following statement forces our code to detect an active zone */ - /* even if all checks actually fail. This makes sense for stems */ - /* marking arks and bends */ - if ( force_ac ) - good = ( gonext ) ? sp->nextcp : sp->prevcp; - /* If a spline is closer to the opposite stem edge than to the current edge, then we */ - /* can no longer consider the stem active at this point */ - if ( err > width/2 ) err = width/2; - - t = ( gonext ) ? 0.9999 : 0.0001; - for ( ; ; s = ( gonext ) ? s->to->next : s->from->prev ) { - pos.x = ((s->splines[0].a*t+s->splines[0].b)*t+s->splines[0].c)*t+s->splines[0].d; - pos.y = ((s->splines[1].a*t+s->splines[1].b)*t+s->splines[1].c)*t+s->splines[1].d; - off = ( pos.x - base->x )*stem->l_to_r.x + - ( pos.y - base->y )*stem->l_to_r.y; - dist = ( pos.x - sp->me.x )*stem->unit.x + - ( pos.y - sp->me.y )*stem->unit.y; - nsp = ( gonext ) ? s->to : s->from; - npd = &gd->points[nsp->ptindex]; - if (fabs( off ) < max && fabs( dist ) <= ( width + width * ratio ) && - nsp != sp && npd->colinear && !npd->x_extr && !npd->y_extr && - StillStem( gd,err,&pos,stem )) - good = pos; - else - break; - } - } - t = .5; - incr = ( gonext ) ? .25 : -.25; - for ( i=0; i<6; ++i ) { - pos.x = ((s->splines[0].a*t+s->splines[0].b)*t+s->splines[0].c)*t+s->splines[0].d; - pos.y = ((s->splines[1].a*t+s->splines[1].b)*t+s->splines[1].c)*t+s->splines[1].d; - off = ( pos.x - base->x )*stem->l_to_r.x + - ( pos.y - base->y )*stem->l_to_r.y; - dist = ( pos.x - sp->me.x )*stem->unit.x + - ( pos.y - sp->me.y )*stem->unit.y; - /* Don't check StillStem for non-curved segments, as they are subject */ - /* to further projection-related tests anyway */ - if ( off > min && off < max && ( !curved || - ( fabs( dist ) < ( width + width * ratio ) && - StillStem( gd,err,&pos,stem )))) { - - good = pos; - t += incr; - } else - t -= incr; - incr/=2; - } - *res = good; -return( curved ); -} - -static int AdjustForImperfectSlopeMatch( SplinePoint *sp,BasePoint *pos, - BasePoint *newpos,struct stemdata *stem,int is_l ) { - - double poff, err, min, max; - BasePoint *base; - - base = ( is_l ) ? &stem->left : &stem->right; - err = ( IsUnitHV( &stem->unit,true )) ? dist_error_hv : dist_error_diag; - min = ( is_l ) ? stem->lmax - 2*err : stem->rmax - 2*err; - max = ( is_l ) ? stem->lmin + 2*err : stem->rmin + 2*err; - - /* Possible if the stem unit has been attached to a line. It is */ - /* hard to prevent this */ - if ( min > max ) { - min = stem->lmin; max = stem->lmax; - } - - poff = ( pos->x - base->x )*stem->l_to_r.x + - ( pos->y - base->y )*stem->l_to_r.y; - if ( poff > min && poff < max ) { - *newpos = *pos; -return( false ); - } else if ( poff <= min ) - err = fabs( min ); - else if ( poff >= max ) - err = fabs( max ); - - newpos->x = sp->me.x + err*( pos->x - sp->me.x )/fabs( poff ); - newpos->y = sp->me.y + err*( pos->y - sp->me.y )/fabs( poff ); -return( true ); -} - -static int AddLineSegment( struct stemdata *stem,struct segment *space,int cnt, - int is_l,struct pointdata *pd,int base_next,struct glyphdata *gd ) { - - double s, e, t, dot; - BasePoint stemp, etemp; - BasePoint *start, *end, *par_unit; - int same_dir, corner = 0, par; - int scurved = false, ecurved = false, c, hv; - SplinePoint *sp, *psp, *nsp; - double b; - uint8 extr; - - if ( pd==NULL || (sp = pd->sp)==NULL || sp->ticked || - sp->next==NULL || sp->prev==NULL ) -return( cnt ); - end = &sp->me; - start = &sp->me; - par_unit = ( base_next ) ? &pd->nextunit : &pd->prevunit; - /* Do the spline and the stem unit point in the same direction ? */ - dot = ( stem->unit.x * par_unit->x ) + - ( stem->unit.y * par_unit->y ); - same_dir = (( dot > 0 && base_next ) || ( dot < 0 && !base_next )); - if ( stem->unit.x == 1 ) corner = pd->y_corner; - else if ( stem->unit.y == 1 ) corner = pd->x_corner; - - dot = ( stem->unit.x * pd->nextunit.x ) + - ( stem->unit.y * pd->nextunit.y ); - /* We used to apply normal checks only if the point's unit vector pointing */ - /* in the direction we are going to check is nearly parallel to the stem unit. */ - /* But this is not the best method, because a spline, "parallel" to our */ - /* stem, may actually have filled space at a wrong side. On the other hand, */ - /* sometimes it makes sense to calculate active space even for splines */ - /* connected to our base point under an angle which is too large to consider */ - /* the direction "parallel". So now we check the units' direction first */ - /* and then (just for straight splines) also their parallelity. */ - if (( dot > 0 && same_dir ) || ( dot < 0 && !same_dir )) { - /* If the segment sp-start doesn't have exactly the right slope, then */ - /* we can only use that bit of it which is less than a standard error */ - par = UnitsParallel( &stem->unit,&pd->nextunit,0 ); - if ( !sp->next->knownlinear ) { - ecurved = WalkSpline( gd,pd,true,stem,is_l,par,&etemp ); - /* Can merge, but treat as curved relatively to projections */ - if ( !ecurved ) ecurved = 2; - end = &etemp; - } else if ( par || corner ) { - nsp = sp->next->to; - ecurved = AdjustForImperfectSlopeMatch( sp,&nsp->me,&etemp,stem,is_l ); - end = &etemp; - } - } - dot = ( stem->unit.x * pd->prevunit.x ) + - ( stem->unit.y * pd->prevunit.y ); - if (( dot < 0 && same_dir ) || ( dot > 0 && !same_dir )) { - par = UnitsParallel( &stem->unit,&pd->prevunit,0 ); - if ( !sp->prev->knownlinear ) { - scurved = WalkSpline( gd,pd,false,stem,is_l,par,&stemp ); - if ( !scurved ) scurved = 2; - start = &stemp; - } else if ( par || corner ) { - psp = sp->prev->from; - scurved = AdjustForImperfectSlopeMatch( sp,&psp->me,&stemp,stem,is_l ); - start = &stemp; - } - } - sp->ticked = true; - - s = (start->x-stem->left.x)*stem->unit.x + - (start->y-stem->left.y)*stem->unit.y; - e = ( end->x-stem->left.x)*stem->unit.x + - ( end->y-stem->left.y)*stem->unit.y; - b = (sp->me.x-stem->left.x)*stem->unit.x + - (sp->me.y-stem->left.y)*stem->unit.y; - - if ( s == e ) -return( cnt ); - if ( s > e ) { - t = s; c = scurved; - s = e; e = t; - scurved = ecurved; ecurved = c; - } - space[cnt].start = s; - space[cnt].end = e; - space[cnt].sbase = space[cnt].ebase = b; - space[cnt].scurved = scurved; - space[cnt].ecurved = ecurved; - - hv = IsUnitHV( &stem->unit,true ); - if ( hv ) { - /* For vertical/horizontal stems we assign a special meaning to */ - /* the 'curved' field. It will be non-zero if the key point of */ - /* this segment is positioned on a prominent curve: */ - /* 1 if the inner side of that curve is inside of the contour */ - /* and 2 otherwise. */ - /* Later, if we get a pair of "inner" and "outer" curves, then */ - /* we are probably dealing with a feature's bend which should be */ - /* necessarily marked with a hint. Checks we apply for this type */ - /* of curved segments should be less strict than in other cases. */ - extr = ( hv == 1 ) ? pd->y_extr : pd->x_extr; - space[cnt].curved = extr; - } else { - /* For diagonal stems we consider a segment "curved" if both its */ - /* start and end are curved. Curved segments usually cannot be */ - /* merged (unless scurved or ecurved is equal to 2) and are not */ - /* checked for "projections". */ - space[cnt].curved = scurved && ecurved; - } -return( cnt+1 ); -} - -static int InActive(double projection,struct segment *segments, int cnt) { - int i; - - for ( i=0; i<cnt; ++i ) { - if ( projection>=segments[i].start && projection<=segments[i].end ) -return( true ); - } -return( false ); -} - -static int MergeSegments(struct segment *space, int cnt) { - int i,j; - double middle; - - for ( i=j=0; i<cnt; ++i, ++j ) { - if ( i!=j ) - space[j] = space[i]; - while ( i+1<cnt && space[i+1].start<space[j].end ) { - if ( space[i+1].end >= space[j].end ) { - - /* If there are 2 overlapping segments and neither the */ - /* end of the first segment nor the start of the second */ - /* one are curved we can merge them. Otherwise we have */ - /* to preserve them both, but modify their start/end properties */ - /* so that the overlap is removed */ - if ( space[j].ecurved != 1 && space[i+1].scurved != 1 ) { - space[j].end = space[i+1].end; - space[j].ebase = space[i+1].ebase; - space[j].ecurved = space[i+1].ecurved; - space[j].curved = false; - } else if ( space[j].ecurved != 1 && space[i+1].scurved == 1 ) { - space[i+1].start = space[j].end; - --i; - } else if ( space[j].ecurved == 1 && space[i+1].scurved != 1 ) { - space[j].end = space[i+1].start; - --i; - } else { - middle = (space[j].end + space[i+1].start)/2; - space[j].end = space[i+1].start = middle; - --i; - } - } - ++i; - } - } -return( j ); -} - -static int MergeSegmentsFinal( struct segment *space, int cnt ) { - int i,j; - - for ( i=j=0; i<cnt; ++i, ++j ) { - if ( i!=j ) - space[j] = space[i]; - while ( i+1<cnt && space[i+1].start<=space[j].end ) { - if ( space[i+1].end>space[j].end ) { - space[j].end = space[i+1].end; - space[j].ebase = space[i+1].ebase; - space[j].ecurved = space[i+1].ecurved; - space[j].curved = false; - } - ++i; - } - } -return( j ); -} - -static void FigureStemActive( struct glyphdata *gd, struct stemdata *stem ) { - int i, j, pcnt=0; - struct pointdata *pd, **pspace = gd->pspace; - struct stem_chunk *chunk; - struct segment *lspace = gd->lspace, *rspace = gd->rspace; - struct segment *bothspace = gd->bothspace, *activespace = gd->activespace; - int lcnt, rcnt, bcnt, bpos, acnt, cove, startset, endset; - double middle, width, len, clen, gap, lseg, rseg; - double err, lmin, rmax, loff, roff, last, s, e, sbase, ebase; - double proj, proj2, proj3, orig_proj, ptemp; - - width = stem->width; - - for ( i=0; i<gd->pcnt; ++i ) if ( gd->points[i].sp!=NULL ) - gd->points[i].sp->ticked = false; - - lcnt = rcnt = 0; - for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - if ( chunk->stemcheat ) - continue; - lcnt = AddLineSegment( stem,lspace,lcnt,true ,chunk->l,chunk->lnext,gd ); - rcnt = AddLineSegment( stem,rspace,rcnt,false,chunk->r,chunk->rnext,gd ); - } - bcnt = 0; - if ( lcnt!=0 && rcnt!=0 ) { - /* For curved segments we can extend left and right active segments */ - /* a bit to ensure that they do overlap and thus can be marked with an */ - /* active zone */ - if ( rcnt == lcnt && stem->chunk_cnt == lcnt ) { - for ( i=0; i<lcnt; i++ ) { - /* If it's a feature bend, then our tests should be more liberal */ - cove = (( rspace[i].curved + lspace[i].curved ) == 3 ); - gap = 0; - if ( lspace[i].start>rspace[i].end && lspace[i].scurved && rspace[i].ecurved ) - gap = lspace[i].start-rspace[i].end; - else if ( rspace[i].start>lspace[i].end && rspace[i].scurved && lspace[i].ecurved ) - gap = rspace[i].start-lspace[i].end; - else if ( !cove ) - continue; - - lseg = lspace[i].end - lspace[i].start; - rseg = rspace[i].end - rspace[i].start; - if (( cove && gap < (lseg > rseg ? lseg : rseg )) || - ( gap < ( lseg + rseg )/2 && !stem->chunks[i].stub )) { - if ( lspace[i].ebase<rspace[i].start ) - rspace[i].start = lspace[i].ebase; - else if ( lspace[i].sbase>rspace[i].end ) - rspace[i].end = lspace[i].sbase; - if ( rspace[i].ebase<lspace[i].start ) - lspace[i].start = rspace[i].ebase; - else if ( rspace[i].sbase>lspace[i].end ) - lspace[i].end = rspace[i].sbase; - } - } - } - qsort(lspace,lcnt,sizeof(struct segment),segment_cmp); - qsort(rspace,rcnt,sizeof(struct segment),segment_cmp); - lcnt = MergeSegments( lspace,lcnt ); - rcnt = MergeSegments( rspace,rcnt ); - for ( i=j=bcnt=0; i<lcnt && j<rcnt; ++i ) { - while ( j<rcnt && rspace[j].end<=lspace[i].start ) - ++j; - while ( j<rcnt && rspace[j].start<=lspace[i].end ) { - cove = (( rspace[j].curved + lspace[i].curved ) == 3 ); - - s = ( rspace[j].start > lspace[i].start ) ? - rspace[j].start : lspace[i].start; - e = ( rspace[j].end < lspace[i].end ) ? - rspace[j].end : lspace[i].end; - sbase = ( rspace[j].start > lspace[i].start ) ? - lspace[i].sbase : rspace[j].sbase; - ebase = ( rspace[j].end < lspace[i].end ) ? - lspace[i].ebase : rspace[j].ebase; - - middle = ( lspace[i].start + rspace[j].start )/2; - bothspace[bcnt].start = ( cove && middle < s ) ? middle : s; - if ( rspace[j].start > lspace[i].start ) - bothspace[bcnt].scurved = ( rspace[j].scurved || sbase < s ) ? - rspace[j].scurved : lspace[i].scurved; - else - bothspace[bcnt].scurved = ( lspace[i].scurved || sbase < s ) ? - lspace[i].scurved : rspace[j].scurved; - - middle = ( lspace[i].end + rspace[j].end )/2; - bothspace[bcnt].end = ( cove && middle > e ) ? middle : e; - if ( rspace[j].end < lspace[i].end ) - bothspace[bcnt].ecurved = ( rspace[j].ecurved || ebase > e ) ? - rspace[j].ecurved : lspace[i].ecurved; - else - bothspace[bcnt].ecurved = ( lspace[i].ecurved || ebase > e ) ? - lspace[i].ecurved : rspace[j].ecurved; - - sbase = ( rspace[j].sbase > lspace[i].sbase ) ? - rspace[j].sbase : lspace[i].sbase; - ebase = ( rspace[j].ebase < lspace[i].ebase ) ? - rspace[j].ebase : lspace[i].ebase; - if ( sbase > bothspace[bcnt].end ) - sbase = ebase = bothspace[bcnt].end; - else if ( ebase < bothspace[bcnt].start ) - sbase = ebase = bothspace[bcnt].start; - else if ( ebase < sbase ) - ebase = sbase = ( ebase + sbase )/2; - bothspace[bcnt].sbase = sbase; - bothspace[bcnt].ebase = ebase; - - bothspace[bcnt++].curved = rspace[j].curved || lspace[i].curved; - - if ( rspace[j].end>lspace[i].end ) - break; - ++j; - } - } - } -#if GLYPH_DATA_DEBUG - fprintf( stderr, "Active zones for stem l=%.2f,%.2f r=%.2f,%.2f dir=%.2f,%.2f:\n", - stem->left.x,stem->left.y,stem->right.x,stem->right.y,stem->unit.x,stem->unit.y ); - for ( i=0; i<lcnt; i++ ) { - fprintf( stderr, "\tleft space curved=%d\n",lspace[i].curved ); - fprintf( stderr, "\t\tstart=%.2f,base=%.2f,curved=%d\n", - lspace[i].start,lspace[i].sbase,lspace[i].scurved ); - fprintf( stderr, "\t\tend=%.2f,base=%.2f,curved=%d\n", - lspace[i].end,lspace[i].ebase,lspace[i].ecurved ); - } - for ( i=0; i<rcnt; i++ ) { - fprintf( stderr, "\tright space curved=%d\n",rspace[i].curved ); - fprintf( stderr, "\t\tstart=%.2f,base=%.2f,curved=%d\n", - rspace[i].start,rspace[i].sbase,rspace[i].scurved ); - fprintf( stderr, "\t\tend=%.2f,base=%.2f,curved=%d\n", - rspace[i].end,rspace[i].ebase,rspace[i].ecurved ); - } - for ( i=0; i<bcnt; i++ ) { - fprintf( stderr, "\tboth space\n" ); - fprintf( stderr, "\t\tstart=%.2f,base=%.2f,curved=%d\n", - bothspace[i].start,bothspace[i].sbase,bothspace[i].scurved ); - fprintf( stderr, "\t\tend=%.2f,base=%.2f,curved=%d\n", - bothspace[i].end,bothspace[i].ebase,bothspace[i].ecurved ); - } - fprintf( stderr,"\n" ); -#endif - - err = ( stem->unit.x == 0 || stem->unit.y == 0 ) ? - dist_error_hv : dist_error_diag; - lmin = ( stem->lmin < -err ) ? stem->lmin : -err; - rmax = ( stem->rmax > err ) ? stem->rmax : err; - acnt = 0; - if ( bcnt!=0 ) { - for ( i=0; i<gd->pcnt; ++i ) if ( (pd = &gd->points[i])->sp!=NULL ) { - /* Let's say we have a stem. And then inside that stem we have */ - /* another rectangle. So our first stem isn't really a stem any */ - /* more (because we hit another edge first), yet it's still reasonable*/ - /* to align the original stem */ - /* Now suppose the rectangle is rotated a bit so we can't make */ - /* a stem from it. What do we do here? */ - loff = ( pd->sp->me.x - stem->left.x ) * stem->unit.y - - ( pd->sp->me.y - stem->left.y ) * stem->unit.x; - roff = ( pd->sp->me.x - stem->right.x ) * stem->unit.y - - ( pd->sp->me.y - stem->right.y ) * stem->unit.x; - - if ( loff >= lmin && roff <= rmax ) { - pd->projection = (pd->sp->me.x - stem->left.x)*stem->unit.x + - (pd->sp->me.y - stem->left.y)*stem->unit.y; - if ( InActive(pd->projection,bothspace,bcnt) ) - pspace[pcnt++] = pd; - } - } - qsort(pspace,pcnt,sizeof(struct pointdata *),proj_cmp); - - bpos = i = 0; - while ( bpos<bcnt ) { - if ( bothspace[bpos].curved || pcnt==0 ) { - activespace[acnt++] = bothspace[bpos++]; - } else { - last = bothspace[bpos].start; - startset = false; endset = false; - - if ( bothspace[bpos].scurved || - StemIsActiveAt( gd,stem,bothspace[bpos].start+0.0015 )) { - - activespace[acnt].scurved = bothspace[bpos].scurved; - activespace[acnt].start = bothspace[bpos].start; - startset = true; - } - - /* If the stem is preceded by a curved segment, then skip */ - /* the first point position and start from the next one. */ - /* (Otherwise StemIsActiveAt() may consider the stem is */ - /* "inactive" at the fragment between the start of the active */ - /* space and the first point actually belonging to this stem) */ - if ( bothspace[bpos].scurved ) { - while ( pcnt>i && pspace[i]->projection < bothspace[bpos].sbase ) i++; - - if ( pcnt > i && pspace[i]->projection >= bothspace[bpos].sbase ) { - last = activespace[acnt].end = pspace[i]->projection; - activespace[acnt].ecurved = false; - activespace[acnt].curved = false; - endset=true; - } - } - - while ( i<pcnt && ( - ( !bothspace[bpos].ecurved && pspace[i]->projection<bothspace[bpos].end ) || - ( bothspace[bpos].ecurved && pspace[i]->projection<=bothspace[bpos].ebase ))) { - if ( last==activespace[acnt].start && pspace[i]->projection >= last ) { - - if ( !StemIsActiveAt( gd,stem,last+(( 1.001*pspace[i]->projection-last )/2.001 ))) { - last = activespace[acnt].start = pspace[i]->projection; - activespace[acnt].scurved = false; - startset = true; endset = false; - } else { - last = activespace[acnt].end = pspace[i]->projection; - activespace[acnt].ecurved = false; - activespace[acnt].curved = false; - endset = true; - } - } else if (( last==activespace[acnt].end || !startset ) - && pspace[i]->projection >= last) { - - if ( !StemIsActiveAt( gd,stem,last+(( 1.001*pspace[i]->projection-last )/2.001 )) || - !startset ) { - - if ( startset ) acnt++; - last = activespace[acnt].start = pspace[i]->projection; - activespace[acnt].scurved = false; - startset = true; endset = false; - } else { - last = activespace[acnt].end = pspace[i]->projection; - activespace[acnt].ecurved = false; - activespace[acnt].curved = false; - endset = true; - } - } - ++i; - } - - if (( bothspace[bpos].ecurved || - StemIsActiveAt( gd,stem,bothspace[bpos].end-0.0015 )) && - startset ) { - - activespace[acnt].end = bothspace[bpos].end; - activespace[acnt].ecurved = bothspace[bpos].ecurved; - activespace[acnt].curved = bothspace[bpos].curved; - endset = true; - } - ++bpos; - if ( endset ) ++acnt; - } - } - } - - for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - /* stemcheat 1 -- diagonal edge stem; - * 2 -- diagonal corner stem with a sharp top; - * 3 -- diagonal corner stem with a flat top; - * 4 -- bounding box hint */ - if ( chunk->stemcheat==3 && chunk->l!=NULL && chunk->r!=NULL && - i+1<stem->chunk_cnt && - stem->chunks[i+1].stemcheat==3 && - ( chunk->l==stem->chunks[i+1].l || - chunk->r==stem->chunks[i+1].r )) { - - SplinePoint *sp = chunk->l==stem->chunks[i+1].l ? - chunk->l->sp : chunk->r->sp; - proj = (sp->me.x - stem->left.x) *stem->unit.x + - (sp->me.y - stem->left.y) *stem->unit.y; - - SplinePoint *sp2 = chunk->l==stem->chunks[i+1].l ? - chunk->r->sp : chunk->l->sp; - SplinePoint *sp3 = chunk->l==stem->chunks[i+1].l ? - stem->chunks[i+1].r->sp : stem->chunks[i+1].l->sp; - proj2 = (sp2->me.x - stem->left.x) *stem->unit.x + - (sp2->me.y - stem->left.y) *stem->unit.y; - proj3 = (sp3->me.x - stem->left.x) *stem->unit.x + - (sp3->me.y - stem->left.y) *stem->unit.y; - - if ( proj2>proj3 ) { - ptemp = proj2; proj2 = proj3; proj3 = ptemp; - } - - if ( (proj3-proj2) < width ) { - activespace[acnt ].curved = true; - proj2 -= width/2; - proj3 += width/2; - } else { - activespace[acnt ].curved = false; - } - - activespace[acnt].start = proj2; - activespace[acnt].end = proj3; - activespace[acnt].sbase = activespace[acnt].ebase = proj; - acnt++; - ++i; - } else if ( chunk->stemcheat && chunk->l!=NULL && chunk->r!=NULL ) { - SplinePoint *sp = chunk->l->sp; - proj = ( sp->me.x - stem->left.x ) * stem->unit.x + - ( sp->me.y - stem->left.y ) * stem->unit.y; - orig_proj = proj; - SplinePoint *other = chunk->lnext ? sp->next->to : sp->prev->from; - len = (other->me.x - sp->me.x) * stem->unit.x + - (other->me.y - sp->me.y) * stem->unit.y; - if ( chunk->stemcheat == 2 ) - proj -= width/2; - else if ( len<0 ) - proj -= width; - activespace[acnt].curved = true; - activespace[acnt].start = proj; - activespace[acnt].end = proj+width; - activespace[acnt].sbase = activespace[acnt].ebase = orig_proj; - acnt++; - } - } - - if ( acnt!=0 ) { - stem->activecnt = MergeSegmentsFinal( activespace,acnt ); - stem->active = malloc(acnt*sizeof(struct segment)); - memcpy(stem->active,activespace,acnt*sizeof(struct segment)); - } - - len = clen = 0; - for ( i=0; i<acnt; ++i ) { - if ( stem->active[i].curved ) - clen += stem->active[i].end-stem->active[i].start; - else - len += stem->active[i].end-stem->active[i].start; - } - stem->len = len; stem->clen = len+clen; -} - -static void GDStemsFixupIntersects(struct glyphdata *gd) { - int i, j, stemidx; - struct stemdata *stem; - struct stem_chunk *chunk; - - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - for ( j=0; j<stem->chunk_cnt; ++j ) { - chunk = &stem->chunks[j]; - if ( chunk->l!=NULL ) { - stemidx = IsStemAssignedToPoint( chunk->l,stem,true ); - FixupT( chunk->l,stemidx,true,chunk->l_e_idx ); - stemidx = IsStemAssignedToPoint( chunk->l,stem,false ); - FixupT( chunk->l,stemidx,false,chunk->l_e_idx ); - } - if ( chunk->r!=NULL ) { - stemidx = IsStemAssignedToPoint( chunk->r,stem,true ); - FixupT( chunk->r,stemidx,true,chunk->r_e_idx ); - stemidx = IsStemAssignedToPoint( chunk->r,stem,false ); - FixupT( chunk->r,stemidx,false,chunk->r_e_idx ); - } - } - } -} - -static int StemsWouldConflict( struct stemdata *stem1,struct stemdata *stem2 ) { - double loff, roff, s1, s2, e1, e2; - int acnt1, acnt2; - - if ( stem1 == stem2 || !UnitsParallel( &stem1->unit,&stem2->unit,true )) -return( false ); - - loff = ( stem2->left.x - stem1->left.x ) * stem1->unit.y - - ( stem2->left.y - stem1->left.y ) * stem1->unit.x; - roff = ( stem2->right.x - stem1->right.x ) * stem1->unit.y - - ( stem2->right.y - stem1->right.y ) * stem1->unit.x; - loff = fabs( loff ); roff = fabs( roff ); - if ( loff > stem1->width || roff > stem1->width ) -return( false ); - - acnt1 = stem1->activecnt; - acnt2 = stem2->activecnt; - if ( acnt1 == 0 || acnt2 == 0 ) -return( false ); - s1 = stem1->active[0].start; e1 = stem1->active[acnt1-1].end; - s2 = stem2->active[0].start; e2 = stem2->active[acnt2-1].end; - - loff = ( stem2->left.x - stem1->left.x ) * stem1->unit.x + - ( stem2->left.y - stem1->left.y ) * stem1->unit.y; - if (( s2+loff >= s1 && s2+loff <= e1 ) || ( e2+loff >= s1 && e2+loff <= e1 ) || - ( s2+loff <= s1 && e2+loff >= e1 ) || ( e2+loff <= s1 && s2+loff >= e1 )) -return( true ); - -return( false ); -} - -/* Convert diagonal stems generated for stubs and intersections to horizontal */ -/* or vertical, if they have just one chunk. This should be done before calculating */ -/* active zones, as they are calculated against each stem's unit vector */ -static void GDNormalizeStubs( struct glyphdata *gd ) { - int i, j, hv; - struct stemdata *stem; - struct stem_chunk *chunk; - BasePoint newdir; - - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( stem->positioned ) - continue; - - if ( !IsUnitHV( &stem->unit,true )) { - hv = IsUnitHV( &stem->unit,false ); - if ( hv && StemFitsHV( stem,( hv == 1 ),3 )) { - if ( hv == 2 && stem->unit.y < 0 ) - SwapEdges( gd,stem ); - - newdir.x = fabs( rint( stem->unit.x )); - newdir.y = fabs( rint( stem->unit.y )); - SetStemUnit( stem,newdir ); - - for ( j=0; j<stem->chunk_cnt && stem->leftidx == -1 && stem->rightidx == -1; j++ ) { - chunk = &stem->chunks[j]; - - if ( stem->leftidx == -1 && chunk->l != NULL ) - stem->leftidx = GetValidPointDataIndex( gd,chunk->l->sp,stem ); - if ( stem->rightidx == -1 && chunk->r != NULL ) - stem->rightidx = GetValidPointDataIndex( gd,chunk->r->sp,stem ); - } - } - } - } -} - -static void GDFindUnlikelyStems( struct glyphdata *gd ) { - double width, minl, ratio; - int i, j, k, stem_cnt, ls_cnt, rs_cnt, ltick, rtick; - struct pointdata *lpd, *rpd; - Spline *ls, *rs; - SplinePoint *lsp, *rsp; - BasePoint *lunit, *runit, *slunit, *srunit, *sunit; - struct stemdata *stem, *stem1, *tstem; - struct stemdata **tstems, **lstems, **rstems; - struct stem_chunk *chunk; - - GDStemsFixupIntersects( gd ); - - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - - /* If stem had been already present in the spline char before we */ - /* started generating glyph data, then it should never be */ - /* considered "too big" */ - if ( stem->positioned ) - continue; - - /* If a stem has straight edges, and it is wider than tall */ - /* then it is unlikely to be a real stem */ - width = stem->width; - ratio = IsUnitHV( &stem->unit,true ) ? gd->emsize/( 6 * width ) : -0.25; - stem->toobig = ( stem->clen + stem->clen * ratio < width ); - } - - /* One more check for curved stems. If a stem has just one active */ - /* segment, this segment is curved and the stem has no conflicts, */ - /* then select the active segment length which allows us to consider */ - /* this stem suitable for PS output by such a way, that stems connecting */ - /* the opposite sides of a circle are always accepted */ - for ( i=0; i<gd->stemcnt; ++i ) if ( gd->stems[i].toobig ) { - stem = &gd->stems[i]; - width = stem->width; - - if ( IsUnitHV( &stem->unit,true ) && stem->activecnt == 1 && - stem->active[0].curved && width/2 > dist_error_curve ) { - - for ( j=0; j<gd->stemcnt; ++j) { - stem1 = &gd->stems[j]; - - if ( !stem1->toobig && StemsWouldConflict( stem,stem1 )) - break; - } - - if ( j == gd->stemcnt ) { - minl = sqrt( pow( width/2,2 ) - pow( width/2 - dist_error_curve,2 )); - if ( stem->clen >= minl ) stem->toobig = false; - } - } - } - - /* And finally a check for stubs and feature terminations. We don't */ - /* want such things to be controlled by any special hints, if there */ - /* is already a hint controlling the middle of the same feature */ - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( stem->positioned ) - continue; - - if ( stem->chunk_cnt == 1 && stem->chunks[0].stub & 3 ) { - chunk = &stem->chunks[0]; - slunit = chunk->lnext ? &chunk->l->nextunit : &chunk->l->prevunit; - srunit = chunk->rnext ? &chunk->r->nextunit : &chunk->r->prevunit; - - /* This test is valid only for features which are not exactly horizontal/ */ - /* vertical. But we can't check this using the stem unit, as it may have */ - /* already beeen reset to HV. So we use the units of this stem's base points */ - /* instead. */ - if ( IsUnitHV( slunit,true ) && IsUnitHV( srunit,true )) - continue; - if ( UnitCloserToHV( srunit,slunit ) > 0 ) sunit = srunit; - else sunit = slunit; - - lpd = chunk->l; lsp = lpd->sp; lstems = tstems = NULL; - ls_cnt = 0; - do { - stem_cnt = (( chunk->lnext && lpd == chunk->l ) || - ( !chunk->lnext && lpd != chunk->l )) ? lpd->nextcnt : lpd->prevcnt; - for ( j=0; j<stem_cnt; j++ ) { - tstems= (( chunk->lnext && lpd == chunk->l ) || - ( !chunk->lnext && lpd != chunk->l )) ? lpd->nextstems : lpd->prevstems; - tstem = tstems[j]; - if ( tstem != stem ) { - lstems = tstems; - ls_cnt = stem_cnt; - break; - } - } - if( lstems != NULL ) - break; - ls = ( chunk->lnext ) ? lsp->next : lsp->prev; - if ( ls == NULL ) - break; - lsp = ( chunk->lnext ) ? ls->to : ls->from; - lpd = &gd->points[lsp->ptindex]; - lunit = ( chunk->lnext ) ? &lpd->prevunit : &lpd->nextunit; - } while ( lpd != chunk->l && lpd != chunk->r && - UnitsParallel( lunit,sunit,false )); - - rpd = chunk->r; rsp = rpd->sp; rstems = tstems = NULL; - rs_cnt = 0; - do { - stem_cnt = (( chunk->rnext && rpd == chunk->r ) || - ( !chunk->rnext && rpd != chunk->r )) ? rpd->nextcnt : rpd->prevcnt; - for ( j=0; j<stem_cnt; j++ ) { - tstems= (( chunk->rnext && rpd == chunk->r ) || - ( !chunk->rnext && rpd != chunk->r )) ? rpd->nextstems : rpd->prevstems; - tstem = tstems[j]; - if ( tstem != stem ) { - rstems = tstems; - rs_cnt = stem_cnt; - break; - } - } - if( rstems != NULL ) - break; - rs = ( chunk->rnext ) ? rsp->next : rsp->prev; - if ( rs == NULL ) - break; - rsp = ( chunk->rnext ) ? rs->to : rs->from; - rpd = &gd->points[rsp->ptindex]; - runit = ( chunk->rnext ) ? &rpd->prevunit : &rpd->nextunit; - } while ( rpd != chunk->r && rpd != chunk->l && - UnitsParallel( runit,sunit,false )); - - if ( lstems != NULL && rstems !=NULL ) { - for ( j=0; j<ls_cnt && !stem->toobig; j++ ) { - for ( k=0; k<rs_cnt && !stem->toobig; k++ ) { - if ( lstems[j] == rstems[k] && IsUnitHV( &lstems[j]->unit,true )) { - stem->toobig = true; - } - } - } - } - } - - /* One more check for intersections between a curved segment and a */ - /* straight feature. Imagine a curve intersected by two bars, like in a Euro */ - /* glyph. Very probably we will get two chunks, one controlling the uppest */ - /* two points of intersection, and another the lowest two, and most probably */ - /* these two chunks will get merged into a single stem (so this stem will */ - /* even get an exactly vertical vector). Yet we don't need this stem because */ - /* there is already a stem controlling the middle of the curve (between two */ - /* bars).*/ - else if ( stem->chunk_cnt == 2 && - (( stem->chunks[0].stub & 7 && stem->chunks[1].stub & 6 ) || - ( stem->chunks[0].stub & 6 && stem->chunks[1].stub & 7 ))) { - for ( j=0; j<gd->stemcnt; ++j) { - stem1 = &gd->stems[j]; - if ( !stem1->toobig && StemsWouldConflict( stem,stem1 )) - break; - } - - if ( j < gd->stemcnt ) - stem->toobig = true; - } - } - - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( IsUnitHV( &stem->unit,true )) - continue; - - /* If a diagonal stem doesn't have at least 2 points assigned to */ - /* each edge, then we probably can't instruct it. However we don't */ - /* disable stems which have just one point on each side, if those */ - /* points are inflection points, as such stems may be useful for */ - /* metafont routines */ - if ( stem->lpcnt < 2 || stem->rpcnt < 2 ) { - lpd = rpd = NULL; - for ( j=0; j<stem->chunk_cnt && lpd == NULL && rpd == NULL; j++ ) { - chunk = &stem->chunks[j]; - if ( chunk->l != NULL ) lpd = chunk->l; - if ( chunk->r != NULL ) rpd = chunk->r; - } - if (lpd == NULL || rpd == NULL || - !IsInflectionPoint( gd,lpd ) || !IsInflectionPoint( gd,rpd ) || stem->clen < stem->width ) - stem->toobig = 2; - } else if ( stem->activecnt >= stem->chunk_cnt ) - stem->toobig = 2; - } - - /* When using preexisting stem data, occasionally we can get two slightly */ - /* different stems (one predefined, another recently detected) with nearly */ - /* parallel vectors, sharing some points at both sides. Attempting to instruct */ - /* them both would lead to very odd effects. So we must disable one */ - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( !stem->positioned || IsUnitHV( &stem->unit,true )) - continue; - - for ( j=0; j<gd->stemcnt; ++j ) { - tstem = &gd->stems[j]; - if ( tstem == stem || tstem->toobig || !UnitsParallel( &stem->unit,&tstem->unit,false )) - continue; - - ltick = false; rtick = false; - for ( k=0; k<stem->chunk_cnt && ( !ltick || !rtick ); k++ ) { - chunk = &stem->chunks[k]; - - if ( chunk->l != NULL && - IsStemAssignedToPoint( chunk->l,stem ,chunk->lnext ) != -1 && - IsStemAssignedToPoint( chunk->l,tstem,chunk->lnext ) != -1 ) - ltick = true; - if ( chunk->r != NULL && - IsStemAssignedToPoint( chunk->r,stem ,chunk->rnext ) != -1 && - IsStemAssignedToPoint( chunk->r,tstem,chunk->rnext ) != -1 ) - rtick = true; - } - if ( ltick && rtick ) tstem->toobig = 2; - } - } -} - -static int StemPointOnDiag( struct glyphdata *gd,struct stemdata *stem, - struct pointdata *pd ) { - - struct stemdata *tstem; - int i, is_next, stemcnt; - - if ( gd->only_hv || pd->colinear ) -return( false ); - - is_next = IsStemAssignedToPoint( pd,stem,false ) != -1; - stemcnt = ( is_next ) ? pd->nextcnt : pd->prevcnt; - - for ( i=0; i<stemcnt; i++ ) { - tstem = ( is_next ) ? pd->nextstems[i] : pd->prevstems[i]; - if ( !IsUnitHV( &tstem->unit,true ) && - tstem->lpcnt >= 2 && tstem->rpcnt >=2 ) -return( true ); - } -return( false ); -} - -static void FindRefPointsExisting( struct glyphdata *gd,struct stemdata *stem ) { - int i; - int pos, lbase, rbase, is_x; - struct stem_chunk *chunk; - struct pointdata *pd; - - is_x = (int) rint( stem->unit.y ); - lbase = ((real *) &stem->left.x)[!is_x]; - rbase = ((real *) &stem->right.x)[!is_x]; - - for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - - if ( chunk->ltick ) { - pd = chunk->l; - pos = ((real *) &pd->sp->me.x)[!is_x]; - if ( pos == lbase ) { - pd->value++; - if ( pd->sp->ptindex < gd->realcnt ) - pd->value++; - if ( StemPointOnDiag( gd,stem,pd )) - pd->value++; - } - } - - if ( chunk->rtick ) { - pd = chunk->r; - pos = ((real *) &pd->sp->me.x)[!is_x]; - if ( pos == rbase ) { - pd->value++; - if ( pd->sp->ptindex < gd->realcnt ) - pd->value++; - if ( StemPointOnDiag( gd,stem,pd )) - pd->value++; - } - } - } -} - -static void FindRefPointsNew( struct glyphdata *gd,struct stemdata *stem ) { - int i, j; - int pos, lpos, rpos, testpos, is_x; - int lval, rval; - struct stem_chunk *chunk; - struct pointdata *lmost1, *lmost2, *rmost1, *rmost2; - double llen, prevllen, rlen, prevrlen; - SplinePoint *sp, *tsp; - uint8 *lextr, *rextr; - - is_x = (int) rint( stem->unit.y ); - lpos = ((real *) &stem->left.x)[!is_x]; - rpos = ((real *) &stem->right.x)[!is_x]; - - lmost1 = rmost1 = lmost2 = rmost2 = NULL; - llen = prevllen = rlen = prevrlen = 0; - for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - - if ( chunk->ltick ) { - sp = chunk->l->sp; - pos = ((real *) &sp->me.x)[!is_x]; - lval = 0; - for ( j=0; j<i; j++ ) if ( stem->chunks[j].ltick ) { - tsp = stem->chunks[j].l->sp; - testpos = ((real *) &tsp->me.x)[!is_x]; - if ( pos == testpos ) { - lval = stem->chunks[j].l->value; - stem->chunks[j].l->value++; - /* An additional bonus for points which form together */ - /* a longer stem segment */ - if ( sp->next->to == tsp || sp->prev->from == tsp ) { - llen = fabs(( sp->me.x - tsp->me.x )*stem->unit.x + - ( sp->me.y - tsp->me.y )*stem->unit.y ); - if ( llen > prevllen ) { - lmost1 = stem->chunks[j].l; - lmost2 = chunk->l; - prevllen = llen; - } - } - } - } - chunk->l->value = lval+1; - - if ( lval == 0 && - ( stem->lmin - ( pos - lpos ) > -dist_error_hv ) && - ( stem->lmax - ( pos - lpos ) < dist_error_hv )) - chunk->l->value++; - } - - if ( chunk->rtick ) { - sp = chunk->r->sp; - pos = ((real *) &sp->me.x)[!is_x]; - rval = 0; - for ( j=0; j<i; j++ ) if ( stem->chunks[j].rtick ) { - tsp = stem->chunks[j].r->sp; - testpos = ((real *) &tsp->me.x)[!is_x]; - if ( pos == testpos ) { - rval = stem->chunks[j].r->value; - stem->chunks[j].r->value++; - if ( sp->next->to == tsp || sp->prev->from == tsp ) { - rlen = fabs(( sp->me.x - tsp->me.x )*stem->unit.x + - ( sp->me.y - tsp->me.y )*stem->unit.y ); - if ( rlen > prevrlen ) { - rmost1 = stem->chunks[j].r; - rmost2 = chunk->r; - prevrlen = rlen; - } - } - } - } - chunk->r->value = rval+1; - - if ( rval == 0 && - ( stem->rmin - ( pos - rpos ) > -dist_error_hv ) && - ( stem->rmax - ( pos - rpos ) < dist_error_hv )) - chunk->r->value++; - } - } - if ( lmost1 != NULL && lmost2 != NULL ) { - lmost1->value++; lmost2->value++; - } - if ( rmost1 != NULL && rmost2 != NULL ) { - rmost1->value++; rmost2->value++; - } - - /* Extrema points get an additional value bonus. This should */ - /* prevent us from preferring wrong points for stems controlling */ - /* curved segments */ - /* Third pass to assign bonuses to extrema points (especially */ - /* to those extrema which are opposed to another extremum point) */ - for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - if ( chunk->ltick ) { - lextr = ( is_x ) ? &chunk->l->x_extr : &chunk->l->y_extr; - if ( *lextr ) chunk->l->value++; - } - if ( chunk->rtick ) { - rextr = ( is_x ) ? &chunk->r->x_extr : &chunk->r->y_extr; - if ( *rextr ) chunk->r->value++; - } - - if ( chunk->ltick && chunk->rtick ) { - lextr = ( is_x ) ? &chunk->l->x_extr : &chunk->l->y_extr; - rextr = ( is_x ) ? &chunk->r->x_extr : &chunk->r->y_extr; - if ( *lextr && *rextr ) { - chunk->l->value++; - chunk->r->value++; - } - } - } -} - -static void NormalizeStem( struct glyphdata *gd,struct stemdata *stem ) { - int i; - int lval, rval, val, lset, rset, best; - double loff=0, roff=0; - BasePoint lold, rold; - SplinePoint *lbest, *rbest; - struct stem_chunk *chunk; - - /* First sort the stem chunks by their coordinates */ - if ( IsUnitHV( &stem->unit,true )) { - qsort( stem->chunks,stem->chunk_cnt,sizeof( struct stem_chunk ),chunk_cmp ); - - /* For HV stems we have to check all chunks once more in order */ - /* to figure out "left" and "right" positions most typical */ - /* for this stem. We perform this by assigning a value to */ - /* left and right side of this chunk. */ - - /* First pass to determine some point properties necessary */ - /* for subsequent operations */ - for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - if ( chunk->ltick ) - /* reset the point's "value" to zero */ - chunk->l->value = 0; - if ( chunk->rtick ) - chunk->r->value = 0; - } - - /* Second pass to check which positions relative to stem edges are */ - /* most common for this stem. Each position which repeats */ - /* more than once gets a plus 1 value bonus */ - if ( stem->positioned ) FindRefPointsExisting( gd,stem ); - else FindRefPointsNew( gd,stem ); - - best = -1; val = 0; - for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - lval = ( chunk->l != NULL ) ? chunk->l->value : 0; - rval = ( chunk->r != NULL ) ? chunk->r->value : 0; - if ((( chunk->l != NULL && chunk->l->value > 0 && - GetValidPointDataIndex( gd,chunk->l->sp,stem ) != -1 ) || - ( stem->ghost && stem->width == 21 )) && - (( chunk->r != NULL && chunk->r->value > 0 && - GetValidPointDataIndex( gd,chunk->r->sp,stem ) != -1 ) || - ( stem->ghost && stem->width == 20 )) && lval + rval > val ) { - - best = i; - val = lval + rval; - } - } - if ( best > -1 ) { - if ( !stem->ghost || stem->width == 20 ) { - lold = stem->left; - lbest = stem->chunks[best].l->sp; - stem->left = lbest->me; - stem->leftidx = GetValidPointDataIndex( gd,lbest,stem ); - - /* Now assign "left" and "right" properties of the stem */ - /* to point coordinates taken from the most "typical" chunk */ - /* of this stem. We also have to recalculate stem width and */ - /* left/right offset values */ - loff = ( stem->left.x - lold.x ) * stem->unit.y - - ( stem->left.y - lold.y ) * stem->unit.x; - stem->lmin -= loff; stem->lmax -= loff; - } - if ( !stem->ghost || stem->width == 21 ) { - rold = stem->right; - rbest = stem->chunks[best].r->sp; - stem->right = rbest->me; - stem->rightidx = GetValidPointDataIndex( gd,rbest,stem ); - roff = ( stem->right.x - rold.x ) * stem->unit.y - - ( stem->right.y - rold.y ) * stem->unit.x; - stem->rmin -= roff; stem->rmax -= roff; - } - if ( !stem->ghost ) - stem->width = ( stem->right.x - stem->left.x ) * stem->unit.y - - ( stem->right.y - stem->left.y ) * stem->unit.x; - } else { - for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - if ( chunk->l != NULL && ( !stem->ghost || stem->width == 20 )) { - stem->leftidx = GetValidPointDataIndex( gd,chunk->l->sp,stem ); - } - if ( chunk->r != NULL && ( !stem->ghost || stem->width == 21 )) { - stem->rightidx = GetValidPointDataIndex( gd,chunk->r->sp,stem ); - } - } - } - } else { - qsort( stem->chunks,stem->chunk_cnt,sizeof( struct stem_chunk ),chunk_cmp ); - lset = false; rset = false; - /* Search for a pair of points whose vectors are really parallel. */ - /* This check is necessary because a diagonal stem can start from */ - /* a feature termination, and our checks for such terminations */ - /* are more "liberal" than in other cases. However we don't want */ - /* considering such a pair of points basic for this stem */ - for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - BasePoint *lu, *ru; - if ( chunk->l != NULL && chunk->r != NULL ) { - lu = chunk->lnext ? &chunk->l->nextunit : &chunk->l->prevunit; - ru = chunk->rnext ? &chunk->r->nextunit : &chunk->r->prevunit; - if ( UnitsParallel( lu,ru,true )) { - loff = ( chunk->l->sp->me.x - stem->left.x )*stem->l_to_r.x + - ( chunk->l->sp->me.y - stem->left.y )*stem->l_to_r.y; - roff = ( chunk->r->sp->me.x - stem->right.x )*stem->l_to_r.x + - ( chunk->r->sp->me.y - stem->right.y )*stem->l_to_r.y; - stem->left = chunk->l->sp->me; - stem->right = chunk->r->sp->me; - RecalcStemOffsets( stem,&stem->unit,loff != 0,roff != 0 ); - break; - } - } - } - /* If the above check fails, just select the first point (relatively) */ - /* to the stem direction both at the left and the right edge */ - if ( i == stem->chunk_cnt ) for ( i=0; i<stem->chunk_cnt; ++i ) { - chunk = &stem->chunks[i]; - if ( !lset && chunk->l != NULL ) { - loff = ( chunk->l->sp->me.x - stem->left.x )*stem->l_to_r.x + - ( chunk->l->sp->me.y - stem->left.y )*stem->l_to_r.y; - stem->left = chunk->l->sp->me; - lset = true; - } - if ( !rset && chunk->r != NULL ) { - roff = ( chunk->r->sp->me.x - stem->right.x )*stem->l_to_r.x + - ( chunk->r->sp->me.y - stem->right.y )*stem->l_to_r.y; - stem->right = chunk->r->sp->me; - rset = true; - } - if ( lset && rset ) { - RecalcStemOffsets( stem,&stem->unit,loff != 0,roff != 0 ); - break; - } - } - } -} - -static void AssignPointsToBBoxHint( struct glyphdata *gd,DBounds *bounds, - struct stemdata *stem,int is_v ) { - - double min, max, test, left, right; - double dist, prevdist; - int i, j; - int lcnt=0, rcnt=0, closest; - BasePoint dir; - SplinePoint **lpoints, **rpoints; - struct pointdata *pd, *pd1, *pd2; - - lpoints = calloc( gd->pcnt,sizeof( SplinePoint *)); - rpoints = calloc( gd->pcnt,sizeof( SplinePoint *)); - dir.x = !is_v; dir.y = is_v; - for ( i=0; i<gd->pcnt; ++i ) if ( gd->points[i].sp!=NULL ) { - pd = &gd->points[i]; - min = ( is_v ) ? bounds->minx : bounds->miny; - max = ( is_v ) ? bounds->maxx : bounds->maxy; - test = ( is_v ) ? pd->base.x : pd->base.y; - if ( test >= min && test < min + dist_error_hv && ( - IsCorrectSide( gd,pd,true,is_v,&dir ) || IsCorrectSide( gd,pd,false,is_v,&dir ))) - lpoints[lcnt++] = pd->sp; - else if ( test > max - dist_error_hv && test <= max && ( - IsCorrectSide( gd,pd,true,!is_v,&dir ) || IsCorrectSide( gd,pd,false,!is_v,&dir ))) - rpoints[rcnt++] = pd->sp; - } - if ( lcnt > 0 && rcnt > 0 ) { - if ( stem == NULL ) { - stem = NewStem( gd,&dir,&lpoints[0]->me,&rpoints[0]->me ); - stem->bbox = true; - stem->len = stem->width; - stem->leftidx = GetValidPointDataIndex( gd,lpoints[0],stem ); - stem->rightidx = GetValidPointDataIndex( gd,rpoints[0],stem ); - } - for ( i=0; i<lcnt; ++i ) { - closest = -1; - dist = 1e4; prevdist = 1e4; - for ( j=0; j<rcnt; ++j ) { - left = ( is_v ) ? lpoints[i]->me.y : lpoints[i]->me.x; - right = ( is_v ) ? rpoints[j]->me.y : rpoints[j]->me.x; - dist = fabs( left - right ); - if ( dist < prevdist ) { - closest = j; - prevdist = dist; - } - } - pd1 = &gd->points[lpoints[i]->ptindex]; - pd2 = &gd->points[rpoints[closest]->ptindex]; - AddToStem( gd,stem,pd1,pd2,false,true,4 ); - } - qsort( stem->chunks,stem->chunk_cnt,sizeof( struct stem_chunk ),chunk_cmp ); - } - free( lpoints ); - free( rpoints ); -} - -static void CheckForBoundingBoxHints( struct glyphdata *gd ) { - /* Adobe seems to add hints at the bounding boxes of glyphs with no hints */ - int i, hv; - int hcnt=0, vcnt=0; - double cw, ch; - struct stemdata *stem, *hstem=NULL,*vstem=NULL; - DBounds bounds; - - SplineCharFindBounds( gd->sc,&bounds ); - - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - hv = IsUnitHV( &stem->unit,true ); - if ( !hv ) - continue; - if ( stem->toobig ) { - if ( stem->left.x == bounds.minx && stem->right.x == bounds.maxx ) - vstem = stem; - else if ( stem->right.y == bounds.miny && stem->left.y == bounds.maxy ) - hstem = stem; - continue; - } - if ( hv == 1 ) { - if ( stem->bbox ) hstem = stem; - else ++hcnt; - } else if ( hv == 2 ) { - if ( stem->bbox ) vstem = stem; - else ++vcnt; - } - } - if ( hcnt!=0 && vcnt!=0 && - ( hstem == NULL || !hstem->positioned ) && - ( vstem == NULL || !vstem->positioned )) -return; - - ch = bounds.maxy - bounds.miny; - cw = bounds.maxx - bounds.minx; - - if ( ch > 0 && (( hstem != NULL && hstem->positioned ) || - ( hcnt == 0 && ch < gd->emsize/3 ))) { - if ( hstem != NULL && hstem->toobig ) hstem->toobig = false; - AssignPointsToBBoxHint( gd,&bounds,hstem,false ); - if ( hstem != NULL ) NormalizeStem( gd,hstem ); - } - if ( cw > 0 && (( vstem != NULL && vstem->positioned ) || - ( vcnt == 0 && cw < gd->emsize/3 ))) { - if ( vstem != NULL && vstem->toobig ) vstem->toobig = false; - AssignPointsToBBoxHint( gd,&bounds,vstem,true ); - if ( vstem != NULL ) NormalizeStem( gd,vstem ); - } -} - -static struct stemdata *FindOrMakeGhostStem( struct glyphdata *gd, - SplinePoint *sp,int blue,double width ) { - int i, j, hasl, hasr; - struct stemdata *stem=NULL, *tstem; - struct stem_chunk *chunk; - BasePoint dir,left,right; - double min, max; - - dir.x = 1; dir.y = 0; - for ( i=0; i<gd->stemcnt; ++i ) { - tstem = &gd->stems[i]; - if ( tstem->blue == blue && tstem->ghost && tstem->width == width ) { - stem = tstem; - break; - /* If the stem controlling this blue zone is not for a ghost hint, */ - /* then we check if it has both left and right points, to ensure that */ - /* we don't occasionally assign an additional point to a stem which */ - /* has already been rejected in favor of another stem */ - } else if ( tstem->blue == blue && !tstem->ghost && !tstem->toobig ) { - min = ( width == 20 ) ? tstem->left.y - tstem->lmin - 2*dist_error_hv : - tstem->right.y - tstem->rmin - 2*dist_error_hv; - max = ( width == 20 ) ? tstem->left.y - tstem->lmax + 2*dist_error_hv : - tstem->right.y - tstem->rmax + 2*dist_error_hv; - - if ( sp->me.y <= min || sp->me.y >= max ) - continue; - - hasl = false; hasr = false; j = 0; - while ( j < tstem->chunk_cnt && ( !hasl || !hasr )) { - chunk = &tstem->chunks[j]; - if ( chunk->l != NULL && !chunk->lpotential ) - hasl = true; - if ( chunk->r != NULL && !chunk->rpotential ) - hasr = true; - j++; - } - if ( hasl && hasr ) { - stem = tstem; - break; - } - } - } - - if ( stem == NULL ) { - left.x = right.x = sp->me.x; - left.y = ( width == 21 ) ? sp->me.y + 21 : sp->me.y; - right.y = ( width == 21 ) ? sp->me.y : sp->me.y - 20; - - stem = NewStem( gd,&dir,&left,&right ); - stem->ghost = true; - stem->width = width; - stem->blue = blue; - } -return( stem ); -} - -static int AddGhostSegment( struct pointdata *pd,int cnt,double base,struct segment *space ) { - double s, e, temp, pos, spos, epos; - SplinePoint *sp, *nsp, *nsp2, *psp, *psp2; - - sp = nsp = psp = pd->sp; - pos = pd->sp->me.y; - - /* First check if there are points on the same line lying further */ - /* in the desired direction */ - if (( sp->next != NULL ) && ( sp->next->to->me.y == pos )) - nsp = sp->next->to; - if (( sp->prev != NULL ) && ( sp->prev->from->me.y == pos )) - psp = sp->prev->from; - - if ( psp != sp ) { - s = psp->me.x; - } else if ( psp->noprevcp ) { - psp2 = psp->prev->from; - if ( psp2->me.y != psp->me.y ) { - s = ( psp->me.x - psp2->me.x )/( psp->me.y - psp2->me.y )*20.0; - if ( s < 0 ) s = -s; - if ( psp2->me.x<psp->me.x ) - s = ( psp->me.x-psp2->me.x < s ) ? psp2->me.x : psp->me.x-s; - else - s = ( psp2->me.x-psp->me.x < s ) ? psp2->me.x : psp->me.x+s; - } else - s = psp->me.x; - } else { - s = ( pd->sp->me.x + psp->prevcp.x )/2; - } - - if ( nsp != sp ) { - e = nsp->me.x; - } else if ( nsp->nonextcp ) { - nsp2 = nsp->next->to; - if ( nsp2->me.y != nsp->me.y ) { - e = ( nsp->me.x - nsp2->me.x )/( nsp->me.y - nsp2->me.y )*20.0; - if ( e < 0 ) e = -e; - if ( nsp2->me.x<nsp->me.x ) - e = ( nsp->me.x-nsp2->me.x < e ) ? nsp2->me.x : nsp->me.x-e; - else - e = ( nsp2->me.x-nsp->me.x < e ) ? nsp2->me.x : nsp->me.x+e; - } else - e = nsp->me.x; - } else { - e = ( pd->sp->me.x + nsp->nextcp.x )/2; - } - - spos = psp->me.x; epos = nsp->me.x; - if ( s>e ) { - temp = s; s = e; e = temp; - temp = spos; spos = epos; epos = temp; - } - - space[cnt].start = s - base; - space[cnt].end = e - base; - space[cnt].sbase = spos - base; - space[cnt].ebase = epos - base; - space[cnt].ecurved = space[cnt].scurved = space[cnt].curved = ( false ); - - return( cnt+1 ); -} - -static void FigureGhostActive( struct glyphdata *gd,struct stemdata *stem ) { - int acnt, i; - real len = 0; - struct segment *activespace = gd->activespace; - struct pointdata *valid; - - if ( !stem->ghost ) -return; - - acnt = 0; - for ( i=0; i<stem->chunk_cnt; ++i ) { - valid = ( stem->chunks[i].l != NULL) ? - stem->chunks[i].l : stem->chunks[i].r; - acnt = AddGhostSegment( valid,acnt,stem->left.x,activespace ); - } - qsort(activespace,acnt,sizeof(struct segment),segment_cmp); - acnt = MergeSegments( activespace,acnt ); - stem->activecnt = acnt; - if ( acnt!=0 ) { - stem->active = malloc(acnt*sizeof(struct segment)); - memcpy( stem->active,activespace,acnt*sizeof( struct segment )); - } - - for ( i=0; i<acnt; ++i ) { - len += stem->active[i].end-stem->active[i].start; - } - stem->clen = stem->len = len; -} - -static void CheckForGhostHints( struct glyphdata *gd ) { - /* PostScript doesn't allow a hint to stretch from one alignment zone to */ - /* another. (Alignment zones are the things in bluevalues). */ - /* Oops, I got this wrong. PS doesn't allow a hint to start in a bottom */ - /* zone and stretch to a top zone. Everything in OtherBlues is a bottom */ - /* zone. The baseline entry in BlueValues is also a bottom zone. Every- */ - /* thing else in BlueValues is a top-zone. */ - /* This means */ - /* that we can't define a horizontal stem hint which stretches from */ - /* the baseline to the top of a capital I, or the x-height of lower i */ - /* If we find any such hints we must remove them, and replace them with */ - /* ghost hints. The bottom hint has height -21, and the top -20 */ - BlueData *bd = &gd->bd; - struct stemdata *stem; - struct pointdata *pd; - real base; - int i, j, leftfound, rightfound, has_h, peak, fuzz; - - fuzz = gd->fuzz; - - /* look for any stems stretching from one zone to another and remove them */ - /* (I used to turn them into ghost hints here, but that didn't work (for */ - /* example on "E" where we don't need any ghosts from the big stem because*/ - /* the narrow stems provide the hints that PS needs */ - /* However, there are counter-examples. in Garamond-Pro the "T" character */ - /* has a horizontal stem at the top which stretches between two adjacent */ - /* bluezones. Removing it is wrong. Um... Thanks Adobe */ - /* I misunderstood. Both of these were top-zones */ - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( IsUnitHV( &stem->unit,true ) != 1) - continue; - - leftfound = rightfound = -1; - for ( j=0; j<bd->bluecnt; ++j ) { - if ( stem->left.y>=bd->blues[j][0]-fuzz && stem->left.y<=bd->blues[j][1]+fuzz ) - leftfound = j; - else if ( stem->right.y>=bd->blues[j][0]-fuzz && stem->right.y<=bd->blues[j][1]+fuzz ) - rightfound = j; - } - /* Assign value 2 to indicate this stem should be ignored also for TTF instrs */ - if ( leftfound !=-1 && rightfound !=-1 && - ( stem->left.y > 0 && stem->right.y <= 0 )) - stem->toobig = 2; - /* Otherwise mark the stem as controlling a specific blue zone */ - else if ( leftfound != -1 && ( rightfound == -1 || stem->left.y > 0 )) - stem->blue = leftfound; - else if ( rightfound != -1 && ( leftfound == -1 || stem->right.y <= 0 )) - stem->blue = rightfound; - } - - /* Now look and see if we can find any edges which lie in */ - /* these zones. Edges which are not currently in hints */ - /* Use the winding number to determine top or bottom */ - for ( i=0; i<gd->pcnt; ++i ) if ( gd->points[i].sp!=NULL ) { - has_h = false; - for ( j=0; j<gd->points[i].prevcnt; j++ ) { - stem = gd->points[i].prevstems[j]; - if ( !stem->toobig && IsUnitHV( &stem->unit,true ) == 1 ) { - has_h = true; - break; - } - } - for ( j=0; j<gd->points[i].nextcnt; j++ ) { - stem = gd->points[i].nextstems[j]; - if ( !stem->toobig && IsUnitHV( &stem->unit,true ) == 1 ) { - has_h = true; - break; - } - } - if ( has_h ) - continue; - - pd = &gd->points[i]; - base = pd->sp->me.y; - for ( j=0; j<bd->bluecnt; ++j ) { - if ( base>=bd->blues[j][0]-fuzz && base<=bd->blues[j][1]+fuzz ) { - peak = IsSplinePeak( gd,pd,false,false,7 ); - if ( peak > 0 ) { - stem = FindOrMakeGhostStem( gd,pd->sp,j,20 ); - AddToStem( gd,stem,pd,NULL,2,false,false ); - } else if ( peak < 0 ) { - stem = FindOrMakeGhostStem( gd,pd->sp,j,21 ); - AddToStem( gd,stem,NULL,pd,2,false,false ); - } - } - } - } - - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( !stem->ghost ) - continue; - NormalizeStem( gd,stem ); - FigureGhostActive( gd,stem ); - } -} - -static void MarkDStemCorner( struct glyphdata *gd,struct pointdata *pd ) { - int x_dir = pd->x_corner; - int hv, is_l, i, peak, has_stem = false; - struct stemdata *stem; - BasePoint left,right,unit; - - for ( i=0; i<pd->prevcnt && !has_stem; i++ ) { - stem = pd->prevstems[i]; - hv = IsUnitHV( &stem->unit,true ); - if ( !stem->toobig && ( - ( x_dir && hv == 1 ) || - ( !x_dir && hv == 2 ))) - has_stem = true; - } - for ( i=0; i<pd->nextcnt && !has_stem; i++ ) { - stem = pd->nextstems[i]; - hv = IsUnitHV( &stem->unit,true ); - if ( !stem->toobig && ( - ( x_dir && hv == 1 ) || - ( !x_dir && hv == 2 ))) - has_stem = true; - } - if ( has_stem ) -return; - - peak = IsSplinePeak( gd,pd,x_dir,x_dir,2 ); - unit.x = !x_dir; unit.y = x_dir; - - if ( peak > 0 ) { - left.x = x_dir ? pd->sp->me.x + 21 : pd->sp->me.x; - right.x = x_dir ? pd->sp->me.x : pd->sp->me.x; - left.y = x_dir ? pd->sp->me.y : pd->sp->me.y; - right.y = x_dir ? pd->sp->me.y : pd->sp->me.y - 20; - - } else if ( peak < 0 ) { - left.x = x_dir ? pd->sp->me.x : pd->sp->me.x; - right.x = x_dir ? pd->sp->me.x - 20 : pd->sp->me.x; - left.y = x_dir ? pd->sp->me.y : pd->sp->me.y + 21; - right.y = x_dir ? pd->sp->me.y : pd->sp->me.y; - } - is_l = IsCorrectSide( gd,pd,true,true,&unit ); - for ( i=0; i<gd->stemcnt; i++ ) { - stem = &gd->stems[i]; - if (!stem->toobig && UnitsParallel( &unit,&stem->unit,true ) && - OnStem( stem,&pd->sp->me,is_l )) - break; - } - if ( i == gd->stemcnt ) { - stem = NewStem( gd,&unit,&left,&right ); - stem->ghost = 2; - } - AddToStem( gd,stem,pd,NULL,2,false,false ); -} - -static void MarkDStemCorners( struct glyphdata *gd ) { - struct stemdata *stem; - struct stem_chunk *schunk, *echunk; - int i; - - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( stem->toobig || IsUnitHV( &stem->unit,true )) - continue; - - schunk = &stem->chunks[0]; - echunk = &stem->chunks[stem->chunk_cnt - 1]; - - if ( schunk->l != NULL && schunk->r != NULL && - fabs( schunk->l->base.x - schunk->r->base.x ) > dist_error_hv && - fabs( schunk->l->base.y - schunk->r->base.y ) > dist_error_hv && ( - ( schunk->l->x_corner == 1 && schunk->r->y_corner == 1 ) || - ( schunk->l->y_corner == 1 && schunk->r->x_corner == 1 ))) { - MarkDStemCorner( gd,schunk->l ); - MarkDStemCorner( gd,schunk->r ); - } - if ( echunk->l != NULL && echunk->r != NULL && - fabs( echunk->l->base.x - echunk->r->base.x ) > dist_error_hv && - fabs( echunk->l->base.y - echunk->r->base.y ) > dist_error_hv && ( - ( echunk->l->x_corner == 1 && echunk->r->y_corner == 1 ) || - ( echunk->l->y_corner == 1 && echunk->r->x_corner == 1 ))) { - MarkDStemCorner( gd,echunk->l ); - MarkDStemCorner( gd,echunk->r ); - } - } -} - -#if GLYPH_DATA_DEBUG -static void DumpGlyphData( struct glyphdata *gd ) { - int i, j; - struct stemdata *stem; - struct linedata *line; - struct stem_chunk *chunk; - - if ( gd->linecnt > 0 ) - fprintf( stderr, "\nDumping line data for %s\n",gd->sc->name ); - for ( i=0; i<gd->linecnt; ++i ) { - line = &gd->lines[i]; - fprintf( stderr, "line vector=%.4f,%.4f base=%.2f,%.2f length=%.4f\n", - line->unit.x,line->unit.y,line->online.x,line->online.y,line->length ); - for( j=0; j<line->pcnt;++j ) { - fprintf( stderr, "\tpoint num=%d, x=%.2f, y=%.2f, prev=%d, next=%d\n", - line->points[j]->sp->ttfindex, line->points[j]->sp->me.x, - line->points[j]->sp->me.y, - line->points[j]->prevline==line, line->points[j]->nextline==line ); - } - fprintf( stderr, "\n" ); - } - - if ( gd->stemcnt > 0 ) - fprintf( stderr, "\nDumping stem data for %s\n",gd->sc->name ); - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - fprintf( stderr, "stem l=%.2f,%.2f idx=%d r=%.2f,%.2f idx=%d vector=%.4f,%.4f\n\twidth=%.2f chunk_cnt=%d len=%.4f clen=%.4f ghost=%d blue=%d toobig=%d\n\tlmin=%.2f,lmax=%.2f,rmin=%.2f,rmax=%.2f,lpcnt=%d,rpcnt=%d\n", - stem->left.x,stem->left.y,stem->leftidx, - stem->right.x,stem->right.y,stem->rightidx, - stem->unit.x,stem->unit.y,stem->width, - stem->chunk_cnt,stem->len,stem->clen,stem->ghost,stem->blue,stem->toobig, - stem->lmin,stem->lmax,stem->rmin,stem->rmax,stem->lpcnt,stem->rpcnt ); - for ( j=0; j<stem->chunk_cnt; ++j ) { - chunk = &stem->chunks[j]; - if ( chunk->l!=NULL && chunk->r!=NULL ) - fprintf (stderr, "\tchunk l=%.2f,%.2f potential=%d r=%.2f,%.2f potential=%d stub=%d\n", - chunk->l->sp->me.x, chunk->l->sp->me.y, chunk->lpotential, - chunk->r->sp->me.x, chunk->r->sp->me.y, chunk->rpotential, chunk->stub ); - else if ( chunk->l!=NULL ) - fprintf (stderr, "\tchunk l=%.2f,%.2f potential=%d\n", - chunk->l->sp->me.x, chunk->l->sp->me.y, chunk->lpotential); - else if ( chunk->r!=NULL ) - fprintf (stderr, "\tchunk r=%.2f,%.2f potential=%d\n", - chunk->r->sp->me.x, chunk->r->sp->me.y, chunk->rpotential); - } - fprintf( stderr, "\n" ); - } - - if ( gd->hbundle != NULL || gd->vbundle != NULL ) - fprintf( stderr, "\nDumping HV stem bundles for %s\n",gd->sc->name ); - if ( gd->hbundle != NULL ) for ( i=0; i<gd->hbundle->cnt; i++ ) { - stem = gd->hbundle->stemlist[i]; - fprintf( stderr, "H stem l=%.2f,%.2f r=%.2f,%.2f slave=%d\n", - stem->left.x,stem->left.y,stem->right.x,stem->right.y,stem->master!=NULL ); - if ( stem->dep_cnt > 0 ) for ( j=0; j<stem->dep_cnt; j++ ) { - fprintf( stderr, "\tslave l=%.2f,%.2f r=%.2f,%.2f mode=%c left=%d\n", - stem->dependent[j].stem->left.x,stem->dependent[j].stem->left.y, - stem->dependent[j].stem->right.x,stem->dependent[j].stem->right.y, - stem->dependent[j].dep_type,stem->dependent[j].lbase ); - } - if ( stem->serif_cnt > 0 ) for ( j=0; j<stem->serif_cnt; j++ ) { - fprintf( stderr, "\tserif l=%.2f,%.2f r=%.2f,%.2f ball=%d left=%d\n", - stem->serifs[j].stem->left.x,stem->serifs[j].stem->left.y, - stem->serifs[j].stem->right.x,stem->serifs[j].stem->right.y, - stem->serifs[j].is_ball,stem->serifs[j].lbase ); - } - } - fprintf( stderr, "\n" ); - if ( gd->vbundle != NULL ) for ( i=0; i<gd->vbundle->cnt; i++ ) { - stem = gd->vbundle->stemlist[i]; - fprintf( stderr, "V stem l=%.2f,%.2f r=%.2f,%.2f slave=%d\n", - stem->left.x,stem->left.y,stem->right.x,stem->right.y,stem->master!=NULL ); - if ( stem->dep_cnt > 0 ) for ( j=0; j<stem->dep_cnt; j++ ) { - fprintf( stderr, "\tslave l=%.2f,%.2f r=%.2f,%.2f mode=%c left=%d\n", - stem->dependent[j].stem->left.x,stem->dependent[j].stem->left.y, - stem->dependent[j].stem->right.x,stem->dependent[j].stem->right.y, - stem->dependent[j].dep_type,stem->dependent[j].lbase ); - } - if ( stem->serif_cnt > 0 ) for ( j=0; j<stem->serif_cnt; j++ ) { - fprintf( stderr, "\tserif l=%.2f,%.2f r=%.2f,%.2f ball=%d left=%d\n", - stem->serifs[j].stem->left.x,stem->serifs[j].stem->left.y, - stem->serifs[j].stem->right.x,stem->serifs[j].stem->right.y, - stem->serifs[j].is_ball,stem->serifs[j].lbase ); - } - if ( stem->prev_c_m != NULL ) { - fprintf( stderr,"\tprev counter master: l=%.2f r=%.2f\n", - stem->prev_c_m->left.x,stem->prev_c_m->right.x ); - } - if ( stem->next_c_m != NULL ) { - fprintf( stderr,"\tnext counter master: l=%.2f r=%.2f\n", - stem->next_c_m->left.x,stem->next_c_m->right.x ); - } - } - fprintf( stderr, "\n" ); - - if ( gd->ibundle != NULL ) for ( i=0; i<gd->ibundle->cnt; i++ ) { - stem = gd->ibundle->stemlist[i]; - fprintf( stderr, "I stem l=%.2f,%.2f r=%.2f,%.2f slave=%d\n", - stem->left.x,stem->left.y,stem->right.x,stem->right.y,stem->master!=NULL ); - if ( stem->dep_cnt > 0 ) for ( j=0; j<stem->dep_cnt; j++ ) { - fprintf( stderr, "\tslave l=%.2f,%.2f r=%.2f,%.2f mode=%c left=%d\n", - stem->dependent[j].stem->left.x,stem->dependent[j].stem->left.y, - stem->dependent[j].stem->right.x,stem->dependent[j].stem->right.y, - stem->dependent[j].dep_type,stem->dependent[j].lbase ); - } - if ( stem->serif_cnt > 0 ) for ( j=0; j<stem->serif_cnt; j++ ) { - fprintf( stderr, "\tserif l=%.2f,%.2f r=%.2f,%.2f ball=%d left=%d\n", - stem->serifs[j].stem->left.x,stem->serifs[j].stem->left.y, - stem->serifs[j].stem->right.x,stem->serifs[j].stem->right.y, - stem->serifs[j].is_ball,stem->serifs[j].lbase ); - } - } - fprintf( stderr, "\n" ); -} -#endif - -static void AssignPointsToStems( struct glyphdata *gd,int startnum,DBounds *bounds ) { - int i; - struct pointdata *pd; - struct stemdata *stem = NULL; - BasePoint dir; - - for ( i=0; i<gd->pcnt; ++i ) if ( gd->points[i].sp!=NULL ) { - pd = &gd->points[i]; - if ( pd->prev_e_cnt > 0 ) - BuildStem( gd,pd,false,true,true,0 ); - else - HalfStemNoOpposite( gd,pd,stem,&pd->prevunit,false ); - - if ( pd->next_e_cnt > 0 ) - BuildStem( gd,pd,true,true,true,0 ); - else - HalfStemNoOpposite( gd,pd,stem,&pd->nextunit,true ); - - if ( pd->x_corner ) { - if ( pd->bothedge!=NULL ) - stem = DiagonalCornerStem( gd,pd,true ); - dir.x = 0; dir.y = 1; - HalfStemNoOpposite( gd,pd,stem,&dir,2 ); - } else if ( pd->y_corner ) { - if ( pd->bothedge!=NULL ) - stem = DiagonalCornerStem( gd,pd,true ); - dir.x = 1; dir.y = 0; - HalfStemNoOpposite( gd,pd,stem,&dir,2 ); - } - } - gd->lspace = malloc(gd->pcnt*sizeof(struct segment)); - gd->rspace = malloc(gd->pcnt*sizeof(struct segment)); - gd->bothspace = malloc(3*gd->pcnt*sizeof(struct segment)); - gd->activespace = malloc(3*gd->pcnt*sizeof(struct segment)); -#if GLYPH_DATA_DEBUG - fprintf( stderr,"Going to calculate stem active zones for %s\n",gd->sc->name ); -#endif - for ( i=startnum; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - NormalizeStem( gd,stem ); - if ( gd->stems[i].ghost ) - FigureGhostActive( gd,stem ); - else if ( gd->stems[i].bbox ) - AssignPointsToBBoxHint( gd,bounds,stem,( stem->unit.y == 1 )); - else - FigureStemActive( gd,&gd->stems[i] ); - } -#if GLYPH_DATA_DEBUG - DumpGlyphData( gd ); -#endif - - free(gd->lspace); gd->lspace = NULL; - free(gd->rspace); gd->rspace = NULL; - free(gd->bothspace); gd->bothspace = NULL; - free(gd->activespace); gd->activespace = NULL; -} - -static void _DStemInfoToStemData( struct glyphdata *gd,DStemInfo *dsi,int *startcnt ) { - struct stemdata *stem; - - if ( gd->stems == NULL ) { - gd->stems = calloc( 2*gd->pcnt,sizeof( struct stemdata )); - gd->stemcnt = 0; - } - *startcnt = gd->stemcnt; - while ( dsi != NULL ) { - stem = NewStem( gd,&dsi->unit,&dsi->left,&dsi->right ); - stem->positioned = true; - dsi = dsi->next; - } -} - -struct glyphdata *DStemInfoToStemData( struct glyphdata *gd,DStemInfo *dsi ) { - int startcnt; - - if ( dsi == NULL ) -return( gd ); - - _DStemInfoToStemData( gd,dsi,&startcnt ); - AssignPointsToStems( gd,startcnt,NULL ); -return( gd ); -} - -static void _StemInfoToStemData( struct glyphdata *gd,StemInfo *si,DBounds *bounds,int is_v,int *startcnt ) { - struct stemdata *stem; - BasePoint dir,left,right; - - dir.x = !is_v; dir.y = is_v; - if ( gd->stems == NULL ) { - gd->stems = calloc( 2*gd->pcnt,sizeof( struct stemdata )); - gd->stemcnt = 0; - } - *startcnt = gd->stemcnt; - - while ( si != NULL ) { - left.x = ( is_v ) ? si->start : 0; - left.y = ( is_v ) ? 0 : si->start + si->width; - right.x = ( is_v ) ? si->start + si->width : 0; - right.y = ( is_v ) ? 0 : si->start; - stem = NewStem( gd,&dir,&left,&right ); - stem->ghost = si->ghost; - if (( is_v && - left.x >= bounds->minx && left.x < bounds->minx + dist_error_hv && - right.x > bounds->maxx - dist_error_hv && right.x <= bounds->maxx ) || - ( !is_v && - right.y >= bounds->miny && right.y < bounds->miny + dist_error_hv && - left.y > bounds->maxy - dist_error_hv && left.y <= bounds->maxy )) - stem->bbox = true; - stem->positioned = true; - si = si->next; - } -} - -struct glyphdata *StemInfoToStemData( struct glyphdata *gd,StemInfo *si,int is_v ) { - DBounds bounds; - int startcnt; - - if ( si == NULL ) -return( gd ); - - SplineCharFindBounds( gd->sc,&bounds ); - _StemInfoToStemData( gd,si,&bounds,is_v,&startcnt ); - - AssignPointsToStems( gd,startcnt,&bounds ); -return( gd ); -} - -static int ValidConflictingStem( struct stemdata *stem1,struct stemdata *stem2 ) { - int x_dir = fabs( stem1->unit.y ) > fabs( stem1->unit.x ); - double s1, e1, s2, e2, temp; - - s1 = (&stem1->left.x)[!x_dir] - - ((&stem1->left.x)[x_dir] * (&stem1->unit.x)[!x_dir] )/(&stem1->unit.x)[x_dir]; - e1 = (&stem1->right.x)[!x_dir] - - ((&stem1->right.x)[x_dir] * (&stem1->unit.x)[!x_dir] )/(&stem1->unit.x)[x_dir]; - s2 = (&stem2->left.x)[!x_dir] - - ((&stem2->left.x)[x_dir] * (&stem2->unit.x)[!x_dir] )/(&stem2->unit.x)[x_dir]; - e2 = (&stem2->right.x)[!x_dir] - - ((&stem2->right.x)[x_dir] * (&stem2->unit.x)[!x_dir] )/(&stem2->unit.x)[x_dir]; - - if ( s1 > e1 ) { - temp = s1; s1 = e1; e1 = temp; - } - if ( s2 > e2 ) { - temp = s2; s2 = e2; e2 = temp; - } - /* If stems don't overlap, then there is no conflict here */ - if ( s2 >= e1 || s1 >= e2 ) -return( false ); - - /* Stems which have no points assigned cannot be valid masters for */ - /* other stems (however there is a notable exception for ghost hints) */ - if (( stem1->lpcnt > 0 || stem1->rpcnt > 0 ) && - stem2->lpcnt == 0 && stem2->rpcnt == 0 && !stem2->ghost ) -return( false ); - - /* Bounding box stems are always preferred */ - if ( stem1->bbox && !stem2->bbox ) -return( false ); - - /* Stems associated with blue zones always preferred to any other stems */ - if ( stem1->blue >=0 && stem2->blue < 0 ) -return( false ); - /* Don't attempt to handle together stems, linked to different zones */ - if ( stem1->blue >=0 && stem2->blue >= 0 && stem1->blue != stem2->blue ) -return( false ); - /* If both stems are associated with a blue zone, but one of them is for */ - /* a ghost hint, then that stem is preferred */ - if ( stem1->ghost && !stem2->ghost ) -return( false ); - -return( true ); -} - -static int HasDependentStem( struct stemdata *master,struct stemdata *slave ) { - int i; - struct stemdata *tstem; - - if ( slave->master != NULL && master->dep_cnt > 0 ) { - for ( i=0; i<master->dep_cnt; i++ ) { - tstem = master->dependent[i].stem; - if ( tstem == slave || HasDependentStem( tstem,slave )) -return( true ); - } - } -return( false ); -} - -static int PreferEndDep( struct stemdata *stem, - struct stemdata *smaster,struct stemdata *emaster,char s_type,char e_type ) { - - int hv = IsUnitHV( &stem->unit,true ); - double sdist, edist; - - if ( !hv ) -return( false ); - - if (( s_type == 'a' && e_type != 'a' ) || ( s_type == 'm' && e_type == 'i' )) -return( false ); - else if (( e_type == 'a' && s_type != 'a' ) || ( e_type == 'm' && s_type == 'i' )) -return( true ); - - if ( s_type == 'm' && s_type == e_type ) { - sdist = ( hv==1 ) ? - fabs( smaster->right.y - stem->right.y ) : - fabs( smaster->left.x - stem->left.x ); - edist = ( hv==1 ) ? - fabs( emaster->left.y - stem->left.y ) : - fabs( emaster->right.x - stem->right.x ); -return( edist < sdist ); - } else -return( emaster->clen > smaster->clen ); -} - -static void LookForMasterHVStem( struct stemdata *stem,BlueData *bd ) { - struct stemdata *tstem, *smaster=NULL, *emaster=NULL; - struct stembundle *bundle = stem->bundle; - double start, end, tstart, tend; - double ssdist, sedist, esdist, eedist; - double smin, smax, emin, emax, tsmin, tsmax, temin, temax; - int is_x, i, link_to_s, stype, etype, allow_s, allow_e; - - is_x = ( bundle->unit.x == 1 ); - if ( is_x ) { - start = stem->right.y; end = stem->left.y; - smin = start - stem->rmin - 2*dist_error_hv; - smax = start - stem->rmax + 2*dist_error_hv; - emin = end - stem->lmin - 2*dist_error_hv; - emax = end - stem->lmax + 2* dist_error_hv; - } else { - start = stem->left.x; end = stem->right.x; - smin = start + stem->lmax - 2*dist_error_hv; - smax = start + stem->lmin + 2*dist_error_hv; - emin = end + stem->rmax - 2*dist_error_hv; - emax = end + stem->rmin + 2*dist_error_hv; - } - start = ( is_x ) ? stem->right.y : stem->left.x; - end = ( is_x ) ? stem->left.y : stem->right.x; - stype = etype = '\0'; - - for ( i=0; i<bundle->cnt; i++ ) { - tstem = bundle->stemlist[i]; - if ( is_x ) { - tstart = tstem->right.y; tend = tstem->left.y; - tsmin = tstart - tstem->rmin - 2*dist_error_hv; - tsmax = tstart - tstem->rmax + 2*dist_error_hv; - temin = tend - tstem->lmin - 2*dist_error_hv; - temax = tend - tstem->lmax + 2* dist_error_hv; - } else { - tstart = tstem->left.x; tend = tstem->right.x; - tsmin = tstart + tstem->lmax - 2*dist_error_hv; - tsmax = tstart + tstem->lmin + 2*dist_error_hv; - temin = tend + tstem->rmax - 2*dist_error_hv; - temax = tend + tstem->rmin + 2*dist_error_hv; - } - tstart = ( is_x ) ? tstem->right.y : tstem->left.x; - tend = ( is_x ) ? tstem->left.y : tstem->right.x; - - /* In this loop we are looking if the given stem has conflicts with */ - /* other stems and if anyone of those conflicting stems should */ - /* take precedence over it */ - if ( stem == tstem || tend < start || tstart > end || - !ValidConflictingStem( stem,tstem ) || HasDependentStem( stem,tstem )) - continue; - /* Usually in case of conflicts we prefer the stem with longer active */ - /* zones. However a stem linked to a blue zone is always preferred to */ - /* a stem which is not, and ghost hints are preferred to any other */ - /* stems */ - if ( stem->clen > tstem->clen && ValidConflictingStem( tstem,stem )) - continue; - - stem->confl_cnt++; - - /* If the master stem is for a ghost hint or both the stems are */ - /* linked to the same blue zone, then we can link only to the edge */ - /* which fall into the blue zone */ - allow_s = ( !tstem->ghost || tstem->width == 21 ) && - ( stem->blue == -1 || stem->blue != tstem->blue || bd->blues[stem->blue][0] < 0 ); - allow_e = ( !tstem->ghost || tstem->width == 20 ) && - ( stem->blue == -1 || stem->blue != tstem->blue || bd->blues[stem->blue][0] > 0 ); - - /* Assume there are two stems which have (almost) coincident left edges. */ - /* The hinting technique for this case is to merge all points found on */ - /* those coincident edges together, position them, and then link to the */ - /* opposite edges. */ - /* However we don't allow merging if both stems can be snapped to a blue */ - /* zone, unless their edges are _exactly_ coincident, as shifting features */ - /* relatively to each other instead of snapping them to the same zone would */ - /* obviously be wrong */ - if ( allow_s && tstart > smin && tstart < smax && start > tsmin && start < tsmax && - ( stem->blue == -1 || RealNear( tstart,start ))) { - - if ( smaster == NULL || stype != 'a' || smaster->clen < tstem->clen ) { - smaster = tstem; - stype = 'a'; - } - /* The same case for right edges */ - } else if ( allow_e && tend > emin && tend < emax && end > temin && end < temax && - ( stem->blue == -1 || RealNear( tend,end ))) { - - if ( emaster == NULL || etype != 'a' || emaster->clen < tstem->clen ) { - emaster = tstem; - etype = 'a'; - } - - /* Nested stems. I first planned to handle them by positioning the */ - /* narrower stem first, and then linking its edges to the opposed edges */ - /* of the nesting stem. But this works well only in those cases where */ - /* maintaining the dependent stem width is not important. So now the */ - /* situations where a narrower or a wider stem can be preferred */ - /* (because it has longer active zones) are equally possible. In the */ - /* first case I link to the master stem just one edge of the secondary */ - /* stem, just like with overlapping stems */ - } else if ( tstart > start && tend < end ) { - if ( allow_s && ( smaster == NULL || stype == 'i' || - ( stype == 'm' && smaster->clen < tstem->clen ))) { - - smaster = tstem; - stype = 'm'; - } - if ( allow_e && ( emaster == NULL || etype == 'i' || - ( etype == 'm' && emaster->clen < tstem->clen ))) { - - emaster = tstem; - etype = 'm'; - } - /* However if we have to prefer the nesting stem, we do as with */ - /* overlapping stems which require interpolations, i. e. interpolate */ - /* one edge and link to another */ - } else if ( tstart < start && tend > end ) { - link_to_s = ( allow_s && ( start - tstart < tend - end )); - if ( link_to_s && ( smaster == NULL || - ( stype == 'i' && smaster->clen < tstem->clen ))) { - smaster = tstem; - stype = 'i'; - } else if ( !link_to_s && ( emaster == NULL || - ( etype == 'i' && emaster->clen < tstem->clen ))) { - emaster = tstem; - etype = 'i'; - } - /* Overlapping stems. Here we first check all 4 distances between */ - /* 4 stem edges. If the closest distance is between left or right */ - /* edges, then the normal technique (in TrueType) is linking them */ - /* with MDRP without maintaining a minimum distance. Otherwise */ - /* we interpolate an edge of the "slave" stem between already */ - /* positioned edges of the "master" stem, and then gridfit it */ - } else if (( tstart < start && start < tend && tend < end ) || - ( start < tstart && tstart < end && end < tend )) { - - ssdist = fabs( start - tstart ); - sedist = fabs( start - tend ); - esdist = fabs( end - tstart ); - eedist = fabs( end - tend ); - - if ( allow_s && ( !allow_e || - ( stem->width < tstem->width/3 && ssdist < eedist ) || - ( ssdist <= eedist && ssdist <= sedist && ssdist <= esdist )) && - ( smaster == NULL || ( stype == 'i' || - ( stype == 'm' && smaster->clen < tstem->clen )))) { - - smaster = tstem; - stype = 'm'; - } else if ( allow_e && ( !allow_s || - ( stem->width < tstem->width/3 && eedist < ssdist ) || - ( eedist <= ssdist && eedist <= sedist && eedist <= esdist )) && - ( emaster == NULL || ( etype == 'i' || - ( etype == 'm' && emaster->clen < tstem->clen )))) { - - emaster = tstem; - etype = 'm'; - } else if ( allow_s && allow_e && ( smaster == NULL || - ( stype == 'i' && smaster->clen < tstem->clen )) && - sedist <= esdist && sedist <= ssdist && sedist <= eedist ) { - - smaster = tstem; - stype = 'i'; - } else if ( allow_s && allow_e && ( emaster == NULL || - ( etype == 'i' && emaster->clen < tstem->clen )) && - esdist <= sedist && esdist <= ssdist && esdist <= eedist ) { - - emaster = tstem; - etype = 'i'; - } - } - } - if ( smaster != NULL && emaster != NULL ) { - if ( PreferEndDep( stem,smaster,emaster,stype,etype )) - smaster = NULL; - else - emaster = NULL; - } - - if ( smaster != NULL ) { - stem->master = smaster; - if ( smaster->dependent == NULL ) - smaster->dependent = calloc( bundle->cnt*2,sizeof( struct dependent_stem )); - smaster->dependent[smaster->dep_cnt].stem = stem; - smaster->dependent[smaster->dep_cnt].dep_type = stype; - smaster->dependent[smaster->dep_cnt++].lbase = !is_x; - } else if ( emaster != NULL ) { - stem->master = emaster; - if ( emaster->dependent == NULL ) - emaster->dependent = calloc( bundle->cnt*2,sizeof( struct dependent_stem )); - emaster->dependent[emaster->dep_cnt ].stem = stem; - emaster->dependent[emaster->dep_cnt ].dep_type = etype; - emaster->dependent[emaster->dep_cnt++].lbase = is_x; - } -} - -/* If a stem has been considered depending from another stem which in */ -/* its turn has its own "master", and the first stem doesn't conflict */ -/* with the "master" of the stem it overlaps (or any other stems), then */ -/* this dependency is unneeded and processing it in the autoinstructor */ -/* can even lead to undesired effects. Unfortunately we can't prevent */ -/* detecting such dependecies in LookForMasterHVStem(), because we */ -/* need to know the whole stem hierarchy first. So look for undesired */ -/* dependencies and clean them now */ -static void ClearUnneededDeps( struct stemdata *stem ) { - struct stemdata *master; - int i, j; - - if ( stem->confl_cnt == 1 && - ( master = stem->master ) != NULL && master->master != NULL ) { - - stem->master = NULL; - for ( i=j=0; i<master->dep_cnt; i++ ) { - if ( j<i ) - memcpy( &master->dependent[i-1],&master->dependent[i], - sizeof( struct dependent_stem )); - if ( master->dependent[i].stem != stem ) j++; - } - (master->dep_cnt)--; - } -} - -static void GDBundleStems( struct glyphdata *gd, int maxtoobig, int needs_deps ) { - struct stemdata *stem, *tstem; - int i, j, k, hv, hasl, hasr, stem_cnt; - struct pointdata *lpd, *rpd; - double dmove; - DBounds bounds; - - /* Some checks for undesired stems which we couldn't do earlier */ - - /* First filter out HV stems which have only "potential" points */ - /* on their left or right edge. Such stems aren't supposed to be */ - /* used for PS hinting, so we mark them as "too big" */ - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - hasl = false; hasr = false; - - if ( IsUnitHV( &stem->unit,true ) && - !stem->toobig && !stem->ghost && !stem->positioned ) { - for ( j=0; j<stem->chunk_cnt && ( !hasl || !hasr ); ++j ) { - if ( stem->chunks[j].l!=NULL && !stem->chunks[j].lpotential ) - hasl = true; - if ( stem->chunks[j].r!=NULL && !stem->chunks[j].rpotential ) - hasr = true; - } - if ( !hasl || !hasr ) - stem->toobig = true; - } - } - - /* Filter out HV stems which have both their edges controlled by */ - /* other, narrower HV stems */ - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - hv = IsUnitHV( &stem->unit,true ); - - if ( IsUnitHV( &stem->unit,true )) { - hasl = hasr = false; - for ( j=0; j<stem->chunk_cnt; ++j ) { - lpd = stem->chunks[j].l; - rpd = stem->chunks[j].r; - if ( lpd != NULL ) { - stem_cnt = ( stem->chunks[j].lnext ) ? lpd->nextcnt : lpd->prevcnt; - for ( k=0; k<stem_cnt; k++ ) { - tstem = ( stem->chunks[j].lnext ) ? - lpd->nextstems[k] : lpd->prevstems[k]; - /* Used to test tstem->toobig <= stem->toobig, but got into troubles with */ - /* a weird terminal stem preventing a ball terminal from being properly detected, */ - /* because both the stems initially have toobig == 1. */ - /* See the "f" from Heuristica-Italic */ - if ( tstem != stem && - !tstem->toobig && tstem->positioned >= stem->positioned && - tstem->width < stem->width && hv == IsUnitHV( &tstem->unit,true )) { - hasl = true; - break; - } - } - } - if ( rpd != NULL ) { - stem_cnt = ( stem->chunks[j].rnext ) ? rpd->nextcnt : rpd->prevcnt; - for ( k=0; k<stem_cnt; k++ ) { - tstem = ( stem->chunks[j].rnext ) ? - rpd->nextstems[k] : rpd->prevstems[k]; - if ( tstem != stem && - !tstem->toobig && tstem->positioned >= stem->positioned && - tstem->width < stem->width && hv == IsUnitHV( &tstem->unit,true )) { - hasr = true; - break; - } - } - } - if ( hasl && hasr ) { - stem->toobig = 2; - break; - } - } - } - } - - gd->hbundle = calloc( 1,sizeof( struct stembundle )); - gd->hbundle->stemlist = calloc( gd->stemcnt,sizeof( struct stemdata *)); - gd->hbundle->unit.x = 1; gd->hbundle->unit.y = 0; - gd->hbundle->l_to_r.x = 0; gd->hbundle->l_to_r.y = -1; - - gd->vbundle = calloc( 1,sizeof( struct stembundle )); - gd->vbundle->stemlist = calloc( gd->stemcnt,sizeof( struct stemdata *)); - gd->vbundle->unit.x = 0; gd->vbundle->unit.y = 1; - gd->vbundle->l_to_r.x = 1; gd->vbundle->l_to_r.y = 0; - - if ( gd->has_slant && !gd->only_hv ) { - SplineCharFindBounds( gd->sc,&bounds ); - - gd->ibundle = calloc( 1,sizeof( struct stembundle )); - gd->ibundle->stemlist = calloc( gd->stemcnt,sizeof( struct stemdata *)); - gd->ibundle->unit.x = gd->slant_unit.x; - gd->ibundle->unit.y = gd->slant_unit.y; - gd->ibundle->l_to_r.x = -gd->ibundle->unit.y; - gd->ibundle->l_to_r.y = gd->ibundle->unit.x; - } - - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( stem->toobig > maxtoobig ) - continue; - hv = IsUnitHV( &stem->unit,true ); - - if ( hv == 1 ) { - gd->hbundle->stemlist[(gd->hbundle->cnt)++] = stem; - stem->bundle = gd->hbundle; - } else if ( hv == 2 ) { - gd->vbundle->stemlist[(gd->vbundle->cnt)++] = stem; - stem->bundle = gd->vbundle; - } else if ( gd->has_slant && !gd->only_hv && - RealNear( stem->unit.x,gd->slant_unit.x ) && - RealNear( stem->unit.y,gd->slant_unit.y )) { - - /* Move base point coordinates to the baseline to simplify */ - /* stem ordering and positioning relatively to each other */ - stem->left.x -= (( stem->left.y - bounds.miny ) * stem->unit.x )/stem->unit.y; - stem->right.x -= (( stem->right.y - bounds.miny ) * stem->unit.x )/stem->unit.y; - dmove = ( stem->left.y - bounds.miny ) / stem->unit.y; - stem->left.y = stem->right.y = bounds.miny; - for ( j=0; j<stem->activecnt; j++ ) { - stem->active[j].start += dmove; - stem->active[j].end += dmove; - } - - gd->ibundle->stemlist[(gd->ibundle->cnt)++] = stem; - stem->bundle = gd->ibundle; - stem->italic = true; - } - } - qsort( gd->hbundle->stemlist,gd->hbundle->cnt,sizeof( struct stemdata *),stem_cmp ); - qsort( gd->vbundle->stemlist,gd->vbundle->cnt,sizeof( struct stemdata *),stem_cmp ); - if ( gd->has_slant && !gd->only_hv ) - qsort( gd->ibundle->stemlist,gd->ibundle->cnt,sizeof( struct stemdata *),stem_cmp ); - - if ( !needs_deps ) -return; - for ( i=0; i<gd->hbundle->cnt; i++ ) - LookForMasterHVStem( gd->hbundle->stemlist[i],&gd->bd ); - for ( i=0; i<gd->hbundle->cnt; i++ ) - ClearUnneededDeps( gd->hbundle->stemlist[i] ); - for ( i=0; i<gd->vbundle->cnt; i++ ) - LookForMasterHVStem( gd->vbundle->stemlist[i],&gd->bd ); - for ( i=0; i<gd->vbundle->cnt; i++ ) - ClearUnneededDeps( gd->vbundle->stemlist[i] ); -} - -static void AddSerifOrBall( struct glyphdata *gd, - struct stemdata *master,struct stemdata *slave,int lbase,int is_ball ) { - - struct dependent_serif *tserif; - struct pointdata *spd; - double width, min, max; - int i, j, scnt, next; - - if ( lbase ) { - width = fabs( - ( slave->right.x - master->left.x ) * master->unit.y - - ( slave->right.y - master->left.y ) * master->unit.x ); - max = width + slave->rmin + 2*dist_error_hv; - min = width + slave->rmax - 2*dist_error_hv; - } else { - width = fabs( - ( master->right.x - slave->left.x ) * master->unit.y - - ( master->right.y - slave->left.y ) * master->unit.x ); - max = width - slave->lmax + 2*dist_error_hv; - min = width - slave->lmin - 2*dist_error_hv; - } - - scnt = master->serif_cnt; - for ( i=0; i<scnt; i++ ) { - tserif = &master->serifs[i]; - if ( tserif->stem == slave && tserif->lbase == lbase ) - break; - else if ( tserif->width > min && tserif->width < max && tserif->lbase == lbase ) { - for ( j=0; j<slave->chunk_cnt; j++ ) { - spd = ( lbase ) ? slave->chunks[j].r : slave->chunks[j].l; - next = ( lbase ) ? slave->chunks[j].rnext : slave->chunks[j].lnext; - if ( spd != NULL && IsStemAssignedToPoint( spd,tserif->stem,next ) == -1 ) - AddToStem( gd,tserif->stem,spd,NULL,next,false,false ); - } - break; - } - } - if ( i<master->serif_cnt ) -return; - - master->serifs = realloc( - master->serifs,( scnt+1 )*sizeof( struct dependent_serif )); - master->serifs[scnt].stem = slave; - master->serifs[scnt].width = width; - master->serifs[scnt].lbase = lbase; - master->serifs[scnt].is_ball = is_ball; - master->serif_cnt++; - - /* Mark the dependent stem as related with a bundle, although it */ - /* is not listed in that bundle itself */ - slave->bundle = master->bundle; -} - -static int IsBall( struct glyphdata *gd, - struct pointdata *pd,struct stemdata *master,int lbase ) { - - double max, min, dot, coord; - BasePoint *lbp, *rbp, *dir; - Spline *test; - struct pointdata *nbase, *pbase, *tpd; - struct stem_chunk *chunk; - int i, is_x, peak_passed; - - if ( pd == NULL || ( pd->x_extr != 1 && pd->y_extr != 1 )) -return( false ); - - is_x = ( IsUnitHV( &master->unit,true ) == 1 ); - lbp = ( lbase ) ? &master->left : &pd->base; - rbp = ( lbase ) ? &pd->base : &master->right; - min = ( is_x ) ? rbp->y : lbp->x; - max = ( is_x ) ? lbp->y : rbp->x; - - peak_passed = false; - nbase = pbase = NULL; - test = pd->sp->next; - dir = &pd->nextunit; - - if ( test != NULL ) do { - tpd = &gd->points[test->to->ptindex]; - if ( IsStemAssignedToPoint( tpd,master,true ) != -1 ) { - nbase = tpd; - break; - } - coord = ( is_x ) ? tpd->base.y : tpd->base.x; - dot = tpd->nextunit.x * dir->x + tpd->nextunit.y * dir->y; - if ( dot == 0 && !peak_passed ) { - dir = &tpd->nextunit; - dot = 1.0; - peak_passed = true; - } - test = test->to->next; - } while ( test != NULL && test != pd->sp->next && dot > 0 && - coord >= min && coord <= max ); - - peak_passed = false; - test = pd->sp->prev; - dir = &pd->prevunit; - if ( test != NULL ) do { - tpd = &gd->points[test->from->ptindex]; - if ( IsStemAssignedToPoint( tpd,master,false ) != -1 ) { - pbase = tpd; - break; - } - coord = ( is_x ) ? tpd->base.y : tpd->base.x; - dot = tpd->prevunit.x * dir->x + tpd->prevunit.y * dir->y; - if ( dot == 0 && !peak_passed ) { - dir = &tpd->prevunit; - dot = 1.0; - peak_passed = true; - } - test = test->from->prev; - } while ( test != NULL && test != pd->sp->prev && dot > 0 && - coord >= min && coord <= max ); - - if ( nbase != NULL && pbase != NULL ) { - for ( i=0; i<master->chunk_cnt; i++ ) { - chunk = &master->chunks[i]; - if (( chunk->l == nbase && chunk->r == pbase ) || - ( chunk->l == pbase && chunk->r == nbase )) -return( true ); - } - } -return( false ); -} - -static void GetSerifData( struct glyphdata *gd,struct stemdata *stem ) { - int i, j, is_x, stem_cnt; - int snext, enext, eidx, allow_s, allow_e, s_ball, e_ball; - struct stem_chunk *chunk; - struct stemdata *tstem, *smaster=NULL, *emaster=NULL; - struct pointdata *spd, *epd; - struct stembundle *bundle; - double start, end, tstart, tend, smend, emstart; - - is_x = ( IsUnitHV( &stem->unit,true ) == 1 ); - bundle = ( is_x ) ? gd->hbundle : gd->vbundle; - start = ( is_x ) ? stem->right.y : stem->left.x; - end = ( is_x ) ? stem->left.y : stem->right.x; - - allow_s = allow_e = true; - s_ball = e_ball = 0; - for ( i=0; i<stem->chunk_cnt && ( allow_s == true || allow_e == true ); i++ ) { - chunk = &stem->chunks[i]; - spd = ( is_x ) ? chunk->r : chunk->l; - snext = ( is_x ) ? chunk->rnext : chunk->lnext; - epd = ( is_x ) ? chunk->l : chunk->r; - enext = ( is_x ) ? chunk->lnext : chunk->rnext; - - if ( spd != NULL && allow_e ) { - stem_cnt = ( snext ) ? spd->nextcnt : spd->prevcnt; - for ( j=0; j<stem_cnt; j++ ) { - tstem = ( snext ) ? spd->nextstems[j] : spd->prevstems[j]; - if (RealNear( tstem->unit.x,stem->unit.x ) && RealNear( tstem->unit.y,stem->unit.y ) && - !tstem->toobig ) { - chunk->is_ball = e_ball = IsBall( gd,epd,tstem,!is_x ); - if ( e_ball ) { - chunk->ball_m = tstem; - emaster = tstem; - emstart = ( is_x ) ? tstem->right.y : tstem->left.x; - } - allow_s = false; - } - } - - } - if ( epd != NULL && allow_s ) { - stem_cnt = ( enext ) ? epd->nextcnt : epd->prevcnt; - for ( j=0; j<stem_cnt; j++ ) { - tstem = ( enext ) ? epd->nextstems[j] : epd->prevstems[j]; - if (tstem->unit.x == stem->unit.x && tstem->unit.y == stem->unit.y && - !tstem->toobig ) { - chunk->is_ball = s_ball = IsBall( gd,spd,tstem,is_x ); - if ( s_ball ) { - chunk->ball_m = tstem; - smaster = tstem; - smend = ( is_x ) ? tstem->left.y : tstem->right.x; - } - allow_e = false; - } - } - - } - } - - for ( i=0; i<bundle->cnt; i++ ) { - tstem = bundle->stemlist[i]; - if (tstem->unit.x != stem->unit.x || tstem->unit.y != stem->unit.y || - tstem->toobig || tstem->width >= stem->width ) - continue; - - tstart = ( is_x ) ? tstem->right.y : tstem->left.x; - tend = ( is_x ) ? tstem->left.y : tstem->right.x; - - if ( tstart >= start && tend <= end ) { - if ( allow_s && tstart > start ) { - for ( j=0; j<tstem->chunk_cnt && smaster != tstem; j++ ) { - if ( is_x ) { - spd = tstem->chunks[j].l; - snext = tstem->chunks[j].lnext; - eidx = tstem->chunks[j].l_e_idx; - } else { - spd = tstem->chunks[j].r; - snext = tstem->chunks[j].rnext; - eidx = tstem->chunks[j].r_e_idx; - } - if ( spd != NULL && ConnectsAcrossToStem( gd,spd,snext,stem,is_x,eidx ) && - ( smaster == NULL || smend - start > tend - start )) { - smaster = tstem; - smend = tend; - } - } - } - if ( allow_e && tend < end ) { - for ( j=0; j<tstem->chunk_cnt && emaster != tstem; j++ ) { - if ( is_x ) { - epd = tstem->chunks[j].r; - enext = tstem->chunks[j].rnext; - eidx = tstem->chunks[j].r_e_idx; - } else { - epd = tstem->chunks[j].l; - enext = tstem->chunks[j].lnext; - eidx = tstem->chunks[j].l_e_idx; - } - if ( epd != NULL && ConnectsAcrossToStem( gd,epd,enext,stem,!is_x,eidx ) && - ( emaster == NULL || end - emstart > end - tstart )) { - emaster = tstem; - emstart = tstart; - } - } - } - } - } - if ( smaster != NULL ) - AddSerifOrBall( gd,smaster,stem,is_x,s_ball ); - if ( emaster != NULL ) - AddSerifOrBall( gd,emaster,stem,!is_x,e_ball ); -} - -static double ActiveOverlap( struct stemdata *stem1,struct stemdata *stem2 ) { - int is_x, i, j = 0; - double base1, base2, s1, e1, s2, e2, s, e, len = 0; - - is_x = ( IsUnitHV( &stem1->unit,true ) == 2 ); - base1 = ( &stem1->left.x )[is_x]; - base2 = ( &stem2->left.x )[is_x]; - - for ( i=0; i<stem1->activecnt; i++ ) { - s1 = base1 + stem1->active[i].start; - e1 = base1 + stem1->active[i].end; - for ( ; j<stem2->activecnt; j++ ) { - s2 = base2 + stem2->active[j].start; - e2 = base2 + stem2->active[j].end; - if ( s2 > e1 ) - break; - - if ( e2 < s1 ) - continue; - - s = s2 < s1 ? s1 : s2; - e = e2 > e1 ? e1 : e2; - if ( e<s ) - continue; /* Shouldn't happen */ - len += e - s; - } - } -return( len ); -} - -static int StemPairsSimilar( struct stemdata *s1, struct stemdata *s2, - struct stemdata *ts1, struct stemdata *ts2 ) { - - int normal, reversed, ret = 0; - double olen1, olen2; - - /* Stem widths in the second pair should be nearly the same as */ - /* stem widths in the first pair */ - normal = ( ts1->width >= s1->width - dist_error_hv && - ts1->width <= s1->width + dist_error_hv && - ts2->width >= s2->width - dist_error_hv && - ts2->width <= s2->width + dist_error_hv ); - reversed = (ts1->width >= s2->width - dist_error_hv && - ts1->width <= s2->width + dist_error_hv && - ts2->width >= s1->width - dist_error_hv && - ts2->width <= s1->width + dist_error_hv ); - - if ( !normal && !reversed ) -return( false ); - - if ( normal ) { - olen1 = ActiveOverlap( s1, ts1 ); - olen2 = ActiveOverlap( s2, ts2 ); - ret = olen1 > s1->clen/3 && olen1 > ts1->clen/3 && - olen2 > s2->clen/3 && olen2 > ts2->clen/3; - } else if ( reversed ) { - olen1 = ActiveOverlap( s1, ts2 ); - olen2 = ActiveOverlap( s2, ts1 ); - ret = olen1 > s1->clen/3 && olen1 > ts2->clen/3 && - olen2 > s2->clen/3 && olen2 > ts1->clen/3; - } -return( ret ); -} - -static void FindCounterGroups( struct glyphdata *gd,int is_v ) { - struct stembundle *bundle = is_v ? gd->vbundle : gd->hbundle; - struct stemdata *curm, *prevm, *cur, *prev; - int i, j; - double mdist, dist; - - prevm = NULL; - for ( i=0; i<bundle->cnt; i++ ) { - curm = prev = bundle->stemlist[i]; - if ( curm->master != NULL ) - continue; - if ( prevm == NULL || curm->prev_c_m != NULL ) { - prevm = curm; - continue; - } - mdist = is_v ? curm->left.x - prevm->right.x : curm->right.y - prevm->left.y; - for ( j=i+1; j<bundle->cnt; j++ ) { - cur = bundle->stemlist[j]; - if ( cur->master != NULL ) - continue; - if ( cur->prev_c_m != NULL ) { - prev = cur; - continue; - } - - dist = is_v ? cur->left.x - prev->right.x : cur->right.y - prev->left.y; - if ( mdist > dist - dist_error_hv && mdist < dist + dist_error_hv && - StemPairsSimilar( prevm,curm,prev,cur )) { - prev->next_c_m = prevm; - cur->prev_c_m = curm; - } - prev = cur; - } - prevm = curm; - } -} - -/* Normally we use the DetectDiagonalStems flag (set via the Preferences dialog) to determine */ -/* if diagonal stems should be generated. However, sometimes it makes sense to reduce the */ -/* processing time, deliberately turning the diagonal stem detection off: in particular we */ -/* don't need any diagonal stems if we only want to assign points to some preexisting HV */ -/* hints. For thisreason the only_hv argument still can be passed to this function. */ -struct glyphdata *GlyphDataInit( SplineChar *sc,int layer,double em_size,int only_hv ) { - struct glyphdata *gd; - struct pointdata *pd; - int i; - SplineSet *ss; - SplinePoint *sp; - Monotonic *m; - int cnt; - double iangle; - - if ( layer<0 || layer>=sc->layer_cnt ) - return( NULL ); - - /* We only hint one layer at a time */ - /* We shan't try to hint references yet */ - if ( sc->layers[layer].splines==NULL ) -return( NULL ); - - gd = calloc( 1,sizeof( struct glyphdata )); - gd->only_hv = only_hv; - gd->layer = layer; - - gd->sc = sc; - gd->sf = sc->parent; - gd->emsize = em_size; - gd->order2 = ( sc->parent != NULL ) ? sc->parent->layers[layer].order2 : false; - gd->fuzz = GetBlueFuzz( sc->parent ); - - dist_error_hv = .0035*gd->emsize; - dist_error_diag = .0065*gd->emsize; - dist_error_curve = .022*gd->emsize; - - if ( sc->parent != NULL && sc->parent->italicangle ) { - iangle = ( 90 + sc->parent->italicangle ); - gd->has_slant = true; - gd->slant_unit.x = cos( iangle * ( PI/180 )); - gd->slant_unit.y = sin( iangle * ( PI/180 )); - } else { - gd->has_slant = false; - gd->slant_unit.x = 0; gd->slant_unit.y = 1; - } - - /* SSToMContours can clean up the splinesets (remove 0 length splines) */ - /* so it must be called BEFORE everything else (even though logically */ - /* that doesn't make much sense). Otherwise we might have a pointer */ - /* to something since freed */ - gd->ms = SSsToMContours(sc->layers[layer].splines,over_remove); /* second argument is meaningless here */ - - gd->realcnt = gd->pcnt = SCNumberPoints( sc, layer ); - for ( i=0, ss=sc->layers[layer].splines; ss!=NULL; ss=ss->next, ++i ); - gd->ccnt = i; - gd->contourends = malloc((i+1)*sizeof(int)); - for ( i=0, ss=sc->layers[layer].splines; ss!=NULL; ss=ss->next, ++i ) { - SplinePoint *last; - if ( ss->first->prev!=NULL ) - last = ss->first->prev->from; - else - last = ss->last; - if ( last->ttfindex==0xffff ) - gd->contourends[i] = last->nextcpindex; - else - gd->contourends[i] = last->ttfindex; - } - gd->contourends[i] = -1; - - /* Create temporary point numbers for the implied points. We need this */ - /* for metafont if nothing else */ - for ( ss= sc->layers[layer].splines; ss!=NULL; ss = ss->next ) { - for ( sp = ss->first; ; ) { - if ( sp->ttfindex < gd->realcnt ) - sp->ptindex = sp->ttfindex; - else if ( sp->ttfindex == 0xffff ) - sp->ptindex = gd->pcnt++; - if ( sp->next==NULL ) - break; - sp = sp->next->to; - if ( sp==ss->first ) - break; - } - } - gd->norefpcnt = gd->pcnt; - /* And for 0xfffe points such as those used in glyphs with order2 glyphs */ - /* with references. */ - for ( ss = sc->layers[layer].splines; ss!=NULL; ss = ss->next ) { - for ( sp = ss->first; ; ) { - if ( sp->ttfindex == 0xfffe ) - sp->ptindex = gd->pcnt++; - if ( sp->next==NULL ) - break; - sp = sp->next->to; - if ( sp==ss->first ) - break; - } - } - gd->pspace = malloc( gd->pcnt*sizeof( struct pointdata *)); - - /*gd->ms = SSsToMContours(sc->layers[layer].splines,over_remove);*/ /* second argument is meaningless here */ - for ( m=gd->ms, cnt=0; m!=NULL; m=m->linked, ++cnt ); - gd->space = malloc((cnt+2)*sizeof(Monotonic*)); - gd->mcnt = cnt; - - gd->points = calloc(gd->pcnt,sizeof(struct pointdata)); - for ( ss=sc->layers[layer].splines; ss!=NULL; ss=ss->next ) if ( ss->first->prev!=NULL ) { - for ( sp=ss->first; ; ) { - PointInit( gd,sp,ss ); - if ( sp->next==NULL ) - break; - sp = sp->next->to; - if ( sp==ss->first ) - break; - } - } - - for ( i=0; i<gd->pcnt; ++i ) if ( gd->points[i].sp!=NULL ) { - pd = &gd->points[i]; - if ( !pd->nextzero ) - pd->next_e_cnt = FindMatchingEdge(gd,pd,true,pd->nextedges); - if ( !pd->prevzero ) - pd->prev_e_cnt = FindMatchingEdge(gd,pd,false,pd->prevedges); - if (( pd->symetrical_h || pd->symetrical_v ) && ( pd->x_corner || pd->y_corner)) - FindMatchingEdge(gd,pd,2,&pd->bothedge); - } - -return( gd ); -} - -struct glyphdata *GlyphDataBuild( SplineChar *sc,int layer, BlueData *bd,int use_existing ) { - struct glyphdata *gd; - struct pointdata *pd; - struct stemdata *stem; - BasePoint dir; - struct stem_chunk *chunk; - int i, j, only_hv, startcnt, stemcnt, ecnt, hv, has_h, has_v; - double em_size; - DBounds bounds; - - only_hv = ( !detect_diagonal_stems && ( !use_existing || sc->dstem == NULL )); - em_size = ( sc->parent != NULL ) ? sc->parent->ascent + sc->parent->descent : 1000; - - gd = GlyphDataInit( sc,layer,em_size,only_hv ); - if ( gd == NULL ) -return( gd ); - /* Get the alignment zones */ - if ( bd == NULL ) - QuickBlues( gd->sf,gd->layer,&gd->bd ); - else - memcpy( &gd->bd,bd,sizeof( BlueData )); - - /* There will never be more lines than there are points (counting next/prev as separate) */ - gd->lines = malloc( 2*gd->pcnt*sizeof( struct linedata )); - gd->linecnt = 0; - for ( i=0; i<gd->pcnt; ++i ) if ( gd->points[i].sp!=NULL ) { - pd = &gd->points[i]; - if (( !gd->only_hv || pd->next_hor || pd->next_ver ) && pd->nextline==NULL ) { - pd->nextline = BuildLine(gd,pd,true); - if ( pd->colinear ) - pd->prevline = pd->nextline; - } - if (( !gd->only_hv || pd->prev_hor || pd->prev_ver ) && pd->prevline==NULL ) { - pd->prevline = BuildLine(gd,pd,false); - if ( pd->colinear && pd->nextline == NULL ) - pd->nextline = pd->prevline; - } - } - - /* There will never be more stems than there are points (counting next/prev as separate) */ - gd->stems = calloc( 2*gd->pcnt,sizeof( struct stemdata )); - gd->stemcnt = 0; /* None used so far */ - - if ( use_existing ) { - SplineCharFindBounds( gd->sc,&bounds ); - if ( sc->vstem != NULL ) - _StemInfoToStemData( gd,sc->vstem,&bounds,true,&startcnt ); - if ( sc->hstem != NULL ) - _StemInfoToStemData( gd,sc->hstem,&bounds,false,&startcnt ); - if ( sc->dstem != NULL ) - _DStemInfoToStemData( gd,sc->dstem,&startcnt ); - } - - for ( i=0; i<gd->pcnt; ++i ) if ( gd->points[i].sp!=NULL ) { - pd = &gd->points[i]; - if ( pd->prev_e_cnt > 0 ) { - ecnt = BuildStem( gd,pd,false,false,use_existing,0 ); - if ( ecnt == 0 && pd->prev_e_cnt > 1 ) - BuildStem( gd,pd,false,false,false,1 ); - } - if ( pd->next_e_cnt > 0 ) { - ecnt = BuildStem( gd,pd,true,false,use_existing,0 ); - if ( ecnt == 0 && pd->next_e_cnt > 1 ) - BuildStem( gd,pd,true,false,false,1 ); - } - if ( pd->bothedge!=NULL ) { - DiagonalCornerStem( gd,pd,false ); - } - - /* Snap corner extrema to preexisting hints if they have not */ - /* already been. This is currently done only when preparing */ - /* glyph data for the autoinstructor */ - if ( use_existing && ( pd->x_corner || pd->y_corner )) { - has_h = has_v = false; - for ( j=0; j<pd->prevcnt && (( pd->x_corner && !has_v ) || ( pd->y_corner && !has_h )); j++ ) { - hv = IsUnitHV( &pd->prevstems[j]->unit,true ); - if ( hv == 1 ) has_h = true; - else if ( hv == 2 ) has_v = true; - } - for ( j=0; j<pd->nextcnt && (( pd->x_corner && !has_v ) || ( pd->y_corner && !has_h )); j++ ) { - hv = IsUnitHV( &pd->nextstems[j]->unit,true ); - if ( hv == 1 ) has_h = true; - else if ( hv == 2 ) has_v = true; - } - if ( pd->x_corner && !has_v ) { - dir.x = 0; dir.y = 1; - HalfStemNoOpposite( gd,pd,NULL,&dir,2 ); - } else if ( pd->y_corner && !has_h ) { - dir.x = 1; dir.y = 0; - HalfStemNoOpposite( gd,pd,NULL,&dir,2 ); - } - } - } - AssignLinePointsToStems( gd ); - - /* Normalize stems before calculating active zones (as otherwise */ - /* we don't know exact positions of stem edges */ - for ( i=0; i<gd->stemcnt; ++i ) - NormalizeStem( gd,&gd->stems[i] ); - GDNormalizeStubs( gd ); - - /* Figure out active zones at the first order (as they are needed to */ - /* determine which stems are undesired and they don't depend from */ - /* the "potential" state of left/right points in chunks */ - gd->lspace = malloc(gd->pcnt*sizeof(struct segment)); - gd->rspace = malloc(gd->pcnt*sizeof(struct segment)); - gd->bothspace = malloc(3*gd->pcnt*sizeof(struct segment)); - gd->activespace = malloc(3*gd->pcnt*sizeof(struct segment)); -#if GLYPH_DATA_DEBUG - fprintf( stderr,"Going to calculate stem active zones for %s\n",gd->sc->name ); -#endif - for ( i=0; i<gd->stemcnt; ++i ) - FigureStemActive( gd,&gd->stems[i] ); - - /* Check this before resolving stem conflicts, as otherwise we can */ - /* occasionally prefer a stem which should be excluded from the list */ - /* for some other reasons */ - GDFindUnlikelyStems( gd ); - - /* we were cautious about assigning points to stems, go back now and see */ - /* if there are any low-quality matches which remain unassigned, and if */ - /* so then assign them to the stem they almost fit on. */ - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - for ( j=0; j<stem->chunk_cnt; ++j ) { - chunk = &stem->chunks[j]; - if ( chunk->l!=NULL && chunk->lpotential ) { - stemcnt = ( chunk->lnext ) ? chunk->l->nextcnt : chunk->l->prevcnt; - if ( stemcnt == 1 ) chunk->lpotential = false; - } - if ( chunk->r!=NULL && chunk->rpotential ) { - stemcnt = ( chunk->rnext ) ? chunk->r->nextcnt : chunk->r->prevcnt; - if ( stemcnt == 1 ) chunk->rpotential = false; - } - } - } - /* If there are multiple stems, find the one which is closest to this point */ - for ( i=0; i<gd->pcnt; ++i ) if ( gd->points[i].sp != NULL ) { - pd = &gd->points[i]; - if ( pd->prevcnt > 1 ) CheckPotential( gd,pd,false ); - if ( pd->nextcnt > 1 ) CheckPotential( gd,pd,true ); - } - - if ( hint_bounding_boxes ) - CheckForBoundingBoxHints( gd ); - CheckForGhostHints( gd ); - if ( use_existing ) - MarkDStemCorners( gd ); - - GDBundleStems( gd,0,use_existing ); - if ( use_existing ) { - for ( i=0; i<gd->stemcnt; ++i ) { - stem = &gd->stems[i]; - if ( stem->toobig == 1 && IsUnitHV( &stem->unit,true )) - GetSerifData( gd,stem ); - } - FindCounterGroups( gd,true ); - } - -#if GLYPH_DATA_DEBUG - DumpGlyphData( gd ); -#endif - free(gd->lspace); gd->lspace = NULL; - free(gd->rspace); gd->rspace = NULL; - free(gd->bothspace); gd->bothspace = NULL; - free(gd->activespace); gd->activespace = NULL; - -return( gd ); -} - -void GlyphDataFree(struct glyphdata *gd) { - int i; - if ( gd == NULL ) -return; - - FreeMonotonics( gd->ms ); gd->ms = NULL; - free( gd->space ); gd->space = NULL; - free( gd->sspace ); gd->sspace = NULL; - free( gd->stspace ); gd->stspace = NULL; - free( gd->pspace ); gd->pspace = NULL; - - /* Clean up temporary point numbers */ - for ( i=0; i<gd->pcnt; ++i ) if ( gd->points[i].sp != NULL ) - gd->points[i].sp->ptindex = 0; - - if ( gd->hbundle != NULL ) { - free( gd->hbundle->stemlist ); - free( gd->hbundle ); - } - if ( gd->vbundle != NULL ) { - free( gd->vbundle->stemlist ); - free( gd->vbundle ); - } - if ( gd->ibundle != NULL ) { - free( gd->ibundle->stemlist ); - free( gd->ibundle ); - } - - for ( i=0; i<gd->linecnt; ++i ) - free( gd->lines[i].points ); - for ( i=0; i<gd->stemcnt; ++i ) { - free( gd->stems[i].chunks ); - free( gd->stems[i].dependent ); - free( gd->stems[i].serifs ); - free( gd->stems[i].active ); - } - for ( i=0; i<gd->pcnt; ++i ) { - free( gd->points[i].nextstems ); - free( gd->points[i].next_is_l ); - free( gd->points[i].prevstems ); - free( gd->points[i].prev_is_l ); - } - free( gd->lines ); - free( gd->stems ); - free( gd->contourends ); - free( gd->points ); - free( gd ); -} |