【JTS】JTS的几何图形的基本关系方法

最新推荐文章于 2023-09-06 04:27:34 发布
最新推荐文章于 2023-09-06 04:27:34 发布
阅读量6.6k 收藏 25
点赞数 3
分类专栏： JTS 文章标签： JTS 几何 关系 并集 交集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011001084/article/details/81119975
版权

拓扑关系——九交模型

2015年06月11日 08:42:30

阅读数：4541

空间关系

中文名称

OGC标准

解释

Contains

包含

是

一个几何图形的内部完全包含了另一个几何图形的内部和边界。

CoveredBy

覆盖

否

一个几何图形被另一个几何图形所包含，并且它们的边界相交。Point和MultiPoint不支持此空间关系，因为它们没有边界。

Crosses

交叉

是

一个几何图形的内部和另一个几何图形的边界和内部相交，但是它们的边界不相交。（两条线相交于一点，一条线和一个面相交）

Disjoint

分离

是

两个几何图形的边界和内部不相交。

EnvelopeIntersects

封套相交

否

两个几何图形的外接矩形相交。

Equal

相等

是

两个几何图形具有相同的边界和内部。

Inside

内部

否

一个几何图形在另一个几何图形的内部，但是和它的边界不接触。

Intersects

相交

是

两个几何图形没有分离(Non-DisJoint)。

Overlaps

重叠

是

两个几何图形的边界和内部相交(Intersect)。

Touch

接触

是

两个几何图形的边界相交，但是内部不相交。

Within

包含于

是

一个几何图形的内部和边界完全在另一个几何图形的内部。

MapGuide所支持的11种空间关系

维度扩展九交模式的形式如下所示，I（A）和I（B）表示A和B的内部（inside），B（A）和B（B）表示A和B的边界（border），E（A)和E（B）表示A和B的外部。

 

 

 

内部

边界

外部

内部

dim(I(a)ÇI(b))

dim(I(a)ÇB(b))

dim(I(a)ÇE(b))

边界

dim(B(a)ÇI(b))

dim(B(a)ÇB(b))

dim(B(a)ÇE(b))

外部

dim(E(a)ÇI(b))

dim(E(a)ÇB(b))

dim(E(a)ÇE(b))

维度扩展九交模型

空间关系描述：

 

 

SpatialRelDescription 描述
T********面与面内部相交
  

 

JTS基本概念和使用

简介

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

操作

  1. 表示Geometry对象
    1. Geometry类型介绍见另一篇文章：WKT WKB和GeoJSON
    2. package com.alibaba.autonavi;


import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryCollection;
import com.vividsolutions.jts.geom.GeometryFactory;
import com.vividsolutions.jts.geom.LineString;
import com.vividsolutions.jts.geom.LinearRing;
import com.vividsolutions.jts.geom.Point;
import com.vividsolutions.jts.geom.Polygon;
import com.vividsolutions.jts.geom.MultiPolygon;
import com.vividsolutions.jts.geom.MultiLineString;
import com.vividsolutions.jts.geom.MultiPoint;
import com.vividsolutions.jts.io.ParseException;
import com.vividsolutions.jts.io.WKTReader;


public class GeometryDemo {

    private GeometryFactory geometryFactory = new GeometryFactory();

    /**
     * create a point
     * @return
     */
    public Point createPoint(){
        Coordinate coord = new Coordinate(109.013388, 32.715519);
        Point point = geometryFactory.createPoint( coord );
        return point;
    }
    
