Geohash 基本知识及 .NET 下计算相邻8个区域编码

目录

• 一、简介
• 二、计算方法
• 三、GeoHash的精度
• 四、查找相邻8个区域的Geohash编码（.NET）
• 五、MySQL 中使用 GeoHash

最近项目中需要搜索周边的 POI 信息，查找的过程中了解到了 Geohash ，这这里记录下以便自己牢记也和大家分享下。

一、简介

GeoHash是一种地址编码方法。他能够把二维的空间经纬度数据编码成一个字符串。GeoHash具有以下特点：
1、GeoHash用一个字符串表示经度和纬度两个坐标。在数据库中可以实现在一列上应用索引
2、GeoHash表示的并不是一个点，而是一个区域；
3、GeoHash编码的前缀可以表示更大的区域。例如wx4g0ec1，它的前缀wx4g0e表示包含编码wx4g0ec1在内的更大范围。 这个特性可以用于附近地点搜索

二、计算方法

GeoHash的计算过程分为三步：
1、将经纬度转换成二进制：
比如这样一个点（39.923201, 116.390705）
纬度的范围是（-90，90），其中间值为0。对于纬度39.923201，在区间（0，90）中，因此得到一个1；（0，90）区间的中间值为45度，纬度39.923201小于45，因此得到一个0，依次计算下去，即可得到纬度的二进制表示，如下表：

最后得到纬度的二进制表示为：
10111000110001111001
同理可以得到经度116.390705的二进制表示为：
11010010110001000100
2、合并纬度、经度的二进制：
合并方法是将经度、纬度二进制按照奇偶位合并：
11100 11101 00100 01111 00000 01101 01011 00001
3、按照Base32进行编码：
Base32编码表（其中一种）：

将上述合并后二进制编码后结果为：
wx4g0ec1

三、GeoHash的精度

编码越长，表示的范围越小，位置也越精确。因此我们就可以通过比较GeoHash匹配的位数来判断两个点之间的大概距离。

四、查找相邻8个区域的Geohash编码（.NET）

为什么会有这样的算法，原因是Geohash是有缺点的，如下：

边缘附近的点，黄色的点要比黑色的点更加靠近红点，但是由于黑点跟红点的GeoHash前缀匹配数目更多，因此得到黑点更加靠近红点的结果（如下图）

这个问题的解决办法就是：筛选周围8个区域内的所有点，然后计算距离得到满足条件结果

