【JTS】利用JTS生成R树索引

最新推荐文章于 2024-03-24 09:50:24 发布
最新推荐文章于 2024-03-24 09:50:24 发布
阅读量5k 收藏 9
点赞数 3
分类专栏： Java 文章标签： r树 索引 空间 网格
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wk1134314305/article/details/76408181
版权

前言

因为，笔者最近在做一个大数据量地图在线展示的项目，因此需要利用一些手段来提升效率，例如地图缩放的时候，需要展示浏览器窗口下的实时点位，轨迹等信息。在大比例尺下（也就是放大级别较大的时候），因此只需要展示目前这个窗口大小内的数据。那么怎么知道目前窗口大小内的有哪些点位信息呢，这个时候，R树的索引就出现了，可以很好地解决这个问题。利用一个矩形框（浏览器窗口大小）来进行R树索引就可以找出矩形框内的点位了。

R树索引是一种空间数据索引，具有高效的特点，在现实生活中，R树可以用来存储地图上的空间信息，例如餐馆地址，或者地图上用来构造街道，建筑，湖泊边缘和海岸线的多边形。然后可以用它来回答“查找距离我2千米以内的博物馆”，“检索距离我2千米以内的所有路段”（然后显示在导航系统中）或者“查找（直线距离）最近的加油站”这类问题。R树还可以用来加速使用包括大圆距离在内的各种距离度量方式的最邻近搜索。

具体原理和用途可以参考下面两个网页：

R树维基百科
R树索引原理

而目前有很多成熟的第三方库提供了这个功能，例如本文用到的JTS。

JTS的开发文档和相应的jar包的下载地址：JTS下载

JTS提供了如下的空间数据类型，还提供了读取各种空间描述文件（WTK等），线简化，空间操作（求交，计算距离，计算外包矩形等），建立空间索引等多种算法。

Point
MultiPoint
LineString
LinearRing 封闭的线条
MultiLineString 多条线
Polygon
MultiPolygon
GeometryCollection 包括点，线，面

里面最主要的几个类，GeometryFactory，Geometry，Envelope以及上面提到的几种常用数据类型。

因为本文中主要用到空间索引和空间拓扑关系的计算，因此下面重点讲解一下相关的内容。

1，几个概念

Geometry类：所有的空间数据类型，点，线，面，多点，环，多边形等等都是继承自Geometry类的。
Envelope类：该类就是描述一个空间几何对象的外包矩形，由max_x,max_y,min_x,min_y组成。

2，空间关系

空间关系主要是由九交模型来描述的，九交模型的讲解可以参考：九交模型的讲解

至于在JTS中的对应的关系，就是以下几种：
这里写图片描述

3，空间索引

空间索引有很多种，下面就介绍网格索引和R树索引，这部分很成熟，网格索引是最原始的空间索引了，R树稍微“时髦”一点，效率更高。
这两个可以参看：
地理信息系统原理在线教程——空间索引
深入浅出空间索引：为什么需要空间索引
深入浅出空间索引：2

相应的，如何利用JTS实现R树索引呢？

以下是相应的代码

SpatialUtil.java

package util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.CoordinateSequences;
import com.vividsolutions.jts.geom.Envelope;
import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryFactory;
import com.vividsolutions.jts.geom.LineString;
import com.vividsolutions.jts.geom.LinearRing;
import com.vividsolutions.jts.geom.MultiPoint;
import com.vividsolutions.jts.geom.Polygon;
import com.vividsolutions.jts.geom.impl.CoordinateArraySequence;
import com.vividsolutions.jts.index.strtree.STRtree;

import config.GeoConfig;
import dao.QueryTrail;
import entity.CompareValue;
import entity.GPSPoint;
import entity.Grid;
import entity.Line;
import entity.Point;
import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.client.HttpResponse;
import io.vertx.ext.web.client.WebClient;

