精华内容
下载资源
问答
  • public static void main(String[] args) { isInCircle(500.00,116.398585,39.914064,116.405693,39.90635)... * 判读一个点是否在圆内 返回boolean true存在 false不存在 , */ public static boolean isInCircle...
    public static void main(String[] args) {
        isInCircle(500.00,116.398585,39.914064,116.405693,39.90635);
    
    }
    
    
    /**
     *  判读一个点是否在圆内 返回boolean  true存在   false不存在  ,
     */
    public static boolean  isInCircle(double r,double centerX1,double centerY1,double x2,double y2) {
        double distance=Math.sqrt((y2-centerY1)*(y2-centerY1)+(x2-centerX1)*(x2-centerX1));
        if(distance>r){
            return false;
        }
        else
        {return true;}
    }
    展开全文
  • 比如我有一个 经纬度,我想知道这个点 是在圆内还是圆外 该如何断定呢?有没有什么公式?
  • 1.判断坐标 位置是否在多边形区域 /** * 判断当前位置是否在多边形区域 * @param orderLocation 当前点 * @param partitionLocation 区域顶点 * @return */ public static boolean isInPolygon(String X,...

    1.判断某坐标 位置是否在多边形区域内

    /**
     * 判断当前位置是否在多边形区域内
     * @param orderLocation 当前点
     * @param partitionLocation 区域顶点
     * @return
     */
    public static boolean isInPolygon(String X,String Y,String partitionLocation){
        double p_x =Double.parseDouble(X);
        double p_y =Double.parseDouble(Y);
        Point2D.Double point = new Point2D.Double(p_x, p_y);
    
        List<Point2D.Double> pointList= new ArrayList<Point2D.Double>();
        String[] strList = partitionLocation.split("\\],");
    
        for (String str : strList){
            String[] points = str.split(",");
            double polygonPoint_x=Double.parseDouble(points[0]);
            double polygonPoint_y=Double.parseDouble(points[1]);
            Point2D.Double polygonPoint = new Point2D.Double(polygonPoint_x,polygonPoint_y);
            pointList.add(polygonPoint);
        }
        return IsPtInPoly(point,pointList);
    }
    /**
     * 判断点是否在多边形内,如果点位于多边形的顶点或边上,也算做点在多边形内,直接返回true
     * @param point 检测点
     * @param pts   多边形的顶点
     * @return      点在多边形内返回true,否则返回false
     */
    public static boolean IsPtInPoly(Point2D.Double point, List<Point2D.Double> pts){
        int N = pts.size();
        boolean boundOrVertex = true; //如果点位于多边形的顶点或边上,也算做点在多边形内,直接返回true
        int intersectCount = 0;//cross points count of x
        double precision = 2e-10; //浮点类型计算时候与0比较时候的容差
        Point2D.Double p1, p2;//neighbour bound vertices
        Point2D.Double p = point; //当前点
    
        p1 = pts.get(0);//left vertex
        for(int i = 1; i <= N; ++i){//check all rays
            if(p.equals(p1)){
                return boundOrVertex;//p is an vertex
            }
            p2 = pts.get(i % N);
            if(p.x < Math.min(p1.x, p2.x) || p.x > Math.max(p1.x, p2.x)){
                p1 = p2;
                continue;
            }
            if(p.x > Math.min(p1.x, p2.x) && p.x < Math.max(p1.x, p2.x)){
                if(p.y <= Math.max(p1.y, p2.y)){
                    if(p1.x == p2.x && p.y >= Math.min(p1.y, p2.y)){
                        return boundOrVertex;
                    }
                    if(p1.y == p2.y){
                        if(p1.y == p.y){
                            return boundOrVertex;
                        }else{//before ray
                            ++intersectCount;
                        }
                    }else{
                        double xinters = (p.x - p1.x) * (p2.y - p1.y) / (p2.x - p1.x) + p1.y;
                        if(Math.abs(p.y - xinters) < precision){
                            return boundOrVertex;
                        }
    
                        if(p.y < xinters){
                            ++intersectCount;
                        }
                    }
                }
            }else{
                if(p.x == p2.x && p.y <= p2.y){
                    Point2D.Double p3 = pts.get((i+1) % N);
                    if(p.x >= Math.min(p1.x, p3.x) && p.x <= Math.max(p1.x, p3.x)){
                        ++intersectCount;
                    }else{
                        intersectCount += 2;
                    }
                }
            }
            p1 = p2;
        }
        if(intersectCount % 2 == 0){//偶数在多边形外
            return false;
        } else { //奇数在多边形内
            return true;
        }
    }
    
    1. 判断是否在多边形区域内

           /**
        * 判断是否在多边形区域内
        *
       * @param pointLon
        *            要判断的点的纵坐标 经
       * @param pointLat
      *            要判断的点的横坐标 纬
      *  @param lon
         *            区域各顶点的纵坐标数组
       	* @param lat
        *            区域各顶点的横坐标数组
         * @return
         */
         public static boolean isScope(double pointLon, double pointLat, double[] 	lon,
                                     double[] lat) {
       // 将要判断的横纵坐标组成一个点
       Point2D.Double point = new Point2D.Double(pointLon, pointLat);
       // 将区域各顶点的横纵坐标放到一个点集合里面
       List<Point2D.Double> pointList = new ArrayList<Point2D.Double>();
       double polygonPoint_x = 0.0, polygonPoint_y = 0.0;
       for (int i = 0; i < lon.length; i++) {
           polygonPoint_x = lon[i];
           polygonPoint_y = lat[i];
           Point2D.Double polygonPoint = new Point2D.Double(polygonPoint_x, polygonPoint_y);
           pointList.add(polygonPoint);
       }
           return check(point, pointList);
       }
       	 /**
        * 一个点是否在多边形内
        *
        * @param point
      *            要判断的点的横纵坐标
       * @param polygon
        *            组成的顶点坐标集合
       * @return
       */
       private static boolean check(Point2D.Double point, List<Point2D.Double> polygon) {
       java.awt.geom.GeneralPath peneralPath = new java.awt.geom.GeneralPath();
      
       Point2D.Double first = polygon.get(0);
       // 通过移动到指定坐标(以双精度指定),将一个点添加到路径中
       peneralPath.moveTo(first.x, first.y);
       polygon.remove(0);
       for (Point2D.Double d : polygon) {
           // 通过绘制一条从当前坐标到新指定坐标(以双精度指定)的直线,将一个点添加到路径中。
           peneralPath.lineTo(d.x, d.y);
       }
       // 将几何多边形封闭
       peneralPath.lineTo(first.x, first.y);
       peneralPath.closePath();
       // 测试指定的 Point2D 是否在 Shape 的边界内。
       return peneralPath.contains(point);
       }
      

      3.判断该地理坐标是否在最大范围区域内

       	 /**
       * 判断该地理坐标是否在最大范围区域内
        *
       * @param pointLon
       *            要判断的点的纵坐标
        * @param pointLat
        *            要判断的点的横坐标
         * @param lon
        *            指定区域的纵坐标组成的数组
       * @param lat
       *            指定区域的横坐标组成的数组
         * @return
       */
        private static boolean isInMaxArea(double pointLon, double pointLat, double[] lon,
                                      double[] lat) {
      
       // 获取区域横纵坐标最大值和最小值
       double temp = 0.0;
       for (int i = 0; i < lon.length; i++) {
           for (int j = 0; j < lon.length - i - 1; j++) {
               if (lon[j] > lon[j + 1]) {
                   temp = lon[j];
                   lon[j] = lon[j + 1];
                   lon[j + 1] = temp;
               }
           }
       }
       for (int i = 0; i < lat.length; i++) {
           for (int j = 0; j < lat.length - i - 1; j++) {
               if (lat[j] > lat[j + 1]) {
                   temp = lat[j];
                   lat[j] = lat[j + 1];
                   lat[j + 1] = temp;
               }
           }
       }
      
       // 如果在最值组成的区域外,那肯定不在重点区域内
       return (pointLon < lon[0] || pointLon > lon[lon.length - 1] || pointLat < lat[0]
               || pointLat > lat[lat.length - 1]);
       }
          /**
          * 判断坐标是否在重点区域内
           *
         * @param pointLon
      *            要判断的点的纵坐标
      * @param pointLat
        *            要判断的点的横坐标
        * @param lon
        *            指定区域的纵坐标组成的数组
        * @param lat
        *            指定区域的横坐标组成的数组
        * @return
        */
        private static boolean isInAccurateArea(double pointLon, double pointLat, double[] lon,
                                           double[] lat) {
       // 代表有几个点
       int vertexNum = lon.length;
       boolean result = false;
      
       for (int i = 0, j = vertexNum - 1; i < vertexNum; j = i++) {
           // 满足条件,与多边形相交一次,result布尔值取反一次,奇数个则在区域内
           if ((lon[i] > pointLon) != (lon[j] > pointLon)
                   && (pointLat < (lat[j] - lat[i]) * (pointLon - lon[i]) / (lon[j] - lon[i])
                   + lat[i])) {
               result = !result;
           }
       }
       return result;
        }
      
    展开全文
  • 多边形和圆分开写,首先简单的就是判断是否在圆里面,如何判断一个坐标是否在圆形区域,相信不用我说都知道,计算这个坐标点和圆心之间的距离,然后跟圆的半径进行比较,如果比半径大,就不在圆形区域,如果小于...

    怎么样判断一个坐标点在一个多边形区域内?包括规则多边形,不规则多边形,还有圆。。。

    1 判断一个坐标是否在圆形区域内?

    多边形和圆分开写,首先简单的就是判断是否在圆里面,如何判断一个坐标是否在圆形区域内,相信不用我说都知道,计算这个坐标点和圆心之间的距离,然后跟圆的半径进行比较,如果比半径大,就不在圆形区域内,如果小于等于圆的半径,则该坐标点在圆形区域内。

    数学上的计算公式是这样的:

    代码采用谷歌地图计算距离的方式,应该算是比较精确。

    private static double EARTH_RADIUS = 6378.137;
    
        private static double rad(double d) {
            return d * Math.PI / 180.0;
        }
    
        /**
         * 通过经纬度获取距离(单位:米)
         *
         * @param lat1
         * @param lng1
         * @param lat2
         * @param lng2
         * @return
         */
        public static double getDistance(double lat1, double lng1, double lat2,
                                         double lng2) {
            double radLat1 = rad(lat1);
            double radLat2 = rad(lat2);
            double a = radLat1 - radLat2;
            double b = rad(lng1) - rad(lng2);
            double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) +
                    Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
            s = s * EARTH_RADIUS;
            s = Math.round(s * 10000d) / 10000d;
            return s;
        }
    
        /**
         * 判断一个点是否在圆形区域内
         */
        public static boolean isInCircle(double lng1, double lat1, double lng2, double lat2, String radius) {
            return getDistance(lat1, lng1, lat2, lng2) > Double.parseDouble(radius);
        }

    (如果使用Math.hypot()方法,计算(经纬度距离时)结果会有偏差): 

        double x = (lon1 - lon2) * PI * R * Math.cos(((lat1 + lat2) / 2) * PI / 180) / 180;
        double y = (lat1 - lat2) * PI * R / 180;
        double distance = Math.hypot(x, y);

     

    2 判断一点是否在一个多边形区域内?

     

    这里用到JAVA的关于坐标系和几何图形的一个类GeneralPath,使用这个类,结合传入的各顶点参数,画一个几何图形,并通过它自身的contains方法,判断一点是否在这个几何图形内。

    也就是,通过JAVA已经封装好的方法,画一个几何多边形,判断一点是否在这个几何多边形里面。

    代码里面也有注释:

    /**
         * 判断是否在多边形区域内
         * 
         * @param pointLon
         *            要判断的点的纵坐标
         * @param pointLat
         *            要判断的点的横坐标
         * @param lon
         *            区域各顶点的纵坐标数组
         * @param lat
         *            区域各顶点的横坐标数组
         * @return
         */
        public static boolean isInPolygon(double pointLon, double pointLat, double[] lon,
                double[] lat) {
            // 将要判断的横纵坐标组成一个点
            Point2D.Double point = new Point2D.Double(pointLon, pointLat);
            // 将区域各顶点的横纵坐标放到一个点集合里面
            List<Point2D.Double> pointList = new ArrayList<Point2D.Double>();
            double polygonPoint_x = 0.0, polygonPoint_y = 0.0;
            for (int i = 0; i < lon.length; i++) {
                polygonPoint_x = lon[i];
                polygonPoint_y = lat[i];
                Point2D.Double polygonPoint = new Point2D.Double(polygonPoint_x, polygonPoint_y);
                pointList.add(polygonPoint);
            }
            return check(point, pointList);
        }
    
        /**
         * 一个点是否在多边形内
         * 
         * @param point
         *            要判断的点的横纵坐标
         * @param polygon
         *            组成的顶点坐标集合
         * @return
         */
        private static boolean check(Point2D.Double point, List<Point2D.Double> polygon) {
            java.awt.geom.GeneralPath peneralPath = new java.awt.geom.GeneralPath();
    
            Point2D.Double first = polygon.get(0);
            // 通过移动到指定坐标(以双精度指定),将一个点添加到路径中
            peneralPath.moveTo(first.x, first.y);
            polygon.remove(0);
            for (Point2D.Double d : polygon) {
                // 通过绘制一条从当前坐标到新指定坐标(以双精度指定)的直线,将一个点添加到路径中。
                peneralPath.lineTo(d.x, d.y);
            }
            // 将几何多边形封闭
            peneralPath.lineTo(first.x, first.y);
            peneralPath.closePath();
            // 测试指定的 Point2D 是否在 Shape 的边界内。
            return peneralPath.contains(point);
        }

    有没有感觉很方便很简单。。。

    以上是用到的各方法介绍。。。

    3 当然解决问题的方法肯定不止一种。这里还有一种比较简单的判断一点是否在一个多边形区域内的方法

    先将横纵坐标数组的横坐标最大最小值,纵坐标的最大最小值,求出来,需要判断的一点大于横纵坐标的最大值或者小于横纵坐标的最小值,也就是粗略的计算一下,如果这个条件不满足的话,就不用往下计算了,直接不在指定的区域里面。

    也就是:

    /**
         * 判断该地理坐标是否在最大范围区域内
         * 
         * @param pointLon
         *            要判断的点的纵坐标
         * @param pointLat
         *            要判断的点的横坐标
         * @param lon
         *            指定区域的纵坐标组成的数组
         * @param lat
         *            指定区域的横坐标组成的数组
         * @return
         */
        private static boolean isInMaxArea(double pointLon, double pointLat, double[] lon,
                double[] lat) {
    
            // 获取区域横纵坐标最大值和最小值
            double temp = 0.0;
            for (int i = 0; i < lon.length; i++) {
                for (int j = 0; j < lon.length - i - 1; j++) {
                    if (lon[j] > lon[j + 1]) {
                        temp = lon[j];
                        lon[j] = lon[j + 1];
                        lon[j + 1] = temp;
                    }
                }
            }
            for (int i = 0; i < lat.length; i++) {
                for (int j = 0; j < lat.length - i - 1; j++) {
                    if (lat[j] > lat[j + 1]) {
                        temp = lat[j];
                        lat[j] = lat[j + 1];
                        lat[j + 1] = temp;
                    }
                }
            }
    
            // 如果在最值组成的区域外,那肯定不在重点区域内
            return (pointLon < lon[0] || pointLon > lon[lon.length - 1] || pointLat < lat[0]
                    || pointLat > lat[lat.length - 1]);
        }

    如果通过了上面的判断,可以进行接下来的算法判断了

    用到了两点间的斜率公式

    这个方法就是,通过一点,画一条线,这条线与多边形相交,如果相交点数位奇数,就在区域内,如果为偶数,就不在区域内

    代码:

    /**
         * 判断坐标是否在重点区域内
         * 
         * @param pointLon
         *            要判断的点的纵坐标
         * @param pointLat
         *            要判断的点的横坐标
         * @param lon
         *            指定区域的纵坐标组成的数组
         * @param lat
         *            指定区域的横坐标组成的数组
         * @return
         */
        private static boolean isInAccurateArea(double pointLon, double pointLat, double[] lon,
                double[] lat) {
            // 代表有几个点
            int vertexNum = lon.length;
            boolean result = false;
            
            for (int i = 0, j = vertexNum - 1; i < vertexNum; j = i++) {
                // 满足条件,与多边形相交一次,result布尔值取反一次,奇数个则在区域内
                if ((lon[i] > pointLon) != (lon[j] > pointLon)
                        && (pointLat < (lat[j] - lat[i]) * (pointLon - lon[i]) / (lon[j] - lon[i])
                                + lat[i])) {
                    result = !result;
                }
            }
            return result;
        }

    好了,就这些了,哪里不对欢迎指教。。。有问题也可以探讨。

    展开全文
  • lat1 ,lng1 ,raduis分别为的纬度,经度和半径 lat ,lng为点的纬度,经度 double R = 6378137.0; double dLat = (lat1 - lat) * Math.PI / 180; double dLng = (lng1 - lng) * Math.PI / 180; double a = Math...

    lat1 ,lng1 ,raduis分别为圆的纬度,经度和半径
    lat ,lng为点的纬度,经度

    double R = 6378137.0;
    double dLat = (lat1 - lat) * Math.PI / 180;
    double dLng = (lng1 - lng) * Math.PI / 180;
            
    double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(lat * Math.PI / 180) * Math.cos(lat1 * Math.PI / 180) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    double d = R * c;
    double dis = Math.round(d);
           
    if (dis <= raduis){
        //点在圆内
    }else {
        //点不在圆内
    }
    
    展开全文
  • 程序先请求输入圆的半径,再请求输入点的x坐标和y坐标,然后给出判断是否在圆内并打印输出结果。假定圆心的位置在坐标原点(0,0),在圆上的点也被认为是在圆内。点到圆心的距离计算可以参考之前的...
  • 简单:满足条件: 长方形满足...有了这个定义,计算点是否在胶囊体内就会简单很多:首先把P点投影到线段 AB上,如果投影P'超出了 AB 那么限制在 AB之间然后计算P点到其投影点P'的距离,如果 < r 则在胶囊体内比...
  • /** * 判断坐标点位置状态 */ public class GisPointUtil { private static double EARTH_RADIUS = 6378137d; private static double rad(double d) { return d * Math.PI / 180.0; } /** * 通过经纬度获取...
  • /** 判断一个点是不是在圆内***/public class Demo {public static void main(String[] args) {//提示用户定义圆形和半径Scanner sc = new Scanner(System.in);//请输入圆形坐标System.out.println("请输入圆心坐标...
  • 判断是否在圆内(C++编程思想)

    千次阅读 2019-01-12 18:08:20
    点要做的工作是:定义两个变量(点的坐标 :x 和y),然后点上要做的事情就是计算我这个点和圆心这个点之间的距离(注意:比较点是否在圆内这个工作点可以做,圆也同样可以做) 圆要做的工作是:定义圆的半径,定义...
  • //判断一个点是否在以(0,0)为圆心,半径不定的圆内 import java.util.Scanner; import javax.swing.JOptionPane; public class Study4 { public static void main(String[] args) { int x = 0;//圆心x...
  • 这几个坐标系的介绍放在下一节,而这些椭球体的转换将第三部分介绍(主要就是数学中,空间直角坐标系旋转的问题)。 1.3 我国常见GCS 借助以下4个常见坐标系及椭球体,就可以推及到世界各地不同的GCS及椭球体,...
  • 点到圆心的距离公式也就是两点间距离... //设置一个点的坐标 void setXY(int x, int y){ m_x = x; m_y = y; } int getX(){ return m_x; } int getY(){ return m_y; } private: int m
  • 两个经纬度坐标的距离 的半径 是否是多边形 import java.awt.geom.Point2D; import java.util.ArrayList; import java.util.List; public class regionUtil { private static double EARTH_RADIUS = 6378137; //...
  • * 判断一个点是不是在圆内 * * */ public class Demo { public static void main(String[] args) { //提示用户定义圆形和半径 Scanner sc = new Scanner(System.in); //请输入圆形坐标 System.out....
  • https://blog.csdn.net/deepak192/article/details/79402694/
  • 其实所占的区域还是正方形区域,只是显示内容为圆形,当我们给ImageView设置触摸事件时,没有显示区域也会相应点击事件,而我们可以通过计算当前点击的位置来判断ImageView是否相应触摸事件。 效果如图所示: 如上...
  • 直接上代码,简单明了  /** * 返回是否在打卡范围内 ... *var0表示圆心的坐标,var1代表圆心的半径,var2代表要判断的点是否在圆内 *isCircleContainsPoint(LatLng var0, int var1, LatLng var2); ...
  • 大致题意: 按照顺时针或逆时针方向...再给定一个圆形(圆心坐标和半径),判断这个圆是否完全n变形内部。   解题思路: 题意已经很直白了。。就是那个思路。。。 注意输入完顶点集后,要封闭多边形,方便后面
  • **【题目】**判断二维空间中的点,是否在圆内(输出:该点在圆内、该点在圆上、该点在圆外)。 允许的误差为1e-6. **输入格式要求:"%f,%f" “%f” “%f,%f” 提示信息:“请输入圆的圆心坐标:” “请输入圆的半径...
  • 在平面上,如果已知\(\triangle P_0 P_1 P_2\)的三个顶点坐标\(P_0(x_0, y_0),\space P_1(x_1,y_1),\space P_2(x_2,y_2)\)和另一点\(P\)的坐标\((x,y)\),要判断点P是否在\(\triangle P_0 P_1 P_2\)。 这里给出两...
  • * 判断一个坐标是否在圆内 * 思路:判断此点的经纬度到圆心的距离 然后和半径做比较 * 如果此点刚好在圆上 则返回true * @param $point ['lng'=>'','lat'=>''] array指定点的坐标 * @param $circle array...
  • 判断是否在圆内或矩形内部”这样的思路编排的。一,首先是定位。先定义6个百度坐标点,然后在坐标点上创建对应的marker,再通过map.addOverlay(marker)方法将6个marker定位在百度地图中,并利用marker....
  • 在学习过程中遇到了需要判断坐标是否在区域的需求,所以发现了这篇文章,特地转载过来
  • /usr/bin/env python# -*- coding: utf-8 -*-'''@filename : 平面坐标内矩形与圆是否相交@usage :@authors : U{peterguo}@copyright: tencent@date : 2012.08.21@version : 1.0.0.0Modified History:2012.08.21 ...
  • 点在多边形常用的算法就是使用... * 判断一个点是否在多边形内部 * @param points 多边形坐标集合 * @param testPoint 测试点坐标 * 返回true为真,false为假 * */ function insidePolygon(points, te...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 232
精华内容 92
关键字:

判断坐标是否在圆内