根据经纬度判断一个点是否在一个矩形范围内

在实际应用中经常会遇到这样一种需求，由最大最小的经纬度给出一个矩形范围，然后判断一个点是否在这个范围内部，由于经纬度有负有正，而且经度跨越正负180度后变号并且反向增减，一两步计算不出来，下面给出一种计算方案，其中在经度的处理上，只有劣弧计入范围内部，也就是只有小于半球面的那部分算作区域内部，如果想算超过180的大面积，请求反操作。

下面是主要方法：

/**
     *
     * @param latitue 待测点的纬度
     * @param longitude 待测点的经度
     * @param areaLatitude1 纬度范围限制1
     * @param areaLatitude2 纬度范围限制2
     * @param areaLongitude1 经度限制范围1
     * @param areaLongitude2 经度范围限制2
     * @return
     */
    public static boolean isInArea(double latitue,double longitude,double areaLatitude1,double areaLatitude2,double areaLongitude1,double areaLongitude2){
        if(isInRange(latitue, areaLatitude1, areaLatitude2)){//如果在纬度的范围内
            if(areaLongitude1*areaLongitude2>0){//如果都在东半球或者都在西半球
                if(isInRange(longitude, areaLongitude1, areaLongitude2)){
                    return true;
                }else {
                    return false;
                }
            }else {//如果一个在东半球，一个在西半球
                if(Math.abs(areaLongitude1)+Math.abs(areaLongitude2)<180){//如果跨越0度经线在半圆的范围内
                    if(isInRange(longitude, areaLongitude1, areaLongitude2)){
                        return true;
                    }else {
                        return false;
                    }
                }else{//如果跨越180度经线在半圆范围内
                    double left = Math.max(areaLongitude1, areaLongitude2);//东半球的经度范围left-180
                    double right = Math.min(areaLongitude1, areaLongitude2);//西半球的经度范围right-（-180）
                    if(isInRange(longitude, left, 180)||isInRange(longitude, 0, right)){
                        return true;
                    }else {
                        return false;
                    }
                }
            }
        }else{
            return false;
        }
    }
    
    public static boolean isInRange(double point, double left,double right){
            if(point>=Math.min(left, right)&&point<=Math.max(left, right)){
                return true;
            }else {
                return false;
            }
        
    }

调用方法

</pre><pre name="code" class="java">public static void main(String[] args) {
// TODO Auto-generated method stub
double myLatitude = 36.0;//待测点的纬度
double myLongitude = 120;//待测点的经度
//下面是经纬度的范围
double minLatitude = -60;
double maxLatitude = 40.0;
double minLongitude = 140;
double maxLongitude = 100;

 if(isInArea(myLatitude, myLongitude, minLatitude, maxLatitude, minLongitude, maxLongitude)){
System.out.println("在范围内");
}else{
System.out.println("不在范围内");
}

}

如果使用地图sdk的话会有更简单的方法

以谷歌地图为例，首先生成一个限制对象，然后用这个限制对象测点就行了，如下

final LatLngBounds boundary = new LatLngBounds(new LatLng(minlatitude, minlongitude), new LatLng(maxlatitude, maxlongitude));
boundary.including(new LatLng(36.0,120.0));

下面给出一个很实用的方法：给出一个经纬度点，然后给出一个距离和方向，求出这个点根据这个距离和方向算出的另一个点

//地理常量
private final static double EARTH_RADIUS = 6378138.0;
private final static double PI = 3.14159265;
private final static double Rc = 6378137;  // 赤道半径
private final static double Rj = 6356725;  // 极半径
// The shared path to all app expansion files
private final static String EXP_PATH = "/Android/obb/";
static double DEF_PI = 3.14159265359; // PI
static double DEF_2PI = 6.28318530712; // 2*PI
static double DEF_PI180 = 0.01745329252; // PI/180.0
static double DEF_R = 6370693.5; // radius of earth