public class SpatialUtil {
    static String result=new String();
    //下面是我用高德地图API和JTS求解武汉市的边界多边形之后，求解出的武汉的外包矩形范围（里面用了vertx中的client）
    public static void getPolygonofWuhan(String[] args) {
        Vertx vertx = Vertx.vertx();
        WebClient client = WebClient.create(vertx);
        client.get(80, "restapi.amap.com",
                "/v3/config/district?keywords=%E6%AD%A6%E6%B1%89&subdistrict=0&key=高德地图API申请的Token&extensions=all")
                .send(ar -> {
                    if (ar.succeeded()) {
                        // Obtain response
                        HttpResponse<Buffer> response = ar.result();
                        result = response.bodyAsString();
                        JsonObject jo = new JsonObject(result);
                        result = jo.getJsonArray("districts").getJsonObject(0).getString("polyline");
                        GeometryFactory factory=new GeometryFactory();
                        String[] xyStrings=result.replace("|", ";").split(";");
                        List<Coordinate> list=new ArrayList<>();
                        for(String xy:xyStrings){
                            String[] s_arr=xy.split(",");
                            double[] d_xy=new double[2];
                            d_xy[0]=Double.parseDouble(s_arr[0]);
                            d_xy[1]=Double.parseDouble(s_arr[1]);
                            Coordinate coor=new Coordinate(d_xy[0], d_xy[1]);
                            list.add(coor);
                        }
                        Coordinate[] coor_arr=list.toArray(new Coordinate[0]);
                        MultiPoint multiPoint=factory.createMultiPoint(coor_arr);
                        Geometry env=multiPoint.getEnvelope();
                        Coordinate[] MBR=env.getCoordinates();
                        for(int i=0;i<MBR.length;i++){
                            System.out.println(MBR[i].x+","+MBR[i].y);
                        }
                        client.close();
                        vertx.close();
                    } else {
                        System.out.println("Something went wrong " + ar.cause().getMessage());
                    }
                });
    }
    /**
     * 计算两点的距离差在哪个阈值范围内
     * @param pt1
     * @param pt2
     * @param config    阈值的设置
     * @return
     */
    public static CompareValue inTolerance(Point pt1,Point pt2,GeoConfig config){
        double delta=Math.sqrt(Math.pow(pt1.getX()-pt2.getX(),2)+Math.pow(pt1.getY()-pt2.getY(), 2));
        double max=config.getMaxGeoRange();
        double min=config.getMinGeoRange();
        if(delta<min){
            return CompareValue.LT;
        }else if(delta<=max&&delta>=min){
            return CompareValue.IN;
        }else{
            return CompareValue.GT;
        }
    }
    /**
     * 建立网格
     * @return
     */
    public static HashMap<String,Grid> createGrids(){
        HashMap<String,Grid> gridMap=new HashMap<>();
        double left_top_x=Double.parseDouble(PropertiesUtil.getProperties("common", "left-top").split(",")[0]);
        double left_top_y=Double.parseDouble(PropertiesUtil.getProperties("common", "left-top").split(",")[1]);
        double right_bottom_x=Double.parseDouble(PropertiesUtil.getProperties("common", "right-bottom").split(",")[0]);
        double right_bottom_y=Double.parseDouble(PropertiesUtil.getProperties("common", "right-bottom").split(",")[1]);
        int rows=Integer.parseInt(PropertiesUtil.getProperties("common", "rows"));
        int cols=Integer.parseInt(PropertiesUtil.getProperties("common", "cols"));
        double interval_x=Double.parseDouble(ParseDataType.parseD2s((right_bottom_x-left_top_x)/(cols*1.0),6));
        double interval_y=Double.parseDouble(ParseDataType.parseD2s((left_top_y-right_bottom_y)/(rows*1.0),6));
        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
                Grid grid=new Grid();
                grid.setCol(cols);
                grid.setRow(rows);
                grid.setIndex(i*cols+j+1);
                Point lefttop=new Point();
                Point rightbottom=new Point();
                lefttop.setX(left_top_x+j*interval_x);
                lefttop.setY(left_top_y-i*interval_y);
                if(j==cols-1){
                    rightbottom.setX(right_bottom_x);
                }else{
                    rightbottom.setX(left_top_x+(j+1)*interval_x);
                }
                if(i==rows-1){
                    rightbottom.setY(right_bottom_y);
                }else{
                    rightbottom.setY(left_top_y-(i+1)*interval_y);
                }
                grid.setLefttop(lefttop);
                grid.setRightbottom(rightbottom);
                gridMap.put(String.valueOf(grid.getRow())+"_"+String.valueOf(grid.getCol())+"_"+String.valueOf(grid.getIndex()),grid);
            }
        }
        return gridMap;
    }

    /**
     * 建立网格索引
     */
    public static HashMap<String, Grid> createGridIndex(){

        HashMap<String, Grid> gridmap=createGrids();

        int cols=Integer.parseInt(PropertiesUtil.getProperties("common", "cols"));
        int rows=Integer.parseInt(PropertiesUtil.getProperties("common", "rows"));
        String rbPt_s=PropertiesUtil.getProperties("common", "right-bottom");
        Point rbPt=new Point();
        rbPt.setX(Double.parseDouble(rbPt_s.split(",")[0]));
        rbPt.setY(Double.parseDouble(rbPt_s.split(",")[1]));
        String ltPt_s=PropertiesUtil.getProperties("common", "left-top");
        Point ltPt=new Point();
        ltPt.setX(Double.parseDouble(ltPt_s.split(",")[0]));
        ltPt.setY(Double.parseDouble(ltPt_s.split(",")[1]));
        double range_x=rbPt.getX()-ltPt.getX();
        double range_y=ltPt.getY()-rbPt.getY();
        QueryTrail query=new QueryTrail();
        HashMap<String, Line> map=query.getLine();
        GeoConfig config=new GeoConfig();
        config.setMaxGeoRange(Double.parseDouble(PropertiesUtil.getProperties("common", "maxGeoRange")));
        config.setMinGeoRange(Double.parseDouble(PropertiesUtil.getProperties("common", "minGeoRange")));
        GeometryFactory factory=new GeometryFactory();
        for(Entry<String, Line> entry:map.entrySet()){
            Line templine=entry.getValue().sort(true);
            List<Line> list=templine.filter(config);
            for(Line line:list){
                List<GPSPoint> gpslist=line.getCoors();
                List<Coordinate> coors=new ArrayList<>();
                for(GPSPoint xy:gpslist){
                    double x=xy.getX();
                    double y=xy.getY();
                    Coordinate coor=new Coordinate(x, y);
                    coors.add(coor);
                }
                Coordinate[] coor_arr=coors.toArray(new Coordinate[0]);
                if(coor_arr.length>1){
                    LineString l_s=factory.createLineString(coor_arr);
                    Envelope env=l_s.getEnvelopeInternal();
                    double max_x=env.getMaxX();
                    double min_x=env.getMinX();
                    double max_y=env.getMaxY();
                    double min_y=env.getMinY();
                    int max_j=(int)((max_x-ltPt.getX())/range_x*cols);
                    int max_i=(int)((ltPt.getY()-max_y)/range_y*rows);
                    int min_j=(int)((min_x-ltPt.getX())/range_x*cols);
                    int min_i=(int)((ltPt.getY()-min_y)/range_y*rows);
                    a:for(int i=max_i;i<=min_i;i++){
                        for(int j=min_j;j<=max_j;j++){
                            Grid grid=gridmap.get(String.valueOf(rows)+"_"+String.valueOf(cols)+"_"+String.valueOf(i*cols+j+1));
                            Coordinate[] coor_arr1=new Coordinate[5];
                            coor_arr1[0]=new Coordinate(grid.getLefttop().getX(), grid.getLefttop().getY());
                            coor_arr1[1]=new Coordinate(grid.getLefttop().getX(), grid.getRightbottom().getY());
                            coor_arr1[2]=new Coordinate(grid.getRightbottom().getX(), grid.getRightbottom().getY());
                            coor_arr1[3]=new Coordinate(grid.getRightbottom().getX(), grid.getLefttop().getY());
                            coor_arr1[4]=new Coordinate(grid.getLefttop().getX(), grid.getLefttop().getY());
                            CoordinateArraySequence seq=new CoordinateArraySequence(coor_arr1);
                            LinearRing ring = new LinearRing(seq, new GeometryFactory());
                            Polygon poly=new Polygon(ring, null, new GeometryFactory());
                            if(l_s.crosses(poly)||poly.covers(l_s)){
                                grid.addLine(line);
                                break a;
                            }
                        }
                    }
                }else{
                    GPSPoint point=gpslist.get(0);
                    int j=(int)((point.getX()-ltPt.getX())/range_x*cols);
                    int i=(int)((ltPt.getY()-point.getY())/range_y*rows);
                    Grid grid=gridmap.get(String.valueOf(rows)+"_"+String.valueOf(cols)+"_"+String.valueOf(i*cols+j+1));
                    grid.addLine(line);
                }
            }
        }
        System.out.println("网格索引创建成功！");
        return gridmap;
    }


    /**
     * 建立R树索引
     * @return
     */
    public static STRtree createRtree(){
        QueryTrail query=new QueryTrail();
        HashMap<String, Line> map=query.getLine();
        GeoConfig config=new GeoConfig();
        config.setMaxGeoRange(Double.parseDouble(PropertiesUtil.getProperties("common", "maxGeoRange")));
        config.setMinGeoRange(Double.parseDouble(PropertiesUtil.getProperties("common", "minGeoRange")));
        STRtree tree=new STRtree();
        for(Entry<String, Line> entry:map.entrySet()){
            Line templine=entry.getValue().sort(true);
            List<Line> list=templine.filter(config);
            for(Line line:list){
                GeometryFactory factory=new GeometryFactory();
                List<Coordinate> coors=new ArrayList<>();
                List<GPSPoint> gpslist=line.getCoors();
                for(GPSPoint xy:gpslist){
                    double x=xy.getX();
                    double y=xy.getY();
                    Coordinate coor=new Coordinate(x, y);
                    coors.add(coor);
                }
                Coordinate[] coor_arr=coors.toArray(new Coordinate[0]);
                if(coor_arr.length>1){
                    LineString lineStr=factory.createLineString(coor_arr);
                    Envelope env=lineStr.getEnvelopeInternal();
                    tree.insert(env, lineStr);
                }else{
                    com.vividsolutions.jts.geom.Point point=factory.createPoint(coor_arr[0]);
                    Envelope env=point.getEnvelopeInternal();
                    tree.insert(env, point);
                }
            }
        }
        tree.build();
        System.out.println("R树索引创建成功！");
        return tree;
    }
    /**
     * R树查询
     * @param tree
     * @param searchGeo
     * @return
     */
    public static List<Geometry> query(STRtree tree,Geometry searchGeo){
        List <Geometry> result=new ArrayList<>();
        @SuppressWarnings("rawtypes")
        List list=tree.query(searchGeo.getEnvelopeInternal());
        for(int i=0;i<list.size();i++){
            Geometry lineStr=(Geometry)list.get(i);
            if(lineStr.intersects(searchGeo)){
                result.add(lineStr);
            }
        }
        return result;
    }
    //根据两点生成矩形搜索框
    public static Geometry generateSearchGeo(double left_top_x,double left_top_y,double right_bottom_x,double right_bottom_y){
        Coordinate[] coors=new Coordinate[4];
        coors[0]=new Coordinate(left_top_x, left_top_y);
        coors[1]=new Coordinate(right_bottom_x, left_top_y);
        coors[2]=new Coordinate(left_top_x, right_bottom_y);
        coors[3]=new Coordinate(right_bottom_x, right_bottom_y);
        LinearRing ring=new LinearRing(new CoordinateArraySequence(coors),new GeometryFactory());
        return ring;
    }

}

