1. 程式人生 > >Geohash 基本知識及 .NET 下計算相鄰8個區域編碼

Geohash 基本知識及 .NET 下計算相鄰8個區域編碼

fine 一個 detail bits 獲取 geohash 技術 esp stat

目錄

  • 一、簡介
  • 二、計算方法
  • 三、GeoHash的精度
  • 四、查找相鄰8個區域的Geohash編碼(.NET)

最近項目中需要搜索周邊的 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 = 0,
            Right = 1,
            Bottom = 2,
            Left = 3 
        }

        #endregion

        private const string Base32 = "0123456789bcdefghjkmnpqrstuvwxyz";
        private static readonly int[] Bits = new[] {16, 8, 4, 2, 1};

        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 - 1];
            int type = hash.Length%2;
            var dir = (int) direction;
            string nHash = hash.Substring(0, hash.Length - 1);

            if (Borders[type][dir].IndexOf(lastChr) != -1)
            {
                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) != 0)
            {
                interval[0] = (interval[0] + interval[1])/2;
            }
            else
            {
                interval[1] = (interval[0] + interval[1])/2;
            }
        }

        /// <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 = 0; j < 5; j++)
                {
                    int mask = Bits[j];
                    if (even)
                    {
                        RefineInterval(ref lon, cd, mask);
                    }
                    else
                    {
                        RefineInterval(ref lat, cd, mask);
                    }
                    even = !even;
                }
            }

            return new[] {(lat[0] + lat[1])/2, (lon[0] + lon[1])/2};
        }
        /// <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 = 12)
        {
            bool even = true;
            int bit = 0;
            int ch = 0;
            string geohash = "";

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

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

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

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

                even = !even;
                if (bit < 4)
                    bit++;
                else
                {
                    geohash += Base32[ch];
                    bit = 0;
                    ch = 0;
                }
            }
            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);
        //}
    }
}

參考:

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

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

Geohash 基本知識及 .NET 下計算相鄰8個區域編碼