    /**
     * create a point by WKT
     * @return
     * @throws ParseException 
     */
    public Point createPointByWKT() throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        Point point = (Point) reader.read("POINT (109.013388 32.715519)");
        return point;
    }
    
    /**
     * create multiPoint by wkt
     * @return
     */
    public MultiPoint createMulPointByWKT()throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        MultiPoint mpoint = (MultiPoint) reader.read("MULTIPOINT(109.013388 32.715519,119.32488 31.435678)");
        return mpoint;
    }
    /**
     * 
     * create a line
     * @return
     */
    public LineString createLine(){
        Coordinate[] coords  = new Coordinate[] {new Coordinate(2, 2), new Coordinate(2, 2)};
        LineString line = geometryFactory.createLineString(coords);
        return line;
    }
    
    /**
     * create a line by WKT
     * @return
     * @throws ParseException
     */
    public LineString createLineByWKT() throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        LineString line = (LineString) reader.read("LINESTRING(0 0, 2 0)");
        return line;
    }
    
    /**
     * create multiLine 
     * @return
     */
    public MultiLineString createMLine(){
        Coordinate[] coords1  = new Coordinate[] {new Coordinate(2, 2), new Coordinate(2, 2)};
        LineString line1 = geometryFactory.createLineString(coords1);
        Coordinate[] coords2  = new Coordinate[] {new Coordinate(2, 2), new Coordinate(2, 2)};
        LineString line2 = geometryFactory.createLineString(coords2);
        LineString[] lineStrings = new LineString[2];
        lineStrings[0]= line1;
        lineStrings[1] = line2;
        MultiLineString ms = geometryFactory.createMultiLineString(lineStrings);
        return ms;
    }
    
    /**
     * create multiLine by WKT
     * @return
     * @throws ParseException
     */
    public MultiLineString createMLineByWKT()throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        MultiLineString line = (MultiLineString) reader.read("MULTILINESTRING((0 0, 2 0),(1 1,2 2))");
        return line;
    }
    
    /**
     * create a polygon(多边形) by WKT
     * @return
     * @throws ParseException
     */
    public Polygon createPolygonByWKT() throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        Polygon polygon = (Polygon) reader.read("POLYGON((20 10, 30 0, 40 10, 30 20, 20 10))");
        return polygon;
    }
    
    /**
     * create multi polygon by wkt
     * @return
     * @throws ParseException
     */
    public MultiPolygon createMulPolygonByWKT() throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        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)))");
        return mpolygon;
    }
    
    /**
     * create GeometryCollection  contain point or multiPoint or line or multiLine or polygon or multiPolygon
     * @return
     * @throws ParseException
     */
    public GeometryCollection createGeoCollect() throws ParseException{
        LineString line = createLine();
        Polygon poly =  createPolygonByWKT();
        Geometry g1 = geometryFactory.createGeometry(line);
        Geometry g2 = geometryFactory.createGeometry(poly);
        Geometry[] garray = new Geometry[]{g1,g2};
        GeometryCollection gc = geometryFactory.createGeometryCollection(garray);
        return gc;
    }
    
    /**
     * create a Circle  创建一个圆，圆心(x,y) 半径RADIUS
     * @param x
     * @param y
     * @param RADIUS
     * @return
     */
    public Polygon createCircle(double x, double y, final double RADIUS){
        final int SIDES = 32;//圆上面的点个数
        Coordinate coords[] = new Coordinate[SIDES+1];
        for( int i = 0; i < SIDES; i++){
            double angle = ((double) i / (double) SIDES) * Math.PI * 2.0;
            double dx = Math.cos( angle ) * RADIUS;
            double dy = Math.sin( angle ) * RADIUS;
            coords[i] = new Coordinate( (double) x + dx, (double) y + dy );
        }
        coords[SIDES] = coords[0];
        LinearRing ring = geometryFactory.createLinearRing( coords );
        Polygon polygon = geometryFactory.createPolygon( ring, null );
        return polygon;
    }

    /**
     * @param args
     * @throws ParseException 
     */
    public static void main(String[] args) throws ParseException {
        GeometryDemo gt = new GeometryDemo();
        Polygon p = gt.createCircle(0, 1, 2);
        //圆上所有的坐标(32个)
        Coordinate coords[] = p.getCoordinates();
        for(Coordinate coord:coords){
            System.out.println(coord.x+","+coord.y);
        }
    }
}

       

  2. Geometry之间的关系
    1. 支持的空间操作包括

相等(Equals)：

几何形状拓扑上相等。

脱节(Disjoint)：

几何形状没有共有的点。

相交(Intersects)：

几何形状至少有一个共有点（区别于脱节）

接触(Touches)：

几何形状有至少一个公共的边界点，但是没有内部点。

交叉(Crosses)：

