JAVA实现将GeoHash转化为相应的经纬度坐标

转载请注明出处：http://blog.csdn.net/xiaojimanman/article/details/50568428

http://www.llwjy.com/blogdetail/fc484929cff1efac413ec2524680c5d7.html

个人博客站已经上线了。网址 www.llwjy.com ~欢迎各位吐槽~

-------------------------------------------------------------------------------------------------

      在博客JAVA实现空间索引编码（GeoHash）中介绍了什么是GeoHash以及怎样将坐标转化为GeoHash。这篇博客就介绍下，怎样将GeoHash转化为相应区域中心点的坐标。


Base32的相应关系

      在上次实现中介绍了数值和base32的相应关系。用数组保存这样的相应关系；如今我们须要找到一个数据结构，能够高速的查找base32字符和数值相应关系。这样我们能够用map来保存这样的关系。

private static final char[] CHARS = {'0', '1', '2', '3', '4', '5', '6', '7', 
			'8', '9', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 
			'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
private static HashMap<Character, Integer> CHARSMAP;

static {
	CHARSMAP = new HashMap<Character, Integer>();
	for (int i = 0; i < CHARS.length; i++) {
		CHARSMAP.put(CHARS[i], i);
	}
}


将数值转化为二进制字符串

      当我们获取每一个字符相应的数字之后，须要将数字转化为二进制字符串。我们能够直接调用Integer.toBinaryString方法来实现，因为我们要保证转换之后的二进制要是5位，对于小于16的。我们须要在前部补0。为了实现这个功能，我们对数字统一加上32，在转化成二进制字符串之后。再把第一位的1移除就可以。

private String getBase32BinaryString(int i) {
	if (i < 0 || i > 31) {
		return null;
	}
	String str = Integer.toBinaryString(i + 32);
	return str.substring(1);
}

将GeoHash转化为二进制字符串

      上一步是将数值转化为五位的二进制字符串，以下我们就介绍下怎样将GeoHash字符串转化为相应的二进制字符串。通过上面介绍的Base32字符和数字的相应关系。我们能够知道每一个字符相应的数字。然后将这个数字转化为相应的五位二进制字符串，我们再把这些字符串拼接起来。就构成了一个完整的二进制字符串。

private String getGeoHashBinaryString(String geoHash) {
	if (geoHash == null || "".equals(geoHash)) {
		return null;
	}
	StringBuffer sb = new StringBuffer();
	for (int i = 0; i < geoHash.length(); i++) {
		char c = geoHash.charAt(i);
		if (CHARSMAP.containsKey(c)) {
			String cStr = getBase32BinaryString(CHARSMAP.get(c));
			if (cStr != null) {
				sb.append(cStr);
			}
		}
	}
	return sb.toString();
}


将GeoHash二进制字符串拆分成经纬度二进制字符串

      在上次博客中介绍了GeoHash二进制字符串是由经纬度的二进制字符串整合而成的，当中奇数为是纬度，偶数为是经度，从而我们仅仅须要再把GeoHash字符串拆开就可以。

StringBuffer lat = new StringBuffer();
StringBuffer lng = new StringBuffer();
for (int i = 0; i < geoHashBinaryStr.length(); i++) {
	if (i % 2 != 0) {
		lat.append(geoHashBinaryStr.charAt(i));
	} else {
		lng.append(geoHashBinaryStr.charAt(i));
	}
}


将经纬度二进制转化为中点相应的经纬度

      上次博客介绍怎样将一个经纬度转化为相应的二进制，就是看经纬度在相应的那个区域，这里我们也来对其做你运算，假设二进制字符串第一位为1，则说明经纬度在大的区域，假设为0。则在小的区域，然后我们再对所在的区域进行切割，再来推断二进制字符串的第二位是1还是0，以此类推，最后返回最后一个区域中点的值。

private double getGeoHashMid(String binaryStr, double min, double max) {
	if (binaryStr == null || binaryStr.length() < 1) {
		return (min + max) / 2.0;
	}
	if (binaryStr.charAt(0) == '1') {
		return getGeoHashMid(binaryStr.substring(1), (min + max) / 2.0, max);
	} else {
		return getGeoHashMid(binaryStr.substring(1), min, (min + max) / 2.0);
	}
}


执行结果检验

img


完整代码

      对于DistanceUtil 和 LocationBean差点儿没有做改变，这里就不再介绍他们的源代码。

 /**  
 *@Description: GeoHash实现经纬度的转化
 */ 
package com.lulei.geo;  

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

import com.lulei.geo.bean.LocationBean;
import com.lulei.util.JsonUtil;
  
public class GeoHash {
	private LocationBean location;
	/**
	 * 1 2500km;2 630km;3 78km;4 30km
	 * 5 2.4km; 6 610m; 7 76m; 8 19m
	 */
	private int hashLength = 8; //经纬度转化为geohash长度
	private int latLength = 20; //纬度转化为二进制长度
	private int lngLength = 20; //经度转化为二进制长度
	
	private double minLat;//每格纬度的单位大小
	private double minLng;//每一个经度的单位大小
	private static final char[] CHARS = {'0', '1', '2', '3', '4', '5', '6', '7', 
				'8', '9', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 
				'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
	private static HashMap<Character, Integer> CHARSMAP;
	
	static {
		CHARSMAP = new HashMap<Character, Integer>();
		for (int i = 0; i < CHARS.length; i++) {
			CHARSMAP.put(CHARS[i], i);
		}
	}
	
	public GeoHash(double lat, double lng) {
		location = new LocationBean(lat, lng);
		setMinLatLng();
	}
	
	public int gethashLength() {
		return hashLength;
	}
	
	/**
	 * @Author:lulei  
	 * @Description: 设置经纬度的最小单位
	 */
	private void setMinLatLng() {
		minLat = LocationBean.MAXLAT - LocationBean.MINLAT;
		for (int i = 0; i < latLength; i++) {
			minLat /= 2.0;
		}
		minLng = LocationBean.MAXLNG - LocationBean.MINLNG;
		for (int i = 0; i < lngLength; i++) {
			minLng /= 2.0;
		}
	}
	
	/**
	 * @return
	 * @Author:lulei  
	 * @Description: 求所在坐标点及周围点组成的九个
	 */
	public List<String> getGeoHashBase32For9() {
		double leftLat = location.getLat() - minLat;
		double rightLat = location.getLat() + minLat;
		double upLng = location.getLng() - minLng;
		double downLng = location.getLng() + minLng;
		List<String> base32For9 = new ArrayList<String>();
		//左側从上到下 3个
		String leftUp = getGeoHashBase32(leftLat, upLng);
		if (!(leftUp == null || "".equals(leftUp))) {
			base32For9.add(leftUp);
		}
		String leftMid = getGeoHashBase32(leftLat, location.getLng());
		if (!(leftMid == null || "".equals(leftMid))) {
			base32For9.add(leftMid);
		}
		String leftDown = getGeoHashBase32(leftLat, downLng);
		if (!(leftDown == null || "".equals(leftDown))) {
			base32For9.add(leftDown);
		}
		//中间从上到下 3个
		String midUp = getGeoHashBase32(location.getLat(), upLng);
		if (!(midUp == null || "".equals(midUp))) {
			base32For9.add(midUp);
		}
		String midMid = getGeoHashBase32(location.getLat(), location.getLng());
		if (!(midMid == null || "".equals(midMid))) {
			base32For9.add(midMid);
		}
		String midDown = getGeoHashBase32(location.getLat(), downLng);
		if (!(midDown == null || "".equals(midDown))) {
			base32For9.add(midDown);
		}
		//右側从上到下 3个
		String rightUp = getGeoHashBase32(rightLat, upLng);
		if (!(rightUp == null || "".equals(rightUp))) {
			base32For9.add(rightUp);
		}
		String rightMid = getGeoHashBase32(rightLat, location.getLng());
		if (!(rightMid == null || "".equals(rightMid))) {
			base32For9.add(rightMid);
		}
		String rightDown = getGeoHashBase32(rightLat, downLng);
		if (!(rightDown == null || "".equals(rightDown))) {
			base32For9.add(rightDown);
		}
		return base32For9;
	}

	/**
	 * @param length
	 * @return
	 * @Author:lulei  
	 * @Description: 设置经纬度转化为geohash长度
	 */
	public boolean sethashLength(int length) {
		if (length < 1) {
			return false;
		}
		hashLength = length;
		latLength = (length * 5) / 2;
		if (length % 2 == 0) {
			lngLength = latLength;
		} else {
			lngLength = latLength + 1;
		}
		setMinLatLng();
		return true;
	}
	
	/**
	 * @return
	 * @Author:lulei  
	 * @Description: 获取经纬度的base32字符串
	 */
	public String getGeoHashBase32() {
		return getGeoHashBase32(location.getLat(), location.getLng());
	}
	
	/**
	 * @param lat
	 * @param lng
	 * @return
	 * @Author:lulei  
	 * @Description: 获取经纬度的base32字符串
	 */
	private String getGeoHashBase32(double lat, double lng) {
		boolean[] bools = getGeoBinary(lat, lng);
		if (bools == null) {
			return null;
		}
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < bools.length; i = i + 5) {
			boolean[] base32 = new boolean[5];
			for (int j = 0; j < 5; j++) {
				base32[j] = bools[i + j];
			}
			char cha = getBase32Char(base32);
			if (' ' == cha) {
				return null;
			}
			sb.append(cha);
		}
		return sb.toString();
	}
	
	/**
	 * @param base32
	 * @return
	 * @Author:lulei  
	 * @Description: 将五位二进制转化为base32
	 */
	private char getBase32Char(boolean[] base32) {
		if (base32 == null || base32.length != 5) {
			return ' ';
		}
		int num = 0;
		for (boolean bool : base32) {
			num <<= 1;
			if (bool) {
				num += 1;
			}
		}
		return CHARS[num % CHARS.length];
	}
	
	/**
	 * @param i
	 * @return
	 * @Author:lulei  
	 * @Description: 将数字转化为二进制字符串
	 */
	private String getBase32BinaryString(int i) {
		if (i < 0 || i > 31) {
			return null;
		}
		String str = Integer.toBinaryString(i + 32);
		return str.substring(1);
	}
	
	/**
	 * @param geoHash
	 * @return
	 * @Author:lulei  
	 * @Description: 将geoHash转化为二进制字符串
	 */
	private String getGeoHashBinaryString(String geoHash) {
		if (geoHash == null || "".equals(geoHash)) {
			return null;
		}
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < geoHash.length(); i++) {
			char c = geoHash.charAt(i);
			if (CHARSMAP.containsKey(c)) {
				String cStr = getBase32BinaryString(CHARSMAP.get(c));
				if (cStr != null) {
					sb.append(cStr);
				}
			}
		}
		return sb.toString();
	}
	
	/**
	 * @param geoHash
	 * @return
	 * @Author:lulei  
	 * @Description: 返回geoHash 相应的坐标
	 */
	public LocationBean getLocation(String geoHash) {
		String geoHashBinaryStr = getGeoHashBinaryString(geoHash);
		if (geoHashBinaryStr == null) {
			return null;
		}
		StringBuffer lat = new StringBuffer();
		StringBuffer lng = new StringBuffer();
		for (int i = 0; i < geoHashBinaryStr.length(); i++) {
			if (i % 2 != 0) {
				lat.append(geoHashBinaryStr.charAt(i));
			} else {
				lng.append(geoHashBinaryStr.charAt(i));
			}
		}
		double latValue = getGeoHashMid(lat.toString(), LocationBean.MINLAT, LocationBean.MAXLAT);
		double lngValue = getGeoHashMid(lng.toString(), LocationBean.MINLNG, LocationBean.MAXLNG);
		LocationBean location = new LocationBean(latValue, lngValue);
		location.setGeoHash(geoHash);
		return location;
	}
	
	/**
	 * @param binaryStr
	 * @param min
	 * @param max
	 * @return
	 * @Author:lulei  
	 * @Description: 返回二进制相应的中间值
	 */
	private double getGeoHashMid(String binaryStr, double min, double max) {
		if (binaryStr == null || binaryStr.length() < 1) {
			return (min + max) / 2.0;
		}
		if (binaryStr.charAt(0) == '1') {
			return getGeoHashMid(binaryStr.substring(1), (min + max) / 2.0, max);
		} else {
			return getGeoHashMid(binaryStr.substring(1), min, (min + max) / 2.0);
		}
	}
	
	/**
	 * @param lat
	 * @param lng
	 * @return
	 * @Author:lulei  
	 * @Description: 获取坐标的geo二进制字符串
	 */
	private boolean[] getGeoBinary(double lat, double lng) {
		boolean[] latArray = getHashArray(lat, LocationBean.MINLAT, LocationBean.MAXLAT, latLength);
		boolean[] lngArray = getHashArray(lng, LocationBean.MINLNG, LocationBean.MAXLNG, lngLength);
		return merge(latArray, lngArray);
	}
	
	/**
	 * @param latArray
	 * @param lngArray
	 * @return
	 * @Author:lulei  
	 * @Description: 合并经纬度二进制
	 */
	private boolean[] merge(boolean[] latArray, boolean[] lngArray) {
		if (latArray == null || lngArray == null) {
			return null;
		}
		boolean[] result = new boolean[lngArray.length + latArray.length];
		Arrays.fill(result, false);
		for (int i = 0; i < lngArray.length; i++) {
			result[2 * i] = lngArray[i];
		}
		for (int i = 0; i < latArray.length; i++) {
			result[2 * i + 1] = latArray[i];
		}
		return result;
	}
	
	/**
	 * @param value
	 * @param min
	 * @param max
	 * @return
	 * @Author:lulei  
	 * @Description: 将数字转化为geohash二进制字符串
	 */
	private boolean[] getHashArray(double value, double min, double max, int length) {
		if (value < min || value > max) {
			return null;
		}
		if (length < 1) {
			return null;
		}
		boolean[] result = new boolean[length];
		for (int i = 0; i < length; i++) {
			double mid = (min + max) / 2.0;
			if (value > mid) {
				result[i] = true;
				min = mid;
			} else {
				result[i] = false;
				max = mid;
			}
		}
		return result;
	}
	

	public static void main(String[] args) {
		// TODO Auto-generated method stub 
		GeoHash g = new GeoHash(40.221227, 116.24875);
		String geoHash = g.getGeoHashBase32();
		System.out.println(geoHash);
		LocationBean bean = g.getLocation(geoHash);
		System.out.println(JsonUtil.parseJson(bean));
		System.out.println(new GeoHash(bean.getLat(), bean.getLng()).getGeoHashBase32());
		System.out.println(DistanceUtil.getDistance(bean.getLat(), bean.getLng(), bean.getLat() - g.minLat, bean.getLng() - g.minLng));
	}

}

-------------------------------------------------------------------------------------------------
小福利
-------------------------------------------------------------------------------------------------
      个人在极客学院上《Lucene案例开发》课程已经上线了，欢迎大家吐槽~

第一课：Lucene概述

第二课：Lucene 经常使用功能介绍

第三课：网络爬虫

第四课：数据库连接池

第五课：小说站点的採集

第六课：小说站点数据库操作

第七课：小说站点分布式爬虫的实现

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/cxchanpin/p/7079163.html