/***************************************************************************/

/*                                                                         */

/*  aflatin.c                                                              */

/*                                                                         */

/*    Auto-fitter hinting routines for latin script (body).                */

/*                                                                         */

/*  Copyright 2003-2011 by                                                 */

/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */

/*                                                                         */

/*  This file is part of the FreeType project, and may only be used,       */

/*  modified, and distributed under the terms of the FreeType project      */

/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */

/*  this file you indicate that you have read the license and              */

/*  understand and accept it fully.                                        */

/*                                                                         */

/***************************************************************************/

#include <ft2build.h>

#include FT_ADVANCES_H

#include FT_INTERNAL_DEBUG_H

#include "aflatin.h"

#include "aferrors.h"

#ifdef AF_CONFIG_OPTION_USE_WARPER

#include "afwarp.h"

#endif

  /*************************************************************************/

  /*                                                                       */

  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */

  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */

  /* messages during execution.                                            */

  /*                                                                       */

#undef  FT_COMPONENT

#define FT_COMPONENT  trace_aflatin

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****            L A T I N   G L O B A L   M E T R I C S            *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  /* Find segments and links, compute all stem widths, and initialize */

  /* standard width and height for the glyph with given charcode.     */

  FT_LOCAL_DEF( void )

  af_latin_metrics_init_widths( AF_LatinMetrics  metrics,

                                FT_Face          face,

                                FT_ULong         charcode )

  {

    /* scan the array of segments in each direction */

    AF_GlyphHintsRec  hints[1];

    af_glyph_hints_init( hints, face->memory );

    metrics->axis[AF_DIMENSION_HORZ].width_count = 0;

    metrics->axis[AF_DIMENSION_VERT].width_count = 0;

    {

      FT_Error             error;

      FT_UInt              glyph_index;

      int                  dim;

      AF_LatinMetricsRec   dummy[1];

      AF_Scaler            scaler = &dummy->root.scaler;

      glyph_index = FT_Get_Char_Index( face, charcode );

      if ( glyph_index == 0 )

        goto Exit;

      error = FT_Load_Glyph( face, glyph_index, FT_LOAD_NO_SCALE );

      if ( error || face->glyph->outline.n_points <= 0 )

        goto Exit;

      FT_ZERO( dummy );

      dummy->units_per_em = metrics->units_per_em;

      scaler->x_scale = 0x10000L;

      scaler->y_scale = 0x10000L;

      scaler->x_delta = 0;

      scaler->y_delta = 0;

      scaler->face        = face;

      scaler->render_mode = FT_RENDER_MODE_NORMAL;

      scaler->flags       = 0;

      af_glyph_hints_rescale( hints, (AF_ScriptMetrics)dummy );

      error = af_glyph_hints_reload( hints, &face->glyph->outline );

      if ( error )

        goto Exit;

      for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )

      {

        AF_LatinAxis  axis    = &metrics->axis[dim];

        AF_AxisHints  axhints = &hints->axis[dim];

        AF_Segment    seg, limit, link;

        FT_UInt       num_widths = 0;

        error = af_latin_hints_compute_segments( hints,

                                                 (AF_Dimension)dim );

        if ( error )

          goto Exit;

        af_latin_hints_link_segments( hints,

                                      (AF_Dimension)dim );

        seg   = axhints->segments;

        limit = seg + axhints->num_segments;

        for ( ; seg < limit; seg++ )

        {

          link = seg->link;

          /* we only consider stem segments there! */

          if ( link && link->link == seg && link > seg )

          {

            FT_Pos  dist;

            dist = seg->pos - link->pos;

            if ( dist < 0 )

              dist = -dist;

            if ( num_widths < AF_LATIN_MAX_WIDTHS )

              axis->widths[num_widths++].org = dist;

          }

        }

        af_sort_widths( num_widths, axis->widths );

        axis->width_count = num_widths;

      }

  Exit:

      for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )

      {

        AF_LatinAxis  axis = &metrics->axis[dim];

        FT_Pos        stdw;

        stdw = ( axis->width_count > 0 )

                 ? axis->widths[0].org

                 : AF_LATIN_CONSTANT( metrics, 50 );

        /* let's try 20% of the smallest width */

        axis->edge_distance_threshold = stdw / 5;

        axis->standard_width          = stdw;

        axis->extra_light             = 0;

      }

    }

    af_glyph_hints_done( hints );

  }