common.properties：

#两点间最大间隔(经纬度差值，目前按照江的宽度)
maxGeoRange=0.002
#maxGeoRange=0.012
#两点间最小间隔(经纬度差值，目前按照地图上一栋楼的宽度)
minGeoRange=0.0005
#minGeoRange=0.0017
#武汉市外包矩形的范围
#左上角
left-top=113.702282,31.36127
#左下角
left-bottom=113.702282,29.969079
#右上角
right-top=115.082574,31.36127
#右下角
right-bottom=115.082574,29.969079
#设定的网格的行数
rows=10
#设定的网格的列数
cols=10
#坐标保留小数点后几位
CoorAbs=10000

GPSPoint.java：

package entity;

import java.util.Date;

/**
 * 点，描述点的位置，所属网格和所属线条
 * @author KingWang
 *
 */
public class GPSPoint extends Point{
    private Date date=new Date();
    private Grid grid=new Grid();
    private Line line=new Line();

    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    public Grid getGrid() {
        return grid;
    }
    public void setGrid(Grid grid) {
        this.grid = grid;
    }
    public Line getLine() {
        return line;
    }
    public void setLine(Line line) {
        this.line = line;
    }

}

Grid.java：

package entity;

import java.util.HashSet;

public class Grid {
    private int index=0;
    private int col=0;
    private int row=0;
    private Point lefttop=new Point();
    private Point rightbottom=new Point();
    private HashSet<Line> set=new HashSet<>();
    public int getIndex() {
        return index;
    }
    public void setIndex(int index) {
        this.index = index;
    }
    public int getCol() {
        return col;
    }
    public void setCol(int col) {
        this.col = col;
    }
    public int getRow() {
        return row;
    }
    public void setRow(int row) {
        this.row = row;
    }
    public Point getLefttop() {
        return lefttop;
    }
    public void setLefttop(Point lefttop) {
        this.lefttop = lefttop;
    }
    public Point getRightbottom() {
        return rightbottom;
    }
    public void setRightbottom(Point rightbottom) {
        this.rightbottom = rightbottom;
    }
    public HashSet<Line> getSet() {
        return set;
    }
    public void setSet(HashSet<Line> set) {
        this.set = set;
    }
    public void addLine(Line line){
        this.set.add(line);
    }
}

