src/freetype/autohint/ahangles.c

/***************************************************************************/
/*                                                                         */
/*  ahangles.h                                                             */
/*                                                                         */
/*    A routine used to compute vector angles with limited accuracy        */
/*    and very high speed (body).                                          */
/*                                                                         */
/*  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 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
  };


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


/* END */
Commit	Line	Data
	1	/***************************************************************************/
	2	/* */
	3	/* ahangles.h */
	4	/* */
	5	/* A routine used to compute vector angles with limited accuracy */
	6	/* and very high speed (body). */
	7	/* */
	8	/* Copyright 2000 Catharon Productions Inc. */
	9	/* Author: David Turner */
	10	/* */
	11	/* This file is part of the Catharon Typography Project and shall only */
	12	/* be used, modified, and distributed under the terms of the Catharon */
	13	/* Open Source License that should come with this file under the name */
	14	/* `CatharonLicense.txt'. By continuing to use, modify, or distribute */
	15	/* this file you indicate that you have read the license and */
	16	/* understand and accept it fully. */
	17	/* */
	18	/* Note that this license is compatible with the FreeType license. */
	19	/* */
	20	/***************************************************************************/
	21
	22
	23	#ifdef FT_FLAT_COMPILE
	24
	25	#include "ahangles.h"
	26
	27	#else
	28
	29	#include <autohint/ahangles.h>
	30
	31	#endif
	32
	33
	34	/* the following table has been automatically generated with */
	35	/* the `mather.py' Python script */
	36
	37	const AH_Angle ah_arctan[1L << AH_ATAN_BITS] =
	38	{
	39	0, 0, 1, 1, 1, 2, 2, 2,
	40	3, 3, 3, 3, 4, 4, 4, 5,
	41	5, 5, 6, 6, 6, 7, 7, 7,
	42	8, 8, 8, 9, 9, 9, 10, 10,
	43	10, 10, 11, 11, 11, 12, 12, 12,
	44	13, 13, 13, 14, 14, 14, 14, 15,
	45	15, 15, 16, 16, 16, 17, 17, 17,
	46	18, 18, 18, 18, 19, 19, 19, 20,
	47	20, 20, 21, 21, 21, 21, 22, 22,
	48	22, 23, 23, 23, 24, 24, 24, 24,
	49	25, 25, 25, 26, 26, 26, 26, 27,
	50	27, 27, 28, 28, 28, 28, 29, 29,
	51	29, 30, 30, 30, 30, 31, 31, 31,
	52	31, 32, 32, 32, 33, 33, 33, 33,
	53	34, 34, 34, 34, 35, 35, 35, 35,
	54	36, 36, 36, 36, 37, 37, 37, 38,
	55	38, 38, 38, 39, 39, 39, 39, 40,
	56	40, 40, 40, 41, 41, 41, 41, 42,
	57	42, 42, 42, 42, 43, 43, 43, 43,
	58	44, 44, 44, 44, 45, 45, 45, 45,
	59	46, 46, 46, 46, 46, 47, 47, 47,
	60	47, 48, 48, 48, 48, 48, 49, 49,
	61	49, 49, 50, 50, 50, 50, 50, 51,
	62	51, 51, 51, 51, 52, 52, 52, 52,
	63	52, 53, 53, 53, 53, 53, 54, 54,
	64	54, 54, 54, 55, 55, 55, 55, 55,
	65	56, 56, 56, 56, 56, 57, 57, 57,
	66	57, 57, 57, 58, 58, 58, 58, 58,
	67	59, 59, 59, 59, 59, 59, 60, 60,
	68	60, 60, 60, 61, 61, 61, 61, 61,
	69	61, 62, 62, 62, 62, 62, 62, 63,
	70	63, 63, 63, 63, 63, 64, 64, 64
	71	};
	72
	73
	74	LOCAL_FUNC
	75	AH_Angle ah_angle( FT_Vector* v )
	76	{
	77	FT_Pos dx, dy;
	78	AH_Angle angle;
	79
	80
	81	dx = v->x;
	82	dy = v->y;
	83
	84	/* check trivial cases */
	85	if ( dy == 0 )
	86	{
	87	angle = 0;
	88	if ( dx < 0 )
	89	angle = AH_PI;
	90	return angle;
	91	}
	92	else if ( dx == 0 )
	93	{
	94	angle = AH_HALF_PI;
	95	if ( dy < 0 )
	96	angle = -AH_HALF_PI;
	97	return angle;
	98	}
	99
	100	angle = 0;
	101	if ( dx < 0 )
	102	{
	103	dx = -v->x;
	104	dy = -v->y;
	105	angle = AH_PI;
	106	}
	107
	108	if ( dy < 0 )
	109	{
	110	FT_Pos tmp;
	111
	112
	113	tmp = dx;
	114	dx = -dy;
	115	dy = tmp;
	116	angle -= AH_HALF_PI;
	117	}
	118
	119	if ( dx == 0 && dy == 0 )
	120	return 0;
	121
	122	if ( dx == dy )
	123	angle += AH_PI / 4;
	124	else if ( dx > dy )
	125	angle += ah_arctan[FT_DivFix( dy, dx ) >> ( 16 - AH_ATAN_BITS )];
	126	else
	127	angle += AH_HALF_PI -
	128	ah_arctan[FT_DivFix( dx, dy ) >> ( 16 - AH_ATAN_BITS )];
	129
	130	if ( angle > AH_PI )
	131	angle -= AH_2PI;
	132
	133	return angle;
	134	}
	135
	136
	137	/* END */