下面是用C#写的在 .NET 平台下的寻找给定区域相邻的8个区域的代码

 using System;

 namespace sharonjl.utils
 {
     public static class Geohash
     {
         #region Direction enum

         public enum Direction
         {
             Top = ,
             Right = ,
             Bottom = ,
             Left =
         }

         #endregion

         private const string Base32 = "0123456789bcdefghjkmnpqrstuvwxyz";
         private static readonly int[] Bits = new[] {, , , , };

         private static readonly string[][] Neighbors = {
                                                            new[]
                                                                {
                                                                    "p0r21436x8zb9dcf5h7kjnmqesgutwvy", // Top
                                                                    "bc01fg45238967deuvhjyznpkmstqrwx", // Right
                                                                    "14365h7k9dcfesgujnmqp0r2twvyx8zb", // Bottom
                                                                    "238967debc01fg45kmstqrwxuvhjyznp", // Left
                                                                }, new[]
                                                                       {
                                                                           "bc01fg45238967deuvhjyznpkmstqrwx", // Top
                                                                           "p0r21436x8zb9dcf5h7kjnmqesgutwvy", // Right
                                                                           "238967debc01fg45kmstqrwxuvhjyznp", // Bottom
                                                                           "14365h7k9dcfesgujnmqp0r2twvyx8zb", // Left
                                                                       }
                                                        };

         private static readonly string[][] Borders = {
                                                          new[] {"prxz", "bcfguvyz", "028b", "0145hjnp"},
                                                          new[] {"bcfguvyz", "prxz", "0145hjnp", "028b"}
                                                      };
         /// <summary>
         /// 计算相邻
         /// </summary>
         /// <param name="hash"></param>
         /// <param name="direction"></param>
         /// <returns></returns>
         public static String CalculateAdjacent(String hash, Direction direction)
         {
             hash = hash.ToLower();

             char lastChr = hash[hash.Length - ];
             int type = hash.Length%;
             var dir = (int) direction;
             string nHash = hash.Substring(, hash.Length - );

             if (Borders[type][dir].IndexOf(lastChr) != -)
             {
                 nHash = CalculateAdjacent(nHash, (Direction) dir);
             }
             return nHash + Base32[Neighbors[type][dir].IndexOf(lastChr)];
         }
         /// <summary>
         /// 细化间隔
         /// </summary>
         /// <param name="interval"></param>
         /// <param name="cd"></param>
         /// <param name="mask"></param>
         public static void RefineInterval(ref double[] interval, int cd, int mask)
         {
             if ((cd & mask) != )
             {
                 interval[] = (interval[] + interval[])/;
             }
             else
             {
                 interval[] = (interval[] + interval[])/;
             }
         }

         /// <summary>
         /// 解码
         /// </summary>
         /// <param name="geohash"></param>
         /// <returns></returns>
         public static double[] Decode(String geohash)
         {
             bool even = true;
             double[] lat = {-90.0, 90.0};
             double[] lon = {-180.0, 180.0};

             foreach (char c in geohash)
             {
                 int cd = Base32.IndexOf(c);
                 for (int j = ; j < ; j++)
                 {
                     int mask = Bits[j];
                     if (even)
                     {
                         RefineInterval(ref lon, cd, mask);
                     }
                     else
                     {
                         RefineInterval(ref lat, cd, mask);
                     }
                     even = !even;
                 }
             }

             return new[] {(lat[] + lat[])/, (lon[] + lon[])/};
         }
         /// <summary>
         /// 编码
         /// </summary>
         /// <param name="latitude">纬度</param>
         /// <param name="longitude">经度</param>
         /// <param name="precision">精度</param>
         /// <returns></returns>
         public static String Encode(double latitude, double longitude, int precision = )
         {
             bool even = true;
             int bit = ;
             int ch = ;
             string geohash = "";

             double[] lat = {-90.0, 90.0};
             double[] lon = {-180.0, 180.0};

             if (precision <  || precision > ) precision = ;

             while (geohash.Length < precision)
             {
                 double mid;

                 if (even)
                 {
                     mid = (lon[] + lon[])/;
                     if (longitude > mid)
                     {
                         ch |= Bits[bit];
                         lon[] = mid;
                     }
                     else
                         lon[] = mid;
                 }
                 else
                 {
                     mid = (lat[] + lat[])/;
                     if (latitude > mid)
                     {
                         ch |= Bits[bit];
                         lat[] = mid;
                     }
                     else
                         lat[] = mid;
                 }

                 even = !even;
                 if (bit < )
                     bit++;
                 else
                 {
                     geohash += Base32[ch];
                     bit = ;
                     ch = ;
                 }
             }
             return geohash;
         }

         /// <summary>
         /// 获取九个格子 顺序 本身 上、下、左、右、 左上、 右上、 左下、右下
         /// </summary>
         /// <param name="geohash"></param>
         /// <returns></returns>
         public static String[] getGeoHashExpand(String geohash)
         { 

         try {
             String geohashTop = CalculateAdjacent(geohash, Direction.Top);//上

             String geohashBottom = CalculateAdjacent(geohash, Direction.Bottom);//下

             String geohashLeft = CalculateAdjacent(geohash, Direction.Left);//左

             String geohashRight = CalculateAdjacent(geohash, Direction.Right);//右

             String geohashTopLeft = CalculateAdjacent(geohashLeft, Direction.Top);//左上

             String geohashTopRight = CalculateAdjacent(geohashRight, Direction.Top);//右上

             String geohashBottomLeft = CalculateAdjacent(geohashLeft, Direction.Bottom);//左下

             String geohashBottomRight = CalculateAdjacent(geohashRight, Direction.Bottom);//右下

             String[] expand = { geohash, geohashTop, geohashBottom, geohashLeft, geohashRight, geohashTopLeft, geohashTopRight,  geohashBottomLeft, geohashBottomRight};
             return expand;
         } catch (Exception e) {
             return null;
         }
         }

         ///// <summary>
         ///// test
         ///// </summary>
         ///// <param name="args"></param>
         //public  void main()
         //{
         //    double lat = 39.90403;
         //    double lon = 116.407526; //需要查询经纬度，目前指向的是BeiJing
         //    string hash = Geohash.Encode(lat, lon);
         //    int geohashLen = 6;
         //    /*获取中心点的geohash*/
         //    String geohash = hash.Substring(0, geohashLen);
         //    /*获取所有的矩形geohash， 一共是九个 ，包含中心点,打印顺序请参考参数*/
         //    String[] result = Geohash.getGeoHashExpand(geohash);
         //}
     }
 }

五、MySQL 中使用 GeoHash

在MySQL 5.7 以后，对GIS空间数据的更好的支持，加上虚拟列可以很方便的使用GeoHash。

选择存储 GeoHash 的列，设置为“虚拟列”，在“表达式”里填入“st_geohash(`point`,6)”，其中 point 是要编码的点字段

参考：

https://blog.csdn.net/youhongaa/article/details/78816700

https://www.cnblogs.com/lucoo/p/5085986.html