Line.java：

package entity;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;

import config.GeoConfig;
import util.SpatialUtil;
/**
 * 线，点串，描述整条轨迹
 * @author KingWang
 *
 */
public class Line {
    /**
     * 轨迹的id
     */
    private String id="";
    /**
     * 按照顺序存储点轨迹
     */
    private List<GPSPoint> coors=new ArrayList<>();
    /**
     * 经过的网格，按照轨迹顺序存储
     */
    private List<Grid> grids=new ArrayList<>();

    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public List<GPSPoint> getCoors() {
        return coors;
    }
    public void setCoors(List<GPSPoint> coors) {
        this.coors = coors;
    }
    public List<Grid> getGrids() {
        return grids;
    }
    public void setGrids(List<Grid> grids) {
        this.grids = grids;
    }
    public void addPoint(GPSPoint p){
        this.coors.add(p);
    }

    public void removePoint(int index){
        this.coors.remove(index);
    }

    public Line sort(boolean isTimeAsc){
        List<GPSPoint> list=this.getCoors();
        Collections.sort(list, (point1,point2)->{
            if(point1.getDate().after(point2.getDate())){
                if(isTimeAsc){
                    return 1;
                }else{
                    return -1;
                }
            }else{
                if(isTimeAsc){
                    return -1;
                }else{
                    return 1;
                }
            }
        });
        return this;
    }
    /**
     * 对线坐标串进行粗处理,太密的点删掉，太远的点打断成两段
     * @param config
     * @return
     */
    public List<Line> filter(GeoConfig config){
        List<Line> resultList=new ArrayList<>();
        List<GPSPoint> list=new CopyOnWriteArrayList<>(this.getCoors());
        Point lastPt=new Point();
        int i=0;
        int lastCutIndex=0;
        for(GPSPoint point:list){
            if(i>0&&SpatialUtil.inTolerance(lastPt,point,config)==CompareValue.GT){
                List<GPSPoint> list_temp=new ArrayList<>();
                list_temp.addAll(list.subList(lastCutIndex, i));
                Line line_temp=new Line();
                line_temp.setCoors(list_temp);
                line_temp.setId(String.valueOf(System.currentTimeMillis()+new Random().nextInt(10)));
                resultList.add(line_temp);
                lastCutIndex=i;
            }else if(i>0&&SpatialUtil.inTolerance(lastPt, point, config)==CompareValue.LT){
                list.remove(i);
                i--;
            }
            lastPt=point;
            i++;
        }
        if(lastCutIndex==i){
            Line line_temp=new Line();
            line_temp.setCoors(this.getCoors());
            line_temp.setId(String.valueOf(System.currentTimeMillis()+new Random().nextInt(10)));
            resultList.add(line_temp);
        }else{
            List<GPSPoint> list_temp=new ArrayList<>();
            list_temp.addAll(list.subList(lastCutIndex, i));
            Line line_temp=new Line();
            line_temp.setCoors(list_temp);
            line_temp.setId(String.valueOf(System.currentTimeMillis()+new Random().nextInt(10)));
            resultList.add(line_temp);
        }
        return resultList;
    }
}