几何形状共享一些但不是所有的内部点。

内含(Within)：

几何形状A的线都在几何形状B内部。

包含(Contains)：

几何形状B的线都在几何形状A内部（区别于内含）

重叠(Overlaps)：

几何形状共享一部分但不是所有的公共点，而且相交处有他们自己相同的区域。

package com.alibaba.autonavi;

import com.vividsolutions.jts.geom.*;
import com.vividsolutions.jts.io.ParseException;
import com.vividsolutions.jts.io.WKTReader;

/**
 * gemotry之间的关系
 * @author xingxing.dxx
 *
 */
public class GeometryRelated {

    private GeometryFactory geometryFactory = new GeometryFactory();
    
    /**
     *  两个几何对象是否是重叠的
     * @return
     * @throws ParseException
     */
    public boolean equalsGeo() throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        LineString geometry1 = (LineString) reader.read("LINESTRING(0 0, 2 0, 5 0)");
        LineString geometry2 = (LineString) reader.read("LINESTRING(5 0, 0 0)");
        return geometry1.equals(geometry2);//true
    }
    
    /**
     * 几何对象没有交点(相邻)
     * @return
     * @throws ParseException
     */
    public boolean disjointGeo() throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        LineString geometry1 = (LineString) reader.read("LINESTRING(0 0, 2 0, 5 0)");
        LineString geometry2 = (LineString) reader.read("LINESTRING(0 1, 0 2)");
        return geometry1.disjoint(geometry2);
    }
    
    /**
     * 至少一个公共点(相交)
     * @return
     * @throws ParseException
     */
    public boolean intersectsGeo() throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        LineString geometry1 = (LineString) reader.read("LINESTRING(0 0, 2 0, 5 0)");
        LineString geometry2 = (LineString) reader.read("LINESTRING(0 0, 0 2)");
        Geometry interPoint = geometry1.intersection(geometry2);//相交点
        System.out.println(interPoint.toText());//输出 POINT (0 0)
        return geometry1.intersects(geometry2);
    }

    /**
     * 判断以x,y为坐标的点point(x,y)是否在geometry表示的Polygon中
     * @param x
     * @param y
     * @param geometry wkt格式
     * @return
     */
    public boolean withinGeo(double x,double y,String geometry) throws ParseException {

        Coordinate coord = new Coordinate(x,y);
        Point point = geometryFactory.createPoint( coord );

        WKTReader reader = new WKTReader( geometryFactory );
        Polygon polygon = (Polygon) reader.read(geometry);
        return point.within(polygon);
    }
    /**
     * @param args
     * @throws ParseException 
     */
    public static void main(String[] args) throws ParseException {
        GeometryRelated gr = new GeometryRelated();
        System.out.println(gr.equalsGeo());
        System.out.println(gr.disjointGeo());
        System.out.println(gr.intersectsGeo());
        System.out.println(gr.withinGeo(5,5,"POLYGON((0 0, 10 0, 10 10, 0 10,0 0))"));
    }

}

 

 

关系判断

  1. Geometry之间的关系有如下几种：

相等(Equals)：

几何形状拓扑上相等。

脱节(Disjoint)：

几何形状没有共有的点。

相交(Intersects)：

几何形状至少有一个共有点（区别于脱节）

接触(Touches)：

几何形状有至少一个公共的边界点，但是没有内部点。

交叉(Crosses)：

几何形状共享一些但不是所有的内部点。

内含(Within)：

几何形状A的线都在几何形状B内部。

包含(Contains)：

几何形状B的线都在几何形状A内部（区别于内含）

重叠(Overlaps)：

几何形状共享一部分但不是所有的公共点，而且相交处有他们自己相同的区域。

  1. 如下例子展示了如何使用Equals,Disjoint,Intersects,Within操作：

复制代码

package com.alibaba.autonavi;

import com.vividsolutions.jts.geom.*;
import com.vividsolutions.jts.io.ParseException;
import com.vividsolutions.jts.io.WKTReader;

/**
 * gemotry之间的关系
 * @author xingxing.dxx
 *
 */
public class GeometryRelated {