#define AF_LATIN_MAX_TEST_CHARACTERS  12

  static const char af_latin_blue_chars[AF_LATIN_MAX_BLUES]

                                       [AF_LATIN_MAX_TEST_CHARACTERS + 1] =

  {

    "THEZOCQS",

    "HEZLOCUS",

    "fijkdbh",

    "xzroesc",

    "xzroesc",

    "pqgjy"

  };

  /* Find all blue zones.  Flat segments give the reference points, */

  /* round segments the overshoot positions.                        */

  static void

  af_latin_metrics_init_blues( AF_LatinMetrics  metrics,

                               FT_Face          face )

  {

    FT_Pos        flats [AF_LATIN_MAX_TEST_CHARACTERS];

    FT_Pos        rounds[AF_LATIN_MAX_TEST_CHARACTERS];

    FT_Int        num_flats;

    FT_Int        num_rounds;

    FT_Int        bb;

    AF_LatinBlue  blue;

    FT_Error      error;

    AF_LatinAxis  axis  = &metrics->axis[AF_DIMENSION_VERT];

    FT_GlyphSlot  glyph = face->glyph;

    /* we compute the blues simply by loading each character from the    */

    /* `af_latin_blue_chars[blues]' string, then finding its top-most or */

    /* bottom-most points (depending on `AF_IS_TOP_BLUE')                */

    FT_TRACE5(( "blue zones computation\n" ));

    FT_TRACE5(( "------------------------------------------------\n" ));

    for ( bb = 0; bb < AF_LATIN_BLUE_MAX; bb++ )

    {

      const char*  p     = af_latin_blue_chars[bb];

      const char*  limit = p + AF_LATIN_MAX_TEST_CHARACTERS;

      FT_Pos*      blue_ref;

      FT_Pos*      blue_shoot;

      FT_TRACE5(( "blue %3d: ", bb ));

      num_flats  = 0;

      num_rounds = 0;

      for ( ; p < limit && *p; p++ )

      {

        FT_UInt     glyph_index;

        FT_Pos      best_y;                            /* same as points.y */

        FT_Int      best_point, best_first, best_last;

        FT_Vector*  points;

        FT_Bool     round = 0;

        FT_TRACE5(( "'%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;

        best_point  = -1;

        best_y      = 0;  /* make compiler happy */

        best_first  = 0;  /* ditto */

        best_last   = 0;  /* ditto */

        {

          FT_Int  nn;

          FT_Int  first = 0;

          FT_Int  last  = -1;

          for ( nn = 0;

                nn < glyph->outline.n_contours;

                first = last + 1, nn++ )

          {

            FT_Int  old_best_point = best_point;

            FT_Int  pp;

            last = glyph->outline.contours[nn];

            /* Avoid single-point contours since they are never rasterized. */

            /* In some fonts, they correspond to mark attachment points     */

            /* which are way outside of the glyph's real outline.           */

            if ( last <= first )

              continue;

            if ( AF_LATIN_IS_TOP_BLUE( bb ) )

            {

              for ( pp = first; pp <= last; pp++ )

                if ( best_point < 0 || points[pp].y > best_y )

                {

                  best_point = pp;

                  best_y     = points[pp].y;

                }

            }

            else

            {

              for ( pp = first; pp <= last; pp++ )

                if ( best_point < 0 || points[pp].y < best_y )

                {

                  best_point = pp;

                  best_y     = points[pp].y;

                }

            }

            if ( best_point != old_best_point )

            {

              best_first = first;

              best_last  = last;

            }

          }

          FT_TRACE5(( "%5d", best_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 inspect its previous and next points              */

        if ( best_point >= 0 )

        {

          FT_Int  prev, next;

          FT_Pos  dist;

          /* now look for the previous and next points that are not on the */

          /* same Y coordinate.  Threshold the `closeness'...              */

          prev = best_point;

          next = prev;

          do

          {

            if ( prev > best_first )

              prev--;

            else

              prev = best_last;

            dist = points[prev].y - best_y;

            if ( dist < -5 || dist > 5 )

              break;

          } while ( prev != best_point );

          do

          {

            if ( next < best_last )

              next++;

            else

              next = best_first;

            dist = points[next].y - best_y;

            if ( dist < -5 || dist > 5 )

              break;

          } while ( next != best_point );

          /* 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 );

          FT_TRACE5(( "%c ", round ? 'r' : 'f' ));

        }

        if ( round )

          rounds[num_rounds++] = best_y;

        else

          flats[num_flats++]   = best_y;

      }

      FT_TRACE5(( "\n" ));

      if ( num_flats == 0 && num_rounds == 0 )

      {

        /*

         *  we couldn't find a single glyph to compute this blue zone,

         *  we will simply ignore it then

         */

        FT_TRACE5(( "empty\n" ));

        continue;

      }

      /* 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 sort               */

      af_sort_pos( num_rounds, rounds );

      af_sort_pos( num_flats,  flats );

      blue       = &axis->blues[axis->blue_count];

      blue_ref   = &blue->ref.org;

      blue_shoot = &blue->shoot.org;

      axis->blue_count++;

      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 ( AF_LATIN_IS_TOP_BLUE( bb ) ^ over_ref )

          *blue_ref   =

          *blue_shoot = ( shoot + ref ) / 2;

      }

      blue->flags = 0;

      if ( AF_LATIN_IS_TOP_BLUE( bb ) )

        blue->flags |= AF_LATIN_BLUE_TOP;

      /*

       * The following flag is used later to adjust the y and x scales

       * in order to optimize the pixel grid alignment of the top of small

       * letters.

       */

      if ( bb == AF_LATIN_BLUE_SMALL_TOP )

        blue->flags |= AF_LATIN_BLUE_ADJUSTMENT;

      FT_TRACE5(( "-- ref = %ld, shoot = %ld\n", *blue_ref, *blue_shoot ));

    }

    return;

  }

  /* Check whether all ASCII digits have the same advance width. */

  FT_LOCAL_DEF( void )

  af_latin_metrics_check_digits( AF_LatinMetrics  metrics,

                                 FT_Face          face )

  {

    FT_UInt   i;

    FT_Bool   started = 0, same_width = 1;

    FT_Fixed  advance, old_advance = 0;

    /* digit `0' is 0x30 in all supported charmaps */

    for ( i = 0x30; i <= 0x39; i++ )

    {

      FT_UInt  glyph_index;

      glyph_index = FT_Get_Char_Index( face, i );

      if ( glyph_index == 0 )

        continue;

      if ( FT_Get_Advance( face, glyph_index,

                           FT_LOAD_NO_SCALE         |

                           FT_LOAD_NO_HINTING       |

                           FT_LOAD_IGNORE_TRANSFORM,

                           &advance ) )

        continue;

      if ( started )

      {

        if ( advance != old_advance )

        {

          same_width = 0;

          break;

        }

      }

      else

      {

        old_advance = advance;

        started     = 1;

      }

    }

    metrics->root.digits_have_same_width = same_width;

  }

  /* Initialize global metrics. */

  FT_LOCAL_DEF( FT_Error )

  af_latin_metrics_init( AF_LatinMetrics  metrics,

                         FT_Face          face )

  {

    FT_Error    error = AF_Err_Ok;

    FT_CharMap  oldmap = face->charmap;

    FT_UInt     ee;

    static const FT_Encoding  latin_encodings[] =

    {

      FT_ENCODING_UNICODE,

      FT_ENCODING_APPLE_ROMAN,

      FT_ENCODING_ADOBE_STANDARD,

      FT_ENCODING_ADOBE_LATIN_1,

      FT_ENCODING_NONE  /* end of list */

    };

    metrics->units_per_em = face->units_per_EM;

    /* do we have a latin charmap in there? */

    for ( ee = 0; latin_encodings[ee] != FT_ENCODING_NONE; ee++ )

    {

      error = FT_Select_Charmap( face, latin_encodings[ee] );

      if ( !error )

        break;

    }

    if ( !error )

    {

      /* For now, compute the standard width and height from the `o'. */

      af_latin_metrics_init_widths( metrics, face, 'o' );

      af_latin_metrics_init_blues( metrics, face );

      af_latin_metrics_check_digits( metrics, face );

    }

    FT_Set_Charmap( face, oldmap );

    return AF_Err_Ok;

  }

  /* Adjust scaling value, then scale and shift widths   */

  /* and blue zones (if applicable) for given dimension. */

  static void

  af_latin_metrics_scale_dim( AF_LatinMetrics  metrics,

                              AF_Scaler        scaler,

                              AF_Dimension     dim )

  {

    FT_Fixed      scale;

    FT_Pos        delta;

    AF_LatinAxis  axis;

    FT_UInt       nn;