Point.java：

package entity;

import config.GeoConfig;

/**
 * 点，描述点的位置
 * @author KingWang
 *
 */
public class Point {
    private double x=0.0;
    private double y=0.0;

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }
}

注：

这里需要用到求解空间拓扑关系的函数。

具体参考博主另外一篇文章关于拓扑关系的测试。

JTS拓扑关系测试

KingWang_WHU
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
jts-core-1.17_en.chm
09-11
org.locationtech.jts:jts-core 1.17.1 API JTS(Java Topology Suite)拓扑套件.一套开放源码的 Java API。它提供了一套空间数据操作的核心算法。 (关于locationtech和vividsolutions:locationtech(持续更新中 1.15-1.17); 和vividsolutions(DEC,2012后停更 1.8-1.13); 前者是新版本所采用的JTS，后者是老版本采用的JTS
通过JTS源码分析Rtree(未完待续)
weixin_30337157的博客
03-30 157
前言 R树在数据库等领域做出的功绩是非常显著的。它很好的解决了在高维空间搜索等问题。它把B树的思想很好的扩展到了多维空间，采用了B树分割空间的思想，并在添加、删除操作时采用合并、分解结点的方法，保证树的平衡性。 因此，R树就是一棵用来存储高维数据的平衡树。 rtree的好处 例如我想查找公司附近查找20英里以内所有的餐厅。 如果没有R树你会怎么解决？一般情况下我...
探索地理空间数据的神器：JTS
最新发布
gitblog_00069的博客
03-24 303
探索地理空间数据的神器：JTS 项目地址:https://gitcode.com/locationtech/jts JTS 是一个强大的开源Java库，全称是Java Topology Suite，它专注于处理几何对象和执行复杂的地理空间操作。这个项目由LocationTech维护，旨在为开发人员提供一套全面的工具，帮助他们在地理信息系统（GIS）中构建高效且精确的应用程序。 技术分析 JTS 提...
JTS中文文档及相关工具汇总
08-12
JTS官方开发指南中文翻译版.doc JAVA-JTS中文文档-图文.doc JTS Developer Guide.pdf JAVA事务处理拓扑套件-开发者指南（完 jts-1.14.zip jts-master.zip
VirtualStringTree使用实例
01-12
VirtualStringTree使用实例， 自己做的练习
JAVA-JTS中文文档-图文.doc
09-03
Java事务服务拓扑套件-开发者指南
矢量数据空间索引之R树索引
XiaoCai
05-17 3587
R 树利用空间实体外接矩形建立空间索引。R 树空间索引建立每个实体的外接矩形(rectangles,R)，通过外接矩形的最大、最小坐标检索空间实体。对这些虚拟矩形建立空间索引，设计虚拟的矩形目录，将空间对象包含它含在矩形内，以虚拟矩形为空间索引，它包含指向所包围的空间实体的指针。为提高检索效率，R 树空间索引还将空间位置相近的实体外接矩形重新组织为更大的虚拟矩形，形成多级空间索引。 R 树空间索引就是按包含实体的矩形来确定的，树的层次表达了分辨率信息，每个实体与R 树结点相联系，这点与四叉树相同。矩形数据结
【地理空间】JTS构建R树索引
TcCookEgg的博客
07-22 1086
空间索引（Spatial Indexing） 回忆下数据库最基本的操作：增删改查以及稍复杂些的比如连接操作，基本都需要先锁定数据位置，再执行操作。而定位这个步骤，如果没有index，基本都是O(n)的时间复杂度，这是一个非常“耗时”的操作。“找”这个操作就需要定位。注意这里的定位不再是指在存储器上的位置，而是在空间中的位置，这里的空间，是由数据的维度张成的空间。空间数据，也即是这些拥有多维度的数据。这是空间数据的一个比较延展性的说法。但通常，空间数据都focus on 几何类型数据，比如点，线，面，球等，
shapely 笔记：STR TREE
qq_40206371的博客
02-20 1172
使用Sort-Tile-Recursive (STR) 算法创建的仅查询的R-tree空间索引该树索引每个几何图形的边界框。树在初始化时直接构建，且一旦创建后不能添加或移除节点所有操作返回输入几何图形的索引边界框限于二维并且是轴对齐的几何图形中存在的任何Z值在树内索引时都会被忽略。
STRtree空间数据处理-java笔记
qiaobing1226的博客
12-21 2249
Geometry 笔记
如何使用JAVA语言构建R树索引并提供查询的例子
热门推荐
夜郎King的博客
07-17 4万+
1、背景 在最近的工作当中，需要在空间中找到指定范围的目标点。由此想到了R树索引，利用R树索引进行高性能查询，将返回指定范围内的经纬度坐标点。大致的方向已明确，便开始寻找相关实现。通过在互联网上查找资料，已经有开源的JTS工具包可进行相关的索引构建工作，并提供查询功能。本文由此简单的说明如何利用jts进行相关操作。 2、相关代码 2.1索引的构建，具体代码如下： STR......
JTS官方技术规范中文翻译版
11-11
JTS拓扑结构程序组是一个通过使用明确的精度模型和健壮的几何算法来执行空间数据操作的Java应用编程孔。JTS是用来对可以支持空间数据集的确认、处理、综合及质疑的应用程序进行改善。这篇文献就是对在JTS拓扑程序组中执行的类、方法与算法进行说明。 JTS试图尽可能精确地执行开放式地理信息系统GIS中的简单要素实现规范（SFS）。在一些情况下，SFS是不清晰的，或者是遗漏了某个规范。在这种情况下，JTS试图选择一个合理的相容的替代物。SFS的不同之处与其细节之处都将会在这个说明书中论述到。有关等级与方法的详细文献将会以Java文件的形式出现，作为原始资料代码。
jts-1.13-API文档-中文版.zip
07-12
赠送jar包：jts-1.13.jar； 赠送原API文档：jts-1.13-javadoc.jar； 赠送源代码：jts-1.13-sources.jar； 赠送Maven依赖信息文件：jts-1.13.pom； 包含翻译后的API文档：jts-1.13-javadoc-API文档-中文(简体)版.zip； Maven坐标：com.vividsolutions:jts:1.13； 标签：vividsolutions、jts、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
JTS-1.14.0
08-25
JTS1.14版本 jar包
R树空间索引详解
06-11
R-Tree: Spatial Representation on a Dynamic-Index Structure
JTS-SpatialIndex空间索引使用说明（十五）
鸟语清晨
04-13 1402
org.locationtech.jts.index 使用说明 SpatialIndex 说明 空间索引算法使用说明 类关系图 实现类说明 STRtree 文档下载Download PDF. Quadtree 四叉树 HPRtree 操作示例 通过构建索引，查询黄色框内对应的线，分析三种空间索引准确性与耗时 package com.leokok.jts.learning.jts.core.index; import com.alibaba.fastjson.JSON; import co
jts-1.13中的bug分析
u011993637的博客
01-21 414
jts-1.13中的bug分析 在使用jts的STRtree时，由于项目需要，需要向索引中添加数据，还会删除数据，在使用STRtree的过程中，发现无法删除数据！代码如下： STRtree stRtree = new STRtree(); stRtree.insert(envelope, geom1); stRtree.remove(envelope, geom1); 鉴于对jts的敬畏之心，首先...
JTS-Java图形拓扑学习笔记
java、c++、机器学习方向King
07-07 2055
请注意，KD树的结构取决于插入点的顺序。当基站数量在二个以上时，全平面会划分为多个包罗一个基站的区域，区域中任何一点都与本区域内基站间隔最近，是以这些个区域可以看作是基站的覆盖区域，我们将这种由多个点将平面划分成的图称为泰森多边形，又称为Voronoi 图。JTS由加拿大的VividSolutions公司开发，是一个用Java语言描述的几何拓扑套件，遵循OpenGIS的Simple Feature Specification，封装了2D几何类型和非常多的空间分析操作，而且包含了不少常见的计算几何算法实现。
GIS算法：6_JAVA拓扑套件JTS
吴道简的博客
06-11 1120
常用可以用于GIS数据处理和空间计算的java包有geotool和jts。 相对来说，geotool功能更全面，还可以用于数据转换、瓦片地图发布、栅格影像分析等，jts只能进行基本的数据处理和空间计算。 但大多数情况下jts就完全够用了。 geotool的官网：https://www.geotools.org/ 本例只讲jts的用法： maven依赖： <dependency> <groupId>com.vividsolutions</groupId&g.
jts 1.14 zip
08-25
JTS 1.14 Zip是JTS（Java Topology Suite）的一个版本。JTS是一个开源的Java库，用于处理和分析二维地理位置数据。它提供了一套丰富的功能，包括点、线、面等几何对象的创建、编辑和查询。 JTS 1.14 Zip是指JTS版本1.14的压缩文件。压缩文件是为了在电子设备上存储和传输数据而压缩成的一种文件格式。通过将文件中的数据进行压缩，可以减小文件的大小，从而提高文件的传输速度和存储效率。 JTS 1.14 Zip中包含了JTS 1.14版本的代码和相关的资源文件。用户可以通过下载和解压缩这个压缩文件，获得JTS 1.14版本的库文件和各种示例、文档等资源。这样，用户就可以在自己的Java项目中使用JTS 1.14版本提供的功能和特性。 JTS 1.14是JTS库的一个特定版本，它可能包含了新的功能、bug修复和改进。通过升级到最新版本，用户可以获得更好的性能、更丰富的功能和更稳定的使用体验。 总之，JTS 1.14 Zip是JTS 1.14版本的压缩文件，通过下载和解压缩这个文件，用户可以获得JTS库的最新版本，从而在自己的Java项目中使用最新的地理位置数据处理和分析功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值