    private GeometryFactory geometryFactory = new GeometryFactory();
    
    /**
     *  两个几何对象是否是重叠的
     * @return
     * @throws ParseException
     */
    public boolean equalsGeo() throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        LineString geometry1 = (LineString) reader.read("LINESTRING(0 0, 2 0, 5 0)");
        LineString geometry2 = (LineString) reader.read("LINESTRING(5 0, 0 0)");
        return geometry1.equals(geometry2);//true
    }
    
    /**
     * 几何对象没有交点(相邻)
     * @return
     * @throws ParseException
     */
    public boolean disjointGeo() throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        LineString geometry1 = (LineString) reader.read("LINESTRING(0 0, 2 0, 5 0)");
        LineString geometry2 = (LineString) reader.read("LINESTRING(0 1, 0 2)");
        return geometry1.disjoint(geometry2);
    }
    
    /**
     * 至少一个公共点(相交)
     * @return
     * @throws ParseException
     */
    public boolean intersectsGeo() throws ParseException{
        WKTReader reader = new WKTReader( geometryFactory );
        LineString geometry1 = (LineString) reader.read("LINESTRING(0 0, 2 0, 5 0)");
        LineString geometry2 = (LineString) reader.read("LINESTRING(0 0, 0 2)");
        Geometry interPoint = geometry1.intersection(geometry2);//相交点
        System.out.println(interPoint.toText());//输出 POINT (0 0)
        return geometry1.intersects(geometry2);
    }

    /**
     * 判断以x,y为坐标的点point(x,y)是否在geometry表示的Polygon中
     * @param x
     * @param y
     * @param geometry wkt格式
     * @return
     */
    public boolean withinGeo(double x,double y,String geometry) throws ParseException {

        Coordinate coord = new Coordinate(x,y);
        Point point = geometryFactory.createPoint( coord );

        WKTReader reader = new WKTReader( geometryFactory );
        Polygon polygon = (Polygon) reader.read(geometry);
        return point.within(polygon);
    }
    /**
     * @param args
     * @throws ParseException 
     */
    public static void main(String[] args) throws ParseException {
        GeometryRelated gr = new GeometryRelated();
        System.out.println(gr.equalsGeo());
        System.out.println(gr.disjointGeo());
        System.out.println(gr.intersectsGeo());
        System.out.println(gr.withinGeo(5,5,"POLYGON((0 0, 10 0, 10 10, 0 10,0 0))"));
    }

}

复制代码

 

关系分析

  1. 关系分析有如下几种

缓冲区分析（Buffer）

包含所有的点在一个指定距离内的多边形和多多边形

凸壳分析（ConvexHull）

包含几何形体的所有点的最小凸壳多边形（外包多边形）

交叉分析（Intersection）

A∩B 交叉操作就是多边形AB中所有共同点的集合

联合分析（Union）

AUB AB的联合操作就是AB所有点的集合

差异分析（Difference）

(A-A∩B) AB形状的差异分析就是A里有B里没有的所有点的集合

对称差异分析（SymDifference）

(AUB-A∩B) AB形状的对称差异分析就是位于A中或者B中但不同时在AB中的所有点的集合

 

 

 

 

 

 

 

 

 

     2. 我们来看看具体的例子

复制代码

package com.alibaba.autonavi;

import java.util.ArrayList;
import java.util.List;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryFactory;
import com.vividsolutions.jts.geom.LineString;

/**
 * gemotry之间的关系分析
 *
 * @author xingxing.dxx
 */
public class Operation {

    private GeometryFactory geometryFactory = new GeometryFactory();

    /**
     * create a Point
     *
     * @param x
     * @param y
     * @return
     */
    public Coordinate point(double x, double y) {
        return new Coordinate(x, y);
    }


    /**
     * create a line
     *
     * @return
     */
    public LineString createLine(List<Coordinate> points) {
        Coordinate[] coords = (Coordinate[]) points.toArray(new Coordinate[points.size()]);
        LineString line = geometryFactory.createLineString(coords);
        return line;
    }

    /**
     * 返回a指定距离内的多边形和多多边形
     *
     * @param a
     * @param distance
     * @return
     */
    public Geometry bufferGeo(Geometry a, double distance) {
        return a.buffer(distance);
    }

