JTS基本概念和使用

深碍√TFBOYSˉ_ 2023-09-30 13:44 56阅读 0赞

简介

  1. JTS是加拿大的 Vivid Solutions公司做的一套开放源码的 Java API。它提供了一套空间数据操作的核心算法。为在兼容OGC标准的空间对象模型中进行基础的几何操作提供2D空间谓词API。

操作

  1. 表示Geometry对象

    1. Geometry类型介绍见另一篇文章：WKT WKB和GeoJSON
    2. package com.alibaba.autonavi;
  1.         import com.vividsolutions.jts.geom.Coordinate;
  2.         import com.vividsolutions.jts.geom.Geometry;
  3.         import com.vividsolutions.jts.geom.GeometryCollection;
  4.         import com.vividsolutions.jts.geom.GeometryFactory;
  5.         import com.vividsolutions.jts.geom.LineString;
  6.         import com.vividsolutions.jts.geom.LinearRing;
  7.         import com.vividsolutions.jts.geom.Point;
  8.         import com.vividsolutions.jts.geom.Polygon;
  9.         import com.vividsolutions.jts.geom.MultiPolygon;
  10.         import com.vividsolutions.jts.geom.MultiLineString;
  11.         import com.vividsolutions.jts.geom.MultiPoint;
  12.         import com.vividsolutions.jts.io.ParseException;
  13.         import com.vividsolutions.jts.io.WKTReader;
  16.         public class GeometryDemo {
  19.             private GeometryFactory geometryFactory = new GeometryFactory();
  21.             /**
  22.              * create a point
  23.              * @return
  24.              */
  25.             public Point createPoint(){
  27.                 Coordinate coord = new Coordinate(109.013388, 32.715519);
  28.                 Point point = geometryFactory.createPoint( coord );
  29.                 return point;
  30.             }
  32.             /**
  33.              * create a point by WKT
  34.              * @return
  35.              * @throws ParseException 
  36.              */
  37.             public Point createPointByWKT() throws ParseException{
  39.                 WKTReader reader = new WKTReader( geometryFactory );
  40.                 Point point = (Point) reader.read("POINT (109.013388 32.715519)");
  41.                 return point;
  42.             }
  44.             /**
  45.              * create multiPoint by wkt
  46.              * @return
  47.              */
  48.             public MultiPoint createMulPointByWKT()throws ParseException{
  50.                 WKTReader reader = new WKTReader( geometryFactory );
  51.                 MultiPoint mpoint = (MultiPoint) reader.read("MULTIPOINT(109.013388 32.715519,119.32488 31.435678)");
  52.                 return mpoint;
  53.             }
  54.             /**
  55.              * 
  56.              * create a line
  57.              * @return
  58.              */
  59.             public LineString createLine(){
  61.                 Coordinate[] coords  = new Coordinate[] {
  62.                 new Coordinate(2, 2), new Coordinate(2, 2)};
  63.                 LineString line = geometryFactory.createLineString(coords);
  64.                 return line;
  65.             }
  67.             /**
  68.              * create a line by WKT
  69.              * @return
  70.              * @throws ParseException
  71.              */
  72.             public LineString createLineByWKT() throws ParseException{
  74.                 WKTReader reader = new WKTReader( geometryFactory );
  75.                 LineString line = (LineString) reader.read("LINESTRING(0 0, 2 0)");
  76.                 return line;
  77.             }
  79.             /**
  80.              * create multiLine 
  81.              * @return
  82.              */
  83.             public MultiLineString createMLine(){
  85.                 Coordinate[] coords1  = new Coordinate[] {
  86.                 new Coordinate(2, 2), new Coordinate(2, 2)};
  87.                 LineString line1 = geometryFactory.createLineString(coords1);
  88.                 Coordinate[] coords2  = new Coordinate[] {
  89.                 new Coordinate(2, 2), new Coordinate(2, 2)};
  90.                 LineString line2 = geometryFactory.createLineString(coords2);
  91.                 LineString[] lineStrings = new LineString[2];
  92.                 lineStrings[0]= line1;
  93.                 lineStrings[1] = line2;
  94.                 MultiLineString ms = geometryFactory.createMultiLineString(lineStrings);
  95.                 return ms;
  96.             }
  98.             /**
  99.              * create multiLine by WKT
  100.              * @return
  101.              * @throws ParseException
  102.              */
  103.             public MultiLineString createMLineByWKT()throws ParseException{
  105.                 WKTReader reader = new WKTReader( geometryFactory );
  106.                 MultiLineString line = (MultiLineString) reader.read("MULTILINESTRING((0 0, 2 0),(1 1,2 2))");
  107.                 return line;
  108.             }
  110.             /**
  111.              * create a polygon(多边形) by WKT
  112.              * @return
  113.              * @throws ParseException
  114.              */
  115.             public Polygon createPolygonByWKT() throws ParseException{
  117.                 WKTReader reader = new WKTReader( geometryFactory );
  118.                 Polygon polygon = (Polygon) reader.read("POLYGON((20 10, 30 0, 40 10, 30 20, 20 10))");
  119.                 return polygon;
  120.             }
  122.             /**
  123.              * create multi polygon by wkt
  124.              * @return
  125.              * @throws ParseException
  126.              */
  127.             public MultiPolygon createMulPolygonByWKT() throws ParseException{
  129.                 WKTReader reader = new WKTReader( geometryFactory );
  130.                 MultiPolygon mpolygon = (MultiPolygon) reader.read("MULTIPOLYGON(((40 10, 30 0, 40 10, 30 20, 40 10),(30 10, 30 0, 40 10, 30 20, 30 10)))");
  131.                 return mpolygon;
  132.             }
  134.             /**
  135.              * create GeometryCollection  contain point or multiPoint or line or multiLine or polygon or multiPolygon
  136.              * @return
  137.              * @throws ParseException
  138.              */
  139.             public GeometryCollection createGeoCollect() throws ParseException{
  141.                 LineString line = createLine();
  142.                 Polygon poly =  createPolygonByWKT();
  143.                 Geometry g1 = geometryFactory.createGeometry(line);
  144.                 Geometry g2 = geometryFactory.createGeometry(poly);
  145.                 Geometry[] garray = new Geometry[]{
  146.                 g1,g2};
  147.                 GeometryCollection gc = geometryFactory.createGeometryCollection(garray);
  148.                 return gc;
  149.             }
  151.             /**
  152.              * create a Circle  创建一个圆，圆心(x,y) 半径RADIUS
  153.              * @param x
  154.              * @param y
  155.              * @param RADIUS
  156.              * @return
  157.              */
  158.             public Polygon createCircle(double x, double y, final double RADIUS){
  160.                 final int SIDES = 32;//圆上面的点个数
  161.                 Coordinate coords[] = new Coordinate[SIDES+1];
  162.                 for( int i = 0; i < SIDES; i++){
  164.                     double angle = ((double) i / (double) SIDES) * Math.PI * 2.0;
  165.                     double dx = Math.cos( angle ) * RADIUS;
  166.                     double dy = Math.sin( angle ) * RADIUS;
  167.                     coords[i] = new Coordinate( (double) x + dx, (double) y + dy );
  168.                 }
  169.                 coords[SIDES] = coords[0];
  170.                 LinearRing ring = geometryFactory.createLinearRing( coords );
  171.                 Polygon polygon = geometryFactory.createPolygon( ring, null );
  172.                 return polygon;
  173.             }
  175.             /**
  176.              * @param args
  177.              * @throws ParseException 
  178.              */
  179.             public static void main(String[] args) throws ParseException {
  181.                 GeometryDemo gt = new GeometryDemo();
  182.                 Polygon p = gt.createCircle(0, 1, 2);
  183.                 //圆上所有的坐标(32个)
  184.                 Coordinate coords[] = p.getCoordinates();
  185.                 for(Coordinate coord:coords){
  187.                     System.out.println(coord.x+","+coord.y);
  188.                 }
  189.             }
  190.         }

  1. Geometry之间的关系

    1. 支持的空间操作包括





































