/***************************************************************************//*                                                                         *//*  ahglobal.c                                                             *//*                                                                         *//*    Routines used to compute global metrics automatically (body).        *//*                                                                         *//*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    *//*  Author: David Turner                                                   *//*                                                                         *//*  This file is part of the Catharon Typography Project and shall only    *//*  be used, modified, and distributed under the terms of the Catharon     *//*  Open Source License that should come with this file under the name     *//*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    *//*  this file you indicate that you have read the license and              *//*  understand and accept it fully.                                        *//*                                                                         *//*  Note that this license is compatible with the FreeType license.        *//*                                                                         *//***************************************************************************/#include <ft2build.h>#include FT_INTERNAL_DEBUG_H#include "ahglobal.h"#include "ahglyph.h"#define MAX_TEST_CHARACTERS  12  static  const char*  blue_chars[ah_blue_max] =  {    "THEZOCQS",    "HEZLOCUS",    "xzroesc",    "xzroesc",    "pqgjy"  };  /* simple insertion sort */  static void  sort_values( FT_Int   count,               FT_Pos*  table )  {    FT_Int  i, j, swap;    for ( i = 1; i < count; i++ )    {      for ( j = i; j > 0; j-- )      {        if ( table[j] > table[j - 1] )          break;        swap         = table[j];        table[j]     = table[j - 1];        table[j - 1] = swap;      }    }  }  static FT_Error  ah_hinter_compute_blues( AH_Hinter*  hinter )  {    AH_Blue       blue;    AH_Globals*   globals = &hinter->globals->design;    FT_Pos        flats [MAX_TEST_CHARACTERS];    FT_Pos        rounds[MAX_TEST_CHARACTERS];    FT_Int        num_flats;    FT_Int        num_rounds;    FT_Face       face;    FT_GlyphSlot  glyph;    FT_Error      error;    FT_CharMap    charmap;    face  = hinter->face;    glyph = face->glyph;    /* save current charmap */    charmap = face->charmap;    /* do we have a Unicode charmap in there? */    error = FT_Select_Charmap( face, ft_encoding_unicode );    if ( error )      goto Exit;    /* we compute the blues simply by loading each character from the */    /* 'blue_chars[blues]' string, then compute its top-most and      */    /* bottom-most points                                             */    AH_LOG(( "blue zones computation\n" ));    AH_LOG(( "------------------------------------------------\n" ));    for ( blue = ah_blue_capital_top; blue < ah_blue_max; blue++ )    {      const char*  p     = blue_chars[blue];      const char*  limit = p + MAX_TEST_CHARACTERS;      FT_Pos       *blue_ref, *blue_shoot;      AH_LOG(( "blue %3d: ", blue ));      num_flats  = 0;      num_rounds = 0;      for ( ; p < limit; p++ )      {        FT_UInt     glyph_index;        FT_Vector*  extremum;        FT_Vector*  points;        FT_Vector*  point_limit;        FT_Vector*  point;        FT_Bool     round;        /* exit if we reach the end of the string */        if ( !*p )          break;        AH_LOG(( "`%c'", *p ));        /* load the character in the face -- skip unknown or empty ones */        glyph_index = FT_Get_Char_Index( face, (FT_UInt)*p );        if ( glyph_index == 0 )          continue;        error = FT_Load_Glyph( face, glyph_index, FT_LOAD_NO_SCALE );        if ( error || glyph->outline.n_points <= 0 )          continue;        /* now compute min or max point indices and coordinates */        points      = glyph->outline.points;        point_limit = points + glyph->outline.n_points;        point       = points;        extremum    = point;        point++;        if ( AH_IS_TOP_BLUE( blue ) )        {          for ( ; point < point_limit; point++ )            if ( point->y > extremum->y )              extremum = point;        }        else        {          for ( ; point < point_limit; point++ )            if ( point->y < extremum->y )              extremum = point;        }        AH_LOG(( "%5d", (int)extremum->y ));        /* now, check whether the point belongs to a straight or round  */        /* segment; we first need to find in which contour the extremum */        /* lies, then see its previous and next points                  */        {          FT_Int  idx = (FT_Int)( extremum - points );          FT_Int  n;          FT_Int  first, last, prev, next, end;          FT_Pos  dist;          last  = -1;          first = 0;          for ( n = 0; n < glyph->outline.n_contours; n++ )          {            end = glyph->outline.contours[n];            if ( end >= idx )            {              last = end;              break;            }            first = end + 1;          }          /* XXX: should never happen! */          if ( last < 0 )            continue;          /* now look for the previous and next points that are not on the */          /* same Y coordinate.  Threshold the `closeness'...              */          prev = idx;          next = prev;          do          {            if ( prev > first )              prev--;            else              prev = last;            dist = points[prev].y - extremum->y;            if ( dist < -5 || dist > 5 )              break;          } while ( prev != idx );          do          {            if ( next < last )              next++;            else              next = first;            dist = points[next].y - extremum->y;            if ( dist < -5 || dist > 5 )              break;          } while ( next != idx );          /* now, set the `round' flag depending on the segment's kind */          round = FT_BOOL(            FT_CURVE_TAG( glyph->outline.tags[prev] ) != FT_Curve_Tag_On ||            FT_CURVE_TAG( glyph->outline.tags[next] ) != FT_Curve_Tag_On );          AH_LOG(( "%c ", round ? 'r' : 'f' ));        }        if ( round )          rounds[num_rounds++] = extremum->y;        else          flats[num_flats++] = extremum->y;      }      AH_LOG(( "\n" ));      /* we have computed the contents of the `rounds' and `flats' tables, */      /* now determine the reference and overshoot position of the blue;   */      /* we simply take the median value after a simple short              */      sort_values( num_rounds, rounds );      sort_values( num_flats,  flats  );      blue_ref   = globals->blue_refs + blue;      blue_shoot = globals->blue_shoots + blue;      if ( num_flats == 0 && num_rounds == 0 )      {        *blue_ref   = -10000;        *blue_shoot = -10000;      }      else if ( num_flats == 0 )      {        *blue_ref   =        *blue_shoot = rounds[num_rounds / 2];      }      else if ( num_rounds == 0 )      {        *blue_ref   =        *blue_shoot = flats[num_flats / 2];      }      else      {        *blue_ref   = flats[num_flats / 2];        *blue_shoot = rounds[num_rounds / 2];      }      /* there are sometimes problems: if the overshoot position of top     */      /* zones is under its reference position, or the opposite for bottom  */      /* zones.  We must thus check everything there and correct the errors */      if ( *blue_shoot != *blue_ref )      {        FT_Pos   ref      = *blue_ref;        FT_Pos   shoot    = *blue_shoot;        FT_Bool  over_ref = FT_BOOL( shoot > ref );        if ( AH_IS_TOP_BLUE( blue ) ^ over_ref )          *blue_shoot = *blue_ref = ( shoot + ref ) / 2;      }      AH_LOG(( "-- ref = %ld, shoot = %ld\n", *blue_ref, *blue_shoot ));    }    /* reset original face charmap */    FT_Set_Charmap( face, charmap );    error = 0;  Exit:    return error;  }  static FT_Error  ah_hinter_compute_widths( AH_Hinter*  hinter )  {    /* scan the array of segments in each direction */    AH_Outline*  outline = hinter->glyph;    AH_Segment*  segments;    AH_Segment*  limit;    AH_Globals*  globals = &hinter->globals->design;    FT_Pos*      widths;    FT_Int       dimension;    FT_Int*      p_num_widths;    FT_Error     error = 0;    FT_Pos       edge_distance_threshold = 32000;    globals->num_widths  = 0;    globals->num_heights = 0;    /* For now, compute the standard width and height from the `o'       */    /* character.  I started computing the stem width of the `i' and the */    /* stem height of the "-", but it wasn't too good.  Moreover, we now */    /* have a single character that gives us standard width and height.  */    {      FT_UInt   glyph_index;      glyph_index = FT_Get_Char_Index( hinter->face, 'o' );      if ( glyph_index == 0 )        return 0;      error = FT_Load_Glyph( hinter->face, glyph_index, FT_LOAD_NO_SCALE );      if ( error )        goto Exit;      error = ah_outline_load( hinter->glyph, hinter->face );      if ( error )        goto Exit;      ah_outline_compute_segments( hinter->glyph );      ah_outline_link_segments( hinter->glyph );    }    segments     = outline->horz_segments;    limit        = segments + outline->num_hsegments;    widths       = globals->heights;    p_num_widths = &globals->num_heights;    for ( dimension = 1; dimension >= 0; dimension-- )    {      AH_Segment*  seg = segments;      AH_Segment*  link;      FT_Int       num_widths = 0;      for ( ; seg < limit; seg++ )      {        link = seg->link;        /* we only consider stem segments there! */        if ( link && link->link == seg && link > seg )        {          FT_Int  dist;          dist = seg->pos - link->pos;          if ( dist < 0 )            dist = -dist;          if ( num_widths < 12 )            widths[num_widths++] = dist;        }      }      sort_values( num_widths, widths );      *p_num_widths = num_widths;      /* we will now try to find the smallest width */      if ( num_widths > 0 && widths[0] < edge_distance_threshold )        edge_distance_threshold = widths[0];      segments     = outline->vert_segments;      limit        = segments + outline->num_vsegments;      widths       = globals->widths;      p_num_widths = &globals->num_widths;    }    /* Now, compute the edge distance threshold as a fraction of the */    /* smallest width in the font. Set it in `hinter.glyph' too!     */    if ( edge_distance_threshold == 32000 )      edge_distance_threshold = 50;    /* let's try 20% */    hinter->glyph->edge_distance_threshold = edge_distance_threshold / 5;  Exit:    return error;  }  FT_LOCAL_DEF( FT_Error )  ah_hinter_compute_globals( AH_Hinter*  hinter )  {    return ah_hinter_compute_widths( hinter ) ||           ah_hinter_compute_blues ( hinter );  }/* END */