libraries/freetype-2.0.5/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-2001 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 #include <ft2build.h>
  24 #include "ahangles.h"
  25
  26
  27   /* the following table has been automatically generated with */
  28   /* the `mather.py' Python script                             */
  29
  30   const AH_Angle  ah_arctan[1L << AH_ATAN_BITS] =
  31   {
  32      0,  0,  1,  1,  1,  2,  2,  2,
  33      3,  3,  3,  3,  4,  4,  4,  5,
  34      5,  5,  6,  6,  6,  7,  7,  7,
  35      8,  8,  8,  9,  9,  9, 10, 10,
  36     10, 10, 11, 11, 11, 12, 12, 12,
  37     13, 13, 13, 14, 14, 14, 14, 15,
  38     15, 15, 16, 16, 16, 17, 17, 17,
  39     18, 18, 18, 18, 19, 19, 19, 20,
  40     20, 20, 21, 21, 21, 21, 22, 22,
  41     22, 23, 23, 23, 24, 24, 24, 24,
  42     25, 25, 25, 26, 26, 26, 26, 27,
  43     27, 27, 28, 28, 28, 28, 29, 29,
  44     29, 30, 30, 30, 30, 31, 31, 31,
  45     31, 32, 32, 32, 33, 33, 33, 33,
  46     34, 34, 34, 34, 35, 35, 35, 35,
  47     36, 36, 36, 36, 37, 37, 37, 38,
  48     38, 38, 38, 39, 39, 39, 39, 40,
  49     40, 40, 40, 41, 41, 41, 41, 42,
  50     42, 42, 42, 42, 43, 43, 43, 43,
  51     44, 44, 44, 44, 45, 45, 45, 45,
  52     46, 46, 46, 46, 46, 47, 47, 47,
  53     47, 48, 48, 48, 48, 48, 49, 49,
  54     49, 49, 50, 50, 50, 50, 50, 51,
  55     51, 51, 51, 51, 52, 52, 52, 52,
  56     52, 53, 53, 53, 53, 53, 54, 54,
  57     54, 54, 54, 55, 55, 55, 55, 55,
  58     56, 56, 56, 56, 56, 57, 57, 57,
  59     57, 57, 57, 58, 58, 58, 58, 58,
  60     59, 59, 59, 59, 59, 59, 60, 60,
  61     60, 60, 60, 61, 61, 61, 61, 61,
  62     61, 62, 62, 62, 62, 62, 62, 63,
  63     63, 63, 63, 63, 63, 64, 64, 64
  64   };
  65
  66
  67   FT_LOCAL_DEF AH_Angle
  68   ah_angle( FT_Vector*  v )
  69   {
  70     FT_Pos    dx, dy;
  71     AH_Angle  angle;
  72
  73
  74     dx = v->x;
  75     dy = v->y;
  76
  77     /* check trivial cases */
  78     if ( dy == 0 )
  79     {
  80       angle = 0;
  81       if ( dx < 0 )
  82         angle = AH_PI;
  83       return angle;
  84     }
  85     else if ( dx == 0 )
  86     {
  87       angle = AH_HALF_PI;
  88       if ( dy < 0 )
  89         angle = -AH_HALF_PI;
  90       return angle;
  91     }
  92
  93     angle = 0;
  94     if ( dx < 0 )
  95     {
  96       dx = -v->x;
  97       dy = -v->y;
  98       angle = AH_PI;
  99     }
 100
 101     if ( dy < 0 )
 102     {
 103       FT_Pos  tmp;
 104
 105
 106       tmp = dx;
 107       dx  = -dy;
 108       dy  = tmp;
 109       angle -= AH_HALF_PI;
 110     }
 111
 112     if ( dx == 0 && dy == 0 )
 113       return 0;
 114
 115     if ( dx == dy )
 116       angle += AH_PI / 4;
 117     else if ( dx > dy )
 118       angle += ah_arctan[FT_DivFix( dy, dx ) >> ( 16 - AH_ATAN_BITS )];
 119     else
 120       angle += AH_HALF_PI -
 121                ah_arctan[FT_DivFix( dx, dy ) >> ( 16 - AH_ATAN_BITS )];
 122
 123     if ( angle > AH_PI )
 124       angle -= AH_2PI;
 125
 126     return angle;
 127   }
 128
 129
 130 /* END */