• Java中使用JTS对空间几何计算(读取WKT、距离、点在面内、长度、面积、相交等)

    场景

    基于GIS相关的集成系统，需要对空间数据做一些判断处理。比如读取WKT数据、点到点、点到线、点到面的距离，

    线的长度、面的面积、点是否在面内等处理。

    JTS

    (Java Topology Suite) Java拓扑套件，是Java的处理地理数据的API。

    github地址：

    GitHub - locationtech/jts: The JTS Topology Suite is a Java library for creating and manipulating vector geometry.

    API文档地址：

    org.locationtech.jts:jts-core 1.19.0 API

    Maven中央仓库地址：

     https://mvnrepository.com/artifact/org.locationtech.jts/jts-core

    特点

    实现了OGC关于简单要素SQL查询规范定义的空间数据模型
    一个完整的、一致的、基本的二维空间算法的实现，包括二元运算（例如touch和overlap）和空间分析方法（例如intersection和buffer）
    一个显示的精确模型，用算法优雅的解决导致dimensional collapse（尺度坍塌–专业名词不知道对不对，暂时这样译）的情况。
    健壮的实现了关键计算几何操作
    提供著名文本格式的I/O接口
    JTS是完全100%由Java写的

    JTS支持一套完整的二元谓词操作。二元谓词方法将两个几何图形作为参数，
    返回一个布尔值来表示几何图形是否有指定的空间关系。它支持的空间关系有：
    相等（equals）、分离（disjoint）、相交（intersect）、相接（touches）、
    交叉（crosses）、包含于（within）、包含（contains）、覆盖/覆盖于（overlaps）。
    同时，也支持一般的关系（relate）操作符。
    relate可以被用来确定维度扩展的九交模型（DE-9IM）,它可以完全的描述两个几何图形的关系。

    空间数据模型

    JTS提供了以下空间数据模型

     

    图形可视化WKT数据

    在jts的bin下的testbuilder.bat，双击运行

     

    即可运行WKT数据可视化界面

     

    可以在页面上绘制图形并下方生成wkt数据，以及输入wkt数据，点击右边按钮，图形化显示。

    注：

    博客：
    霸道流氓气质的博客_CSDN博客-C#,架构之路,SpringBoot领域博主
    关注公众号
    霸道的程序猿
    获取编程相关电子书、教程推送与免费下载。

    实现

    1、项目中引入jts的依赖

    1. ​
    2.         
    3.         <dependency>
    4.             <groupId>org.locationtech.jtsgroupId>
    5.             <artifactId>jts-coreartifactId>
    6.             <version>1.18.2version>
    7.         dependency>
    8.  
    9. ​

    2、从WKT字符串中读取几何图形，读取点、线、面

    1.         //read a geometry from a WKT string (using the default geometry factory)
    2.         //从WKT字符串读取几何图形
    3.         Geometry g1 = null;
    4.         try {
    5.             //读取线
    6.             //g1 = new WKTReader().read("LINESTRING (0 0, 10 10, 20 20)");
    7.             //读取点
    8.             //g1 = new WKTReader().read("POINT (2 2)");
    9.             //读取面
    10.             g1 = new WKTReader().read("POLYGON((40 100, 40 20, 120 20, 120 100, 40 100))");
    11.         } catch (ParseException e) {
    12.             e.printStackTrace();
    13.         }
    14. //        Arrays.stream(g1.getCoordinates()).forEach(point -> System.out.println("x:"+point.x+" y:"+point.y));
    15.         //输出结果：
    16. //        x:0.0 y:0.0
    17. //        x:10.0 y:10.0
    18. //        x:20.0 y:20.0
    19.  
    20.         //Arrays.stream(g1.getCoordinates()).forEach(point ->System.out.println("x:"+point.x+" y:"+point.y));
    21.         //输出：x:2.0 y:2.0
    22.  
    23.         //Arrays.stream(g1.getCoordinates()).forEach(point ->System.out.println("x:"+point.x+" y:"+point.y));
    24.         //输出：
    25. //        x:40.0 y:100.0
    26. //        x:40.0 y:20.0
    27. //        x:120.0 y:20.0
    28. //        x:120.0 y:100.0
    29. //        x:40.0 y:100.0

    3、创建点、线

    1.         //创建点
    2.         Point point = new GeometryFactory().createPoint(new Coordinate(1, 1));
    3.  
    4.         // create a geometry by specifying the coordinates directly
    5.         //通过指定坐标创建线
    6.         Coordinate[] coordinates = new Coordinate[]{new Coordinate(0, 0),
    7.                 new Coordinate(10, 10), new Coordinate(20, 20)};
    8.         // use the default factory, which gives full double-precision
    9.         Geometry g2 = new GeometryFactory().createLineString(coordinates);
    10.         //System.out.println("Geometry 2: " + g2);
    11.         //输出结果：Geometry 2: LINESTRING (0 0, 10 10, 20 20)

    4、计算点是否在线上、点是否在面内

    1.         //创建点
    2.         Point point = new GeometryFactory().createPoint(new Coordinate(1, 1));
    3.         //输出结果：POINT (1 1)
    4.         //计算点是否在线上
    5.         //System.out.println(g1.contains(point));
    6.         //输出结果：true
    7.  
    8.         //计算点是否在面内
    9.         Point point2 = new GeometryFactory().createPoint(new Coordinate(70, 70));
    10.         //System.out.println(g1.contains(point2));
    11.         //输出结果: true
    12.         Point point3 = new GeometryFactory().createPoint(new Coordinate(20, 10));
    13.         //System.out.println(g1.contains(point3));
    14.         //输出结果: false

    5、计算两个几何图形的交点

    1.         // compute the intersection of the two geometries
    2.         //计算两个几何图形的交点
    3.         Geometry g3 = g1.intersection(g2);
    4.         //System.out.println("G1 intersection G2: " + g3);
    5.         //输出结果：G1 intersection G2: MULTILINESTRING ((0 0, 10 10), (10 10, 20 20))

    6、创建一个MultiPoint多点

    1.         // create a factory using default values (e.g. floating precision)
    2.         //创建一个MultiPoint多点
    3.         GeometryFactory fact = new GeometryFactory();
    4.  
    5. //        Point p1 = fact.createPoint(new Coordinate(0,0));
    6. //        System.out.println(p1);
    7. //
    8. //        Point p2 = fact.createPoint(new Coordinate(1,1));
    9. //        System.out.println(p2);
    10. //
    11. //        MultiPoint mpt = fact.createMultiPointFromCoords(new Coordinate[] { new Coordinate(0,0), new Coordinate(1,1) } );
    12. //        System.out.println(mpt);
    13.  
    14.         //输出结果：
    15. //        POINT (0 0)
    16. //        POINT (1 1)
    17. //        MULTIPOINT ((0 0), (1 1))

    7、创建闭合线LinearRing

    1.         //创建闭合线-LinearRing
    2.         LinearRing lr = new GeometryFactory().createLinearRing(new Coordinate[]{new Coordinate(0, 0), new Coordinate(0, 10), new Coordinate(10, 10), new Coordinate(10, 0), new Coordinate(0, 0)});
    3.         //System.out.println(lr);
    4.         //输出结果：LINEARRING (0 0, 0 10, 10 10, 10 0, 0 0)

    8、创建几何集合列表

    1.         //创建几何集合列表
    2.         Geometry[] garray = new Geometry[]{g1,g2};
    3.         GeometryCollection gc = fact.createGeometryCollection(garray);
    4.         //System.out.println(gc.toString());
    5.         //输出结果：GEOMETRYCOLLECTION (POLYGON ((40 100, 40 20, 120 20, 120 100, 40 100)), LINESTRING (0 0, 10 10, 20 20))

    9、几何关系判断

    1.         //几何关系判断，是否相交intersection
    2.         //其他方法类似
    3. //        相等(Equals)： 几何形状拓扑上相等。
    4. //        不相交(Disjoint)： 几何形状没有共有的点。
    5. //        相交(Intersects)： 几何形状至少有一个共有点（区别于脱节）
    6. //        接触(Touches)： 几何形状有至少一个公共的边界点，但是没有内部点。
    7. //        交叉(Crosses)： 几何形状共享一些但不是所有的内部点。
    8. //        内含(Within)： 几何形状A的线都在几何形状B内部。
    9. //        包含(Contains)： 几何形状B的线都在几何形状A内部（区别于内含）
    10. //        重叠(Overlaps)： 几何形状共享一部分但不是所有的公共点，而且相交处有他们自己相同的区域。
    11.  
    12.         WKTReader reader = new WKTReader(fact);
    13.         LineString geometry1 = null;
    14.         try {
    15.             geometry1 = (LineString) reader.read("LINESTRING(0 0, 2 0, 5 0)");
    16.         } catch (ParseException e) {
    17.             e.printStackTrace();
    18.         }
    19.         LineString geometry2 = null;
    20.         try {
    21.             geometry2 = (LineString) reader.read("LINESTRING(0 0, 0 2)");
    22.         } catch (ParseException e) {
    23.             e.printStackTrace();
    24.         }
    25.         Geometry interPoint = geometry1.intersection(geometry2);//相交点
    26.         //System.out.println(interPoint.toText());
    27.         //输出结果： POINT (0 0)

    10、计算距离distance

    1.         //计算距离distance
    2.         Point p1 = fact.createPoint(new Coordinate(0,0));
    3.         //System.out.println(p1);
    4.  
    5.         Point p2 = fact.createPoint(new Coordinate(3,4));
    6.         ///System.out.println(p2);
    7.  
    8.         //System.out.println(p1.distance(p2));
    9.         //输出结果
    10. //        POINT (0 0)
    11. //        POINT (3 4)
    12. //        5.0

    11、计算长度和面积

    1.         Geometry g5 = null;
    2.         Geometry g6 = null;
    3.         try {
    4.             //读取面
    5.             g5 = new WKTReader().read("POLYGON((40 100, 40 20, 120 20, 120 100, 40 100))");
    6.             g6 = new WKTReader().read("LINESTRING(0 0, 0 2)");
    7.             //计算面积getArea()
    8.             //System.out.println(g5.getArea());
    9.             //输出结果：6400.0
    10.             //计算长度getLength()
    11.             //System.out.println(g6.getLength());
    12.             //输出结果：2.0
    13.         } catch (ParseException e) {
    14.             e.printStackTrace();
    15.         }

    12、求点到线、点到面的最近距离

    1.         GeometryFactory gf = new GeometryFactory();
    2.         WKTReader reader2 = new WKTReader(gf);
    3.         Geometry line2 = null;
    4.         Geometry g7 = null;
    5.         try {
    6.             line2 = reader2.read("LINESTRING(0 0, 10 0, 10 10, 20 10)");
    7.             g7 = new WKTReader().read("POLYGON((40 100, 40 20, 120 20, 120 100, 40 100))");
    8.         } catch (ParseException e) {
    9.             e.printStackTrace();
    10.         }
    11.         Coordinate c = new Coordinate(5, 5);
    12.         PointPairDistance ppd = new PointPairDistance();
    13.         //求点到线的最近距离
    14.         //DistanceToPoint.computeDistance(line2,c,ppd);
    15.         //输出结果:5.0
    16.         //求点到面的最近距离
    17.         DistanceToPoint.computeDistance(g7,c,ppd);
    18.         System.out.println(ppd.getDistance());
    19.         //输出结果38.07886552931954

    13、其他api可以参考其官方文档或者示例代码中进行使用。

  • 相关阅读:
    K-means 聚类算法学习笔记
    钢建筑模板和木建筑模板的优缺点？
    【leetcode】 剑指 Offer学习计划（java版本含注释）（下）
    Springboot整合Fastdfs上传图片、缩略图、下载文件、需求：文件转存方案(springboot整合线程池多线程实现)
    framebuffer驱动
    Python150题day12
    87 GB 模型种子，GPT-4 缩小版，超越ChatGPT3.5，多平台在线体验
    分布式服务器架构的优点有哪些？
    一文搞懂傅里叶级数与变换
    GIS前端编程-Leaflet插件发布
  • 原文地址：https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/126302894