src/freetype/autohint/ahangles.c

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