相等(Equals)： 几何形状拓扑上相等。
脱节(Disjoint)： 几何形状没有共有的点。
相交(Intersects)： 几何形状至少有一个共有点（区别于脱节）
接触(Touches)： 几何形状有至少一个公共的边界点，但是没有内部点。
交叉(Crosses)： 几何形状共享一些但不是所有的内部点。
内含(Within)： 几何形状A的线都在几何形状B内部。
包含(Contains)： 几何形状B的线都在几何形状A内部（区别于内含）
重叠(Overlaps)： 几何形状共享一部分但不是所有的公共点，而且相交处有他们自己相同的区域。 
  1. package com.alibaba.autonavi;
  3. import com.vividsolutions.jts.geom.*;
  4. import com.vividsolutions.jts.io.ParseException;
  5. import com.vividsolutions.jts.io.WKTReader;
  7. /**
  8.  * gemotry之间的关系
  9.  *
  10.  */
  11. public class GeometryRelated {
  14.     private GeometryFactory geometryFactory = new GeometryFactory();
  16.     /**
  17.      *  两个几何对象是否是重叠的
  18.      * @return
  19.      * @throws ParseException
  20.      */
  21.     public boolean equalsGeo() throws ParseException{
  23.         WKTReader reader = new WKTReader( geometryFactory );
  24.         LineString geometry1 = (LineString) reader.read("LINESTRING(0 0, 2 0, 5 0)");
  25.         LineString geometry2 = (LineString) reader.read("LINESTRING(5 0, 0 0)");
  26.         return geometry1.equals(geometry2);//true
  27.     }
  29.     /**
  30.      * 几何对象没有交点(相邻)
  31.      * @return
  32.      * @throws ParseException
  33.      */
  34.     public boolean disjointGeo() throws ParseException{
  36.         WKTReader reader = new WKTReader( geometryFactory );
  37.         LineString geometry1 = (LineString) reader.read("LINESTRING(0 0, 2 0, 5 0)");
  38.         LineString geometry2 = (LineString) reader.read("LINESTRING(0 1, 0 2)");
  39.         return geometry1.disjoint(geometry2);
  40.     }
  42.     /**
  43.      * 至少一个公共点(相交)
  44.      * @return
  45.      * @throws ParseException
  46.      */
  47.     public boolean intersectsGeo() throws ParseException{
  49.         WKTReader reader = new WKTReader( geometryFactory );
  50.         LineString geometry1 = (LineString) reader.read("LINESTRING(0 0, 2 0, 5 0)");
  51.         LineString geometry2 = (LineString) reader.read("LINESTRING(0 0, 0 2)");
  52.         Geometry interPoint = geometry1.intersection(geometry2);//相交点
  53.         System.out.println(interPoint.toText());//输出 POINT (0 0)
  54.         return geometry1.intersects(geometry2);
  55.     }
  57.     /**
  58.      * 判断以x,y为坐标的点point(x,y)是否在geometry表示的Polygon中
  59.      * @param x
  60.      * @param y
  61.      * @param geometry wkt格式
  62.      * @return
  63.      */
  64.     public boolean withinGeo(double x,double y,String geometry) throws ParseException {
  67.         Coordinate coord = new Coordinate(x,y);
  68.         Point point = geometryFactory.createPoint( coord );
  70.         WKTReader reader = new WKTReader( geometryFactory );
  71.         Polygon polygon = (Polygon) reader.read(geometry);
  72.         return point.within(polygon);
  73.     }
  74.     /**
  75.      * @param args
  76.      * @throws ParseException 
  77.      */
  78.     public static void main(String[] args) throws ParseException {
  80.         GeometryRelated gr = new GeometryRelated();
  81.         System.out.println(gr.equalsGeo());
  82.         System.out.println(gr.disjointGeo());
  83.         System.out.println(gr.intersectsGeo());
  84.         System.out.println(gr.withinGeo(5,5,"POLYGON((0 0, 10 0, 10 10, 0 10,0 0))"));
  85.     }
  87. }

发表评论

表情：
评论列表 （有 0 条评论，56人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Git 的基本概念和使用方式

    一、Git基本概念 Git是一种分布式版本控制系统，它可以追踪文件的变化，并允许多人同时对同一文件进行更新和合并。以下是Git的基本概念和使用方式： 1. 仓库（Re

    亦凉亦凉/ 0 赞/ 126 阅读

    相关 jcs-基本概念和使用

    前言 如果一个计算非常耗时，每次获取都重新计算，会消耗很多额外的计算资源。对于这些耗时的计算结果，可以存储在缓存中，下次需要的时候，直接访问缓存中的内容，而不是再重新计算

    我不是女神ヾ我不是女神ヾ/ 0 赞/ 208 阅读

    相关 jts

    JTS基本概念和使用 简介 1. JTS是加拿大的 Vivid Solutions公司做的一套开放源码的 Java API。它提供了一套空间数据操作的核心算法。

    古城微笑少年丶古城微笑少年丶/ 0 赞/ 261 阅读