public static String[] getGPSLocation(double latitude, double longitude, double distance, double angle) {
String[] result = {"0.0", "0.0"};
double m_Latitude;
double m_RadLo, m_RadLa;
double Ec;
double Ed;

m_Latitude = latitude;
m_RadLo = longitude * PI / 180.0;
m_RadLa = latitude * PI / 180.0;
Ec = Rj + (Rc - Rj) * (90.0 - m_Latitude) / 90.0;
Ed = Ec * Math.cos(m_RadLa);

double dx = distance * 1000 * Math.sin(angle * PI / 180.0);
double dy = distance * 1000 * Math.cos(angle * PI / 180.0);

double BJD = (dx / Ed + m_RadLo) * 180.0 / PI;
double BWD = (dy / Ec + m_RadLa) * 180.0 / PI;

result[0] = BWD + "";
result[1] = BJD + "";
return result;
}

下面是再提供几个比较实用的方法：根据经纬度计算两点间距离

public static double getGPSDistance(double lat_a, double lng_a, double lat_b, double lng_b) {
final double M_PI = 3.14159265358979323846264338327950288;
final double dd = M_PI / 180.0;

double lon2 = lng_b;
double lat2 = lat_b;

double x1 = lat_a * dd, x2 = lat2 * dd;
double y1 = lng_a * dd, y2 = lon2 * dd;
double distance = (2 * EARTH_RADIUS * Math.asin(Math.sqrt(2 - 2 * Math.cos(x1)
* Math.cos(x2) * Math.cos(y1 - y2) - 2 * Math.sin(x1)
* Math.sin(x2)) / 2));

return distance;
}

//适用于近距离
public static double GetShortDistance(double lon1, double lat1, double lon2, double lat2) {
double ew1, ns1, ew2, ns2;
double dx, dy, dew;
double distance;
// 角度转换为弧度
ew1 = lon1 * DEF_PI180;
ns1 = lat1 * DEF_PI180;
ew2 = lon2 * DEF_PI180;
ns2 = lat2 * DEF_PI180;
// 经度差
dew = ew1 - ew2;
// 若跨东经和西经180 度，进行调整
if (dew > DEF_PI)
dew = DEF_2PI - dew;
else if (dew < -DEF_PI)
dew = DEF_2PI + dew;
dx = DEF_R * Math.cos(ns1) * dew; // 东西方向长度(在纬度圈上的投影长度)
dy = DEF_R * (ns1 - ns2); // 南北方向长度(在经度圈上的投影长度)
// 勾股定理求斜边长
distance = Math.sqrt(dx * dx + dy * dy);
return distance;
}

//适用于远距离
public static double GetLongDistance(double lon1, double lat1, double lon2, double lat2) {
double ew1, ns1, ew2, ns2;
double distance;
// 角度转换为弧度
ew1 = lon1 * DEF_PI180;
ns1 = lat1 * DEF_PI180;
ew2 = lon2 * DEF_PI180;
ns2 = lat2 * DEF_PI180;
// 求大圆劣弧与球心所夹的角(弧度)
distance = Math.sin(ns1) * Math.sin(ns2) + Math.cos(ns1) * Math.cos(ns2) * Math.cos(ew1 - ew2);
// 调整到[-1..1]范围内，避免溢出
if (distance > 1.0)
distance = 1.0;
else if (distance < -1.0)
distance = -1.0;
// 求大圆劣弧长度
distance = DEF_R * Math.acos(distance);
return distance;
}

/**
* Unit:M
*/
public static String getGPSDistance(String lat_a, String lng_a, String lat_b, String lng_b) {
double d_lat_a = 0.0;
try {
d_lat_a = Double.parseDouble(lat_a);
} catch (Exception ex) {
ex.printStackTrace();
}

double d_lng_a = 0.0;
try {
d_lng_a = Double.parseDouble(lng_a);
} catch (Exception ex) {
ex.printStackTrace();
}

double d_lat_b = 0.0;
try {
d_lat_b = Double.parseDouble(lat_b);
} catch (Exception ex) {
ex.printStackTrace();
}

double d_lng_b = 0.0;
try {
d_lng_b = Double.parseDouble(lng_b);
} catch (Exception ex) {
ex.printStackTrace();
}

return getGPSDistance(d_lat_a, d_lng_a, d_lat_b, d_lng_b) + "";
}