kc3-lang/freetype/src/autohint/ahangles.c

• Show log

  Commit

• Hash : 66456162
  Author :
  Date : 2002-08-21T21:34:59
  

  * src/pshinter/pshalgo3.c, src/autohint/ahangles.c, src/autohint/ahangles.h, src/autohint/ahglyph.c, src/autohint/ahhint.c, src/autohint/ahtypes.h: the automatic and Postscript hinter now automatically detect inflection points in glyph outlines and treats them specially. This is very useful to prevent nasty effect like the disappearing diagonals of "S" and "s" in many, many fonts..

Download

• src/autohint/ahangles.c

• /***************************************************************************/
  /*                                                                         */
  /*  ahangles.h                                                             */
  /*                                                                         */
  /*    A routine used to compute vector angles with limited accuracy        */
  /*    and very high speed (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 "ahangles.h"
  
  
    /* the following table has been automatically generated with */
    /* the `mather.py' Python script                             */
  
    const AH_Angle  ah_arctan[1L << AH_ATAN_BITS] =
    {
       0,  0,  1,  1,  1,  2,  2,  2,
       3,  3,  3,  3,  4,  4,  4,  5,
       5,  5,  6,  6,  6,  7,  7,  7,
       8,  8,  8,  9,  9,  9, 10, 10,
      10, 10, 11, 11, 11, 12, 12, 12,
      13, 13, 13, 14, 14, 14, 14, 15,
      15, 15, 16, 16, 16, 17, 17, 17,
      18, 18, 18, 18, 19, 19, 19, 20,
      20, 20, 21, 21, 21, 21, 22, 22,
      22, 23, 23, 23, 24, 24, 24, 24,
      25, 25, 25, 26, 26, 26, 26, 27,
      27, 27, 28, 28, 28, 28, 29, 29,
      29, 30, 30, 30, 30, 31, 31, 31,
      31, 32, 32, 32, 33, 33, 33, 33,
      34, 34, 34, 34, 35, 35, 35, 35,
      36, 36, 36, 36, 37, 37, 37, 38,
      38, 38, 38, 39, 39, 39, 39, 40,
      40, 40, 40, 41, 41, 41, 41, 42,
      42, 42, 42, 42, 43, 43, 43, 43,
      44, 44, 44, 44, 45, 45, 45, 45,
      46, 46, 46, 46, 46, 47, 47, 47,
      47, 48, 48, 48, 48, 48, 49, 49,
      49, 49, 50, 50, 50, 50, 50, 51,
      51, 51, 51, 51, 52, 52, 52, 52,
      52, 53, 53, 53, 53, 53, 54, 54,
      54, 54, 54, 55, 55, 55, 55, 55,
      56, 56, 56, 56, 56, 57, 57, 57,
      57, 57, 57, 58, 58, 58, 58, 58,
      59, 59, 59, 59, 59, 59, 60, 60,
      60, 60, 60, 61, 61, 61, 61, 61,
      61, 62, 62, 62, 62, 62, 62, 63,
      63, 63, 63, 63, 63, 64, 64, 64
    };
  
  
    FT_LOCAL_DEF( AH_Angle )
    ah_angle( FT_Vector*  v )
    {
      FT_Pos    dx, dy;
      AH_Angle  angle;
  
  
      dx = v->x;
      dy = v->y;
  
      /* check trivial cases */
      if ( dy == 0 )
      {
        angle = 0;
        if ( dx < 0 )
          angle = AH_PI;
        return angle;
      }
      else if ( dx == 0 )
      {
        angle = AH_HALF_PI;
        if ( dy < 0 )
          angle = -AH_HALF_PI;
        return angle;
      }
  
      angle = 0;
      if ( dx < 0 )
      {
        dx = -v->x;
        dy = -v->y;
        angle = AH_PI;
      }
  
      if ( dy < 0 )
      {
        FT_Pos  tmp;
  
  
        tmp = dx;
        dx  = -dy;
        dy  = tmp;
        angle -= AH_HALF_PI;
      }
  
      if ( dx == 0 && dy == 0 )
        return 0;
  
      if ( dx == dy )
        angle += AH_PI / 4;
      else if ( dx > dy )
        angle += ah_arctan[FT_DivFix( dy, dx ) >> ( 16 - AH_ATAN_BITS )];
      else
        angle += AH_HALF_PI -
                 ah_arctan[FT_DivFix( dx, dy ) >> ( 16 - AH_ATAN_BITS )];
  
      if ( angle > AH_PI )
        angle -= AH_2PI;
  
      return angle;
    }
  
  
    FT_LOCAL_DEF( AH_Angle )
    ah_angle_diff( AH_Angle  angle1,
                   AH_Angle  angle2 )
    {
      AH_Angle  delta;
      
      delta = ( angle2 - angle1 );
      if ( delta < 0 )
        delta += AH_2PI;
      
      if ( delta > AH_PI )
        delta -= AH_2PI;
      
      return delta;
    }                 
  
  /* END */
  

Download