shithub: freetype+ttf2subf

ref: c49f69cb8c9d9b38179f760bf0cbbe4c78a3e296
dir: /src/autohint/ahangles.c/

View raw version
/***************************************************************************/
/*                                                                         */
/*  ahangles.h                                                             */
/*                                                                         */
/*    a routine used to compute vector angles with limited accuracy        */
/*    and very high speed.                                                 */
/*                                                                         */
/*  Copyright 2000: 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         */
/*                                                                         */
/***************************************************************************/
#ifdef FT_FLAT_COMPILE
#include "ahangles.h"
#else
#include <autohint/ahangles.h>
#endif

/* the following two tables are automatically generated with */
/* the "mather.py" Python script..                           */

static 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
};


  LOCAL_FUNC
  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;
  }