1 using System;

  2

  3 namespace sharonjl.utils

  4 {

  5     public static class Geohash

  6     {

  7         #region Direction enum

  8

  9         public enum Direction

 10         {

 11             Top = 0,

 12             Right = 1,

 13             Bottom = 2,

 14             Left = 3

 15         }

 16

 17         #endregion

 18

 19         private const string Base32 = "0123456789bcdefghjkmnpqrstuvwxyz";

 20         private static readonly int[] Bits = new[] {16, 8, 4, 2, 1};

 21

 22         private static readonly string[][] Neighbors = {

 23                                                            new[]

 24                                                                {

 25                                                                    "p0r21436x8zb9dcf5h7kjnmqesgutwvy", // Top

 26                                                                    "bc01fg45238967deuvhjyznpkmstqrwx", // Right

 27                                                                    "14365h7k9dcfesgujnmqp0r2twvyx8zb", // Bottom

 28                                                                    "238967debc01fg45kmstqrwxuvhjyznp", // Left

 29                                                                }, new[]

 30                                                                       {

 31                                                                           "bc01fg45238967deuvhjyznpkmstqrwx", // Top

 32                                                                           "p0r21436x8zb9dcf5h7kjnmqesgutwvy", // Right

 33                                                                           "238967debc01fg45kmstqrwxuvhjyznp", // Bottom

 34                                                                           "14365h7k9dcfesgujnmqp0r2twvyx8zb", // Left

 35                                                                       }

 36                                                        };

 37

 38         private static readonly string[][] Borders = {

 39                                                          new[] {"prxz", "bcfguvyz", "028b", "0145hjnp"},

 40                                                          new[] {"bcfguvyz", "prxz", "0145hjnp", "028b"}

 41                                                      };

 42

 43         public static String CalculateAdjacent(String hash, Direction direction)

 44         {

 45             hash = hash.ToLower();

 46

 47             char lastChr = hash[hash.Length - 1];

 48             int type = hash.Length%2;

 49             var dir = (int) direction;

 50             string nHash = hash.Substring(0, hash.Length - 1);

 51

 52             if (Borders[type][dir].IndexOf(lastChr) != -1)

 53             {

 54                 nHash = CalculateAdjacent(nHash, (Direction) dir);

 55             }

 56             return nHash + Base32[Neighbors[type][dir].IndexOf(lastChr)];

 57         }

 58

 59         public static void RefineInterval(ref double[] interval, int cd, int mask)

 60         {

 61             if ((cd & mask) != 0)

 62             {

 63                 interval[0] = (interval[0] + interval[1])/2;

 64             }

 65             else

 66             {

 67                 interval[1] = (interval[0] + interval[1])/2;

 68             }

 69         }

 70

 71         public static double[] Decode(String geohash)

 72         {

 73             bool even = true;

 74             double[] lat = {-90.0, 90.0};

 75             double[] lon = {-180.0, 180.0};

 76

 77             foreach (char c in geohash)

 78             {

 79                 int cd = Base32.IndexOf(c);

 80                 for (int j = 0; j < 5; j++)

 81                 {

 82                     int mask = Bits[j];

 83                     if (even)

 84                     {

 85                         RefineInterval(ref lon, cd, mask);

 86                     }

 87                     else

 88                     {

 89                         RefineInterval(ref lat, cd, mask);

 90                     }

 91                     even = !even;

 92                 }

 93             }

 94

 95             return new[] {(lat[0] + lat[1])/2, (lon[0] + lon[1])/2};

 96         }

 97

 98         public static String Encode(double latitude, double longitude, int precision = 12)

 99         {

100             bool even = true;

101             int bit = 0;

102             int ch = 0;

103             string geohash = "";

104

105             double[] lat = {-90.0, 90.0};

106             double[] lon = {-180.0, 180.0};

107

108             if (precision < 1 || precision > 20) precision = 12;

109

110             while (geohash.Length < precision)

111             {

112                 double mid;

113

114                 if (even)

115                 {

116                     mid = (lon[0] + lon[1])/2;

117                     if (longitude > mid)

118                     {

119                         ch |= Bits[bit];

120                         lon[0] = mid;

121                     }

122                     else

123                         lon[1] = mid;

124                 }

125                 else

126                 {

127                     mid = (lat[0] + lat[1])/2;

128                     if (latitude > mid)

129                     {

130                         ch |= Bits[bit];

131                         lat[0] = mid;

132                     }

133                     else

134                         lat[1] = mid;

135                 }

136

137                 even = !even;

138                 if (bit < 4)

139                     bit++;

140                 else

141                 {

142                     geohash += Base32[ch];

143                     bit = 0;

144                     ch = 0;

145                 }

146             }

147             return geohash;

148         }

149     }

150 }