    /**
     * 返回(A)与(B)中距离最近的两个点的距离
     *
     * @param a
     * @param b
     * @return
     */
    public double distanceGeo(Geometry a, Geometry b) {
        return a.distance(b);
    }

    /**
     * 两个几何对象的交集
     *
     * @param a
     * @param b
     * @return
     */
    public Geometry intersectionGeo(Geometry a, Geometry b) {
        return a.intersection(b);
    }

    /**
     * 几何对象合并
     *
     * @param a
     * @param b
     * @return
     */
    public Geometry unionGeo(Geometry a, Geometry b) {
        return a.union(b);
    }

    /**
     * 在A几何对象中有的，但是B几何对象中没有
     *
     * @param a
     * @param b
     * @return
     */
    public Geometry differenceGeo(Geometry a, Geometry b) {
        return a.difference(b);
    }


    public static void main(String[] args) {
        Operation op = new Operation();
        //创建一条线
        List<Coordinate> points1 = new ArrayList<Coordinate>();
        points1.add(op.point(0, 0));
        points1.add(op.point(1, 3));
        points1.add(op.point(2, 3));
        LineString line1 = op.createLine(points1);
        //创建第二条线
        List<Coordinate> points2 = new ArrayList<Coordinate>();
        points2.add(op.point(3, 0));
        points2.add(op.point(3, 3));
        points2.add(op.point(5, 6));
        LineString line2 = op.createLine(points2);

        System.out.println(op.distanceGeo(line1, line2));//out 1.0
        System.out.println(op.intersectionGeo(line1, line2));//out GEOMETRYCOLLECTION EMPTY
        System.out.println(op.unionGeo(line1, line2)); //out MULTILINESTRING ((0 0, 1 3, 2 3), (3 0, 3 3, 5 6))
        System.out.println(op.differenceGeo(line1, line2));//out LINESTRING (0 0, 1 3, 2 3)
    }
}
ArthurKingYs
关注
  • 3
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
jts-app.rar
05-22
Geometry空间分析方法几何图形操作包，在operation包内，包含buffer、distance、linemerge、overlap、polygonize、predicate、relate等包。分别对应着计算图形的缓冲、距离、线段融合、图形覆盖、多边形化、断言、关联等的操作。图形化测试，简单方便。
JTS Topology Suite中文版
09-22
Java Transaction Service（Java事务服务）拓扑套件，是一种能够利用清楚精确的模型和强大的几何算法来实现一套核心空间数据操作的JAVA 应用编程接口（API）。它提供一种详细说明2-D线性几何图形（Geometry）的完善模式。许多在计算几何学的普通操作（Operation）和空间数据处理在一个清晰的，一致的，完整的应用程序接口（API）是无掩蔽的。Java事务服务（JTS）是为了致力于能够支持确定性，清洁性，完整性和对空间数据进行查询的应用软件的发展。
jts-1.14.zip
12-17
JTS工具，处理GIS图形数据。可以对于GIS几何数据进行处理。
JTS中文API.rar
11-15
该资源为JAVA事务处理拓扑套件-开发者指南中文API Java Transaction Service（Java事务服务）拓扑套件，是一种能够利用清楚精确的模型和强大的几何算法来实现一套核心空间数据操作的JAVA 应用编程接口（API）。它提供一种详细说明2-D线性几何图形（Geometry）的完善模式。许多在计算几何学的普通操作（Operation）和空间数据处理在一个清晰的，一致的，完整的应用程序接口（API）是无掩蔽的。Java事务服务（JTS）是为了致力于能够支持确定性，清洁性，完整性和对空间数据进行查询的应用软件的发展。 本文档适合于那些愿意使用JTS的开发者去满足他们对空间数据处理的需求。它描述了JTS应用程序接口API并且提供了源码范例。
【NetTopologySuite类库】NTS与JTS一些问题整理
blucod的博客
06-10 2804
文章目录介绍SO上有关的一些问答多边形自交情况处理 介绍 NTS是C#版的JTS(Java Topology Suite)，两者的API相似，代码很容易相互转化。 所以一个功能能用JTS实现，也能在NTS中找到对应API来实现。 SO上有关的一些问答 NTS的基础功能很容易上手，可以参考之前写的一点内容。 有些略微复杂的功能在国内博客上找不到，但在Stack OVerflow中能找到，于是下面列举了一些在SO中搜过的，并试验有效的问答。 多边形自交情况处理 1、CSDN上有播客介绍：博客1，其源自SO上的一
JTS（Geometry）表示圆形
PG_STAR的博客
04-24 7514
在平时工作中会涉及一些空间范围的操作，比如两个面求交集，求一个多边形的面积等等，一般都会用到JTS。JTS支持点线面的很多操作，关键字为point、linestring、polygon。JTS没有直接表示圆的关键字，一般用一个多边形表示圆：1，确定边数2，画一个环线3，根据环线生成面public class JtsTest { private static GeometryFactory ge...
【JTS】JTS空间拓扑关系的测试
KingWang@whu的博客
07-30 3101
在JTS中有九种拓扑关系函数，touches、covers、within、crosses、intersects、disjoint、equals、overlaps、contains、coveredBy。 对于线，环，多边形这三种各有不同的特点，线不闭合，环是闭合的，多边形是一种面状。三者分别对应JTS中的LineString、LinearRing、Polygon。 JTS的jar包和开发文档下载
Java JTS点线面分析、线以及多边形合并、面积计算
Fang_cl的博客
07-24 8704
参考文章： https://blog.csdn.net/kone0611/article/details/83781484 https://wenku.baidu.com/view/839cbdb1fd0a79563c1e726c.html Geometry 空间分析方法几何图形操作包，在operat
JTS拓扑套件 开发人员指南
最新发布
hayaqi0504的博客
09-06 465
JTS拓扑套件是一个Java API，它使用明确的高精度模型和稳健的几何算法实现了一组核心空间数据操作。它为二维平面几何提供了一个完整的模型。计算几何和空间数据处理中的许多常见操作都清晰、一致的集成到公开的API中。JTS旨在为空间数据提供验证、清洗、集成和查询处理。本文档适用于希望使用JTS来满足其空间数据处理需求的开发人员。它描述了JTS API的常见用法，并给出了代码示例。1.1其他资源SQLRevision1.1的OpenGIS简化功能说明（请参阅本文档中的sSFS）。
JTS-Java图形拓扑学习笔记
java、c++、机器学习方向King
07-07 1943
请注意，KD树的结构取决于插入点的顺序。当基站数量在二个以上时，全平面会划分为多个包罗一个基站的区域，区域中任何一点都与本区域内基站间隔最近，是以这些个区域可以看作是基站的覆盖区域，我们将这种由多个点将平面划分成的图称为泰森多边形，又称为Voronoi 图。JTS由加拿大的VividSolutions公司开发，是一个用Java语言描述的几何拓扑套件，遵循OpenGIS的Simple Feature Specification，封装了2D几何类型和非常多的空间分析操作，而且包含了不少常见的计算几何算法实现。
JTS两个空间几何图形间最短距离，及最短距离间的两个坐标
10-12
记录下 java jts 求两个空间几何图形间最短距离，及最短距离间的两个坐标. 如：求一个点到一条直线的垂直坐标
jts学习——com.vividsolutions.jts.geom包
weixin_44280356的博客
10-13 3203
介绍 jts是一个为GIS服务提供的api，内部可以用坐标点构建空间模型，判断模型之间的关系等 Coordinate JTS内部封装的一个坐标类Coordinate(坐标)是用来存储坐标的轻便的类。它不同于点，点是Geometry的子类。不像模范Point的对象(包含额外的信息，例如一个信包，一个精确度模型和空间参考系统信息)，Coordinate只包含纵座标值和...
GeoTools使用--jts处理线的自相交问题
奥法vx的笔记
11-19 6405
jts处理线的自相交问题 做图形处理的时候，经常遇到面的边线有自相交的交点，当进行面面合并、拆分时就会报错： com.vividsolutions.jts.geom.TopologyException: side location conflict [ (1.3808092156632675E7, 4827228.3856722275, NaN) ] 这里使用面的边线进行自相交，获取线的所有点（包含相交点），然后在重新生成多边形面。 处理前的图形： 处理代码： public static voi
JTS多边形自相交异常问题处理
tomcat的博客
08-18 496
这个问题和同事谈论了下，最终在Stack Overflow上找到了解决方案，intersection前先判断下两polygon或者GeoMetry是否完整，通过isValid来判断，上链接。看了下报错信息的含义，是说对于红色区域的多边形来说，线段GH和JE之间是没有交点的，但是在做相交运算时，则需要有交点，但需要的时候却发现没有，所以报找不到交点的错。就是下图中的交错点。从逻辑上讲写的没问题，然后本地验证了下，发现是JTS自身报的异常。//去除超过空间的部分。//去除柜体重叠部分。
【GeoTools】JTS几何关系判断
sipengfei_的博客
01-12 3514
GeoTools JTS的几何关系判断 maven: <dependency> <groupId>org.locationtech.jts</groupId> <artifactId>jts-core</artifactId> <version>1.16.1</version> </dependency> 相等（equals） /** * 判断两个几何图形是否相等 * @thro
JavaScript中Set求交集/并集/差集
to_the_Future的博客
06-24 2857
通过使用Set对象，我们可以很方便地进行交集、并集和差集运算，从而快速地对数据进行处理。需要注意的是，Set对象中不允许出现重复的值，因此合并后的集合中不会包含重复的元素。
JTS 空间数据模型
chenhua1028的专栏
12-02 1619
空间数据模型 空间数据模型 (1)、JTS Geometry model  (2)、ISO Geometry model (Geometry Plugin and JTS Wrapper Plugin) GeoTools has two implementations of these interfaces: Geometry Plugin a port of JTS 1.7 t
【JTS -- 空间数据处理】--计算两个几何图形的关系
十年磨一剑，沉淀……
01-08 3995
当前需求是需要为建图算法建立评价指标，比如精准率和召回率指标，这两个指标如何计算在此不细说了，其中主要用到了JTS做空间关系计算。 差分出两份OSM 文件中同一个Way节点之间的重合的Node部分，多余的部分和空缺的部分； 用到了JTS 中的 buffer 和 intersection来做 两个Way也就是两个LINESTRING ，但并不是所有Node经纬度完全相同的Linestring, 而...
JTS 空间数据关系判定
十年磨一剑，沉淀……
01-08 2913
Geometry之间的关系有如下几种，JTS中都有相应的方法做关系判定: JTS Geometry关系判断：
jts库中PolygonBuilder没有getMergedPolygon这个方法
07-13
抱歉，我之前提到的 `PolygonBuilder` 和 `getMergedPolygon` 方法是我自己编写的示例代码，而不是 JTS 库中的实际方法。在 JTS 库中，你可以使用以下步骤将多个相邻的面合并为一个面： 1. 创建一个空的 `GeometryFactory` 对象。这将用于创建几何对象。 ```java GeometryFactory factory = new GeometryFactory(); ``` 2. 使用 `Polygon` 类来表示每个面，并将它们添加到一个 `GeometryCollection` 中。 ```java Polygon face1 = ...; // 创建第一个面 Polygon face2 = ...; // 创建第二个面 // 创建更多面... List<Polygon> polygons = new ArrayList<>(); polygons.add(face1); polygons.add(face2); // 添加更多面... GeometryCollection geometryCollection = new GeometryCollection(polygons.toArray(new Polygon[0]), factory); ``` 3. 使用 `UnaryUnionOp` 类的 `union` 方法来合并多边形。 ```java Geometry mergedGeometry = UnaryUnionOp.union(geometryCollection); ``` 现在，`mergedGeometry` 将包含所有输入面的合并结果。你可以根据需要将其转换为 `Polygon` 对象或进行进一步的操作或分析。 请注意，以上代码是一个示例，你需要根据你的实际需求来调整代码。确保在使用 JTS 库之前，你已经正确地导入了相关的类和包。另外，你需要确保输入的面是有效的，并且相邻的面之间没有空隙或重叠。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值