Java使用geotools将Geometry(地图要素)导出为shp文件

最新推荐文章于 2024-04-27 17:30:34 发布
最新推荐文章于 2024-04-27 17:30:34 发布
阅读量3.5k 收藏 15
点赞数 2
分类专栏： geotools java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38951418/article/details/124494755
版权

        做图形方面的功能，往往会遇到将地图要素导出成shap文件的需求，现整理记录一下方便后期直接使用。

1、需要用到的依赖

        <geotools.version>20.5</geotools.version>
        <!--jts版本跟geotools相匹配，20.x后的需要1.16版本-->
        <jts.version>1.16.1</jts.version>

        <!-- geotools start -->
        <dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-main</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-referencing</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-api</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-opengis</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-metadata</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-geometry</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-coverage</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-cql</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-data</artifactId>
			<version>${geotools.version}</version>
		</dependency>
        <dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-epsg-wkt</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-jdbc</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools.jdbc</groupId>
			<artifactId>gt-jdbc-postgis</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-shapefile</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-geojson</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>com.googlecode.json-simple</groupId>
			<artifactId>json-simple</artifactId>
			<version>1.1.1</version>
		</dependency>
		<dependency>
			<groupId>org.geotools</groupId>
			<artifactId>gt-swing</artifactId>
			<version>${geotools.version}</version>
		</dependency>
		<dependency>
			<groupId>org.locationtech.jts</groupId>
			<artifactId>jts-core</artifactId>
			<version>1.16.1</version>
		</dependency>
		 <!-- geotools end -->

2、工具类

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.Serializable;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import org.geotools.data.FeatureWriter;
import org.geotools.data.Transaction;
import org.geotools.data.shapefile.ShapefileDataStore;
import org.geotools.data.shapefile.ShapefileDataStoreFactory;
import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
import org.geotools.referencing.CRS;
import org.geotools.referencing.crs.DefaultGeographicCRS;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.LineString;
import org.locationtech.jts.geom.MultiLineString;
import org.locationtech.jts.geom.MultiPoint;
import org.locationtech.jts.geom.MultiPolygon;
import org.locationtech.jts.geom.Point;
import org.locationtech.jts.geom.Polygon;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
 
public class ShapeUtil {
 
    /**
     * 生成shape文件
     *
     * @param shpPath 生成shape文件路径（包含文件名称）
     * @param encode  编码
     * @param geoType 图幅类型，Point和Rolygon
     * @param geoms   图幅集合
     */
    public static void write2Shape(String shpPath, String encode, String geoType, List<Geometry> geoms) {
        try {
            //创建shape文件对象
            File file = new File(shpPath);
            Map<String, Serializable> params = new HashMap<>();
            params.put(ShapefileDataStoreFactory.URLP.key, file.toURI().toURL());
            ShapefileDataStore ds = (ShapefileDataStore) new ShapefileDataStoreFactory().createNewDataStore(params);
            //定义图形信息和属性信息
            SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
            /**
             *  //方式一
             *	CRS.decode("EPSG:4326");
             *  //方式二
             *	DefaultGeographicCRS.WGS84;
             *
             *  EPSG:4490为大地坐标系_国家2000大地坐标系CGCS2000
             *  EPSG:4326支持一种默认的定义方式, 坐标系WGS84
             */
            tb.setCRS(CRS.decode("EPSG:4490"));
            
            tb.setName("shapefile");
 
            if ("Polygon".equals(geoType) || "polygon".equals(geoType)) {
                tb.add("the_geom", Polygon.class);
            } else if ("MultiPolygon".equals(geoType)) {
                tb.add("the_geom", MultiPolygon.class);
            } else if ("Point".equals(geoType) || "point".equals(geoType)) {
                tb.add("the_geom", Point.class);
            } else if ("MultiPoint".equals(geoType)) {
                tb.add("the_geom", MultiPoint.class);
            } else if ("LineString".equals(geoType)) {
                tb.add("the_geom", LineString.class);
            } else if ("MultiLineString".equals(geoType) || "Polyline".equals(geoType) || "polyline".equals(geoType)) {
                tb.add("the_geom", MultiLineString.class);
            } else {
                throw new Exception("Geometry中没有该类型：" + geoType);
            }
 
            ds.createSchema(tb.buildFeatureType());
            //设置编码
            Charset charset = Charset.forName(encode);
            ds.setCharset(charset);
            //设置Writer
            FeatureWriter<SimpleFeatureType, SimpleFeature> writer = ds.getFeatureWriter(ds.getTypeNames()[0], Transaction.AUTO_COMMIT);
            for (Geometry geom : geoms) {
                //String type = geom.getGeometryType();
 
                //写下一条
                SimpleFeature feature = writer.next();
 
                feature.setAttribute("the_geom", geom);
            }
            writer.write();
            writer.close();
            ds.dispose();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 生成shape文件
     *
     * @param shpPath  生成shape文件路径（包含文件名称）
     * @param encode   编码
     * @param geoType  图幅类型，Point和Rolygon
     * @param shpKey   data中图幅的key
     * @param attrKeys 属性key集合
     * @param data     图幅和属性集合
     */
    public static void write2Shape(String shpPath, String encode, String geoType, String shpKey, List<String> attrKeys, List<Map<String, Object>> data) {
        try {
            if (data == null || data.size() == 0) {
                return;
            }
            //创建shape文件对象
            File file = new File(shpPath);
            Map<String, Serializable> params = new HashMap<>();
            params.put(ShapefileDataStoreFactory.URLP.key, file.toURI().toURL());
            ShapefileDataStore ds = (ShapefileDataStore) new ShapefileDataStoreFactory().createNewDataStore(params);
 
            //定义图形信息和属性信息
            SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
            tb.setCRS(DefaultGeographicCRS.WGS84);
            tb.setName("shapefile");
 
            if ("Polygon".equals(geoType)) {
                tb.add("the_geom", Polygon.class);
            } else if ("MultiPolygon".equals(geoType)) {
                tb.add("the_geom", MultiPolygon.class);
            } else if ("Point".equals(geoType)) {
                tb.add("the_geom", Point.class);
            } else if ("MultiPoint".equals(geoType)) {
                tb.add("the_geom", MultiPoint.class);
            } else if ("LineString".equals(geoType)) {
                tb.add("the_geom", LineString.class);
            } else if ("MultiLineString".equals(geoType)) {
                tb.add("the_geom", MultiLineString.class);
            } else {
                throw new Exception("Geometry中没有该类型：" + geoType);
            }
 
            for (String field : attrKeys) {
                tb.add(field.toUpperCase(), String.class);
            }
 
            ds.createSchema(tb.buildFeatureType());
            //设置编码
            Charset charset = Charset.forName(encode);
            ds.setCharset(charset);
            //设置Writer
            FeatureWriter<SimpleFeatureType, SimpleFeature> writer = ds.getFeatureWriter(ds.getTypeNames()[0], Transaction.AUTO_COMMIT);
            //写入文件信息
            for (int i = 0; i < data.size(); i++) {
                SimpleFeature feature = writer.next();
                Map<String, Object> row = data.get(i);
                Geometry geom = (Geometry) row.get(shpKey);
                feature.setAttribute("the_geom", geom);
                for (String key : row.keySet()) {
                    if (!key.equals(shpKey)) {
                        if (row.get(key) != null) {
                            feature.setAttribute(key.toUpperCase(), row.get(key).toString());
                        } else {
                            feature.setAttribute(key.toUpperCase(), "");
                        }
                    }
                }
            }
            writer.write();
            writer.close();
            ds.dispose();
 
            //添加到压缩文件
            //zipShapeFile(shpPath);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
 
    /**
     * 压缩shape文件
     *
     * @param shpPath shape文件路径（包含shape文件名称）
     */
    public static void zipShapeFile(String shpPath) {
        try {
            File shpFile = new File(shpPath);
            String shpRoot = shpFile.getParentFile().getPath();
            String shpName = shpFile.getName().substring(0, shpFile.getName().lastIndexOf("."));
 
            String zipPath = shpRoot + File.separator + shpName + ".zip";
            File zipFile = new File(zipPath);
            InputStream input = null;
            ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(zipFile));
            // zip的名称为
            zipOut.setComment(shpName);
            String[] shpFiles = new String[]{
                    shpRoot + File.separator + shpName + ".dbf",
                    shpRoot + File.separator + shpName + ".prj",
                    shpRoot + File.separator + shpName + ".shp",
                    shpRoot + File.separator + shpName + ".shx",
                    shpRoot + File.separator + shpName + ".fix"
            };
 
            for (int i = 0; i < shpFiles.length; i++) {
                File file = new File(shpFiles[i]);
                input = new FileInputStream(file);
                zipOut.putNextEntry(new ZipEntry(file.getName()));
                int temp = 0;
                while ((temp = input.read()) != -1) {
                    zipOut.write(temp);
                }
                input.close();
            }
            zipOut.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

import org.geotools.geojson.geom.GeometryJSON;
import org.geotools.geometry.jts.JTSFactoryFinder;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.io.WKTReader;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

public class GeometryUtil {
	
	/**
     * geometry转geojson
     * @param geometry
     * @return JSONObject
     * @throws IOException
     */
    public static JSONObject toGeoJson(Geometry geometry) {
        try {
            StringWriter sw = new StringWriter();
            // 设置保留6位小数，否则GeometryJSON默认保留4位小数
            GeometryJSON geometryJson = new GeometryJSON(6);
            geometryJson.write(geometry, sw);
            JSONObject geoJson = JSONObject.parseObject(sw.toString());
            sw.close();
            return geoJson;
        }catch(IOException ex){
            ex.printStackTrace();
            return null;
        }
    }
    
    /**
     * geojson转geometry
     * @param geojson
     * @return Geometry
     */
    public static Geometry toGeometry(JSONObject geojson){
        Geometry geometry = null;
        try {
            GeometryJSON geometryJson = new GeometryJSON(6);
            String jsonStr = JSONObject.toJSONString(geojson);
            StringReader sr = new StringReader(jsonStr);
            geometry = geometryJson.read(sr);
            sr.close();
            return geometry;
        }catch(IOException ex){
            ex.printStackTrace();
            return null;
        }
    }
	
    /**
     * 字符串转对象
     * @param wktGeometry
     * @return Geometry
     */
    public static Geometry toGeometry(String wktGeometry){
        try {
            GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory(null);
            WKTReader reader = new WKTReader(geometryFactory);
            Geometry geometry = reader.read(wktGeometry);
            return geometry;
        }catch (Exception ex){
            ex.printStackTrace();
            return null;
        }
    }
    
    public static List<String> arrayListToWktPoint(JSONArray points){
        List<String> strings = new ArrayList<>();
        for (int i=0;i<points.size();i++){
            String result = points.getString(i);
            result = result.substring(0,result.lastIndexOf(",")-1);
            result =  "MULTIPOINT"+result.replace("[","(").replace(","," ")+")";
            strings.add(result);
        }
        return strings;
    }

    public static List<String> arrayListToWktLine(JSONArray lines){
        List<String> strings = new ArrayList<>();
        for (int i=0;i<lines.size();i++){
            String result = lines.getString(i);
            result =  "MULTILINESTRING"+result.replace(","," ").replace(" 0.0] [",",").replace(" 0.0]","]").replace("[","(").replace("]",")");
            strings.add(result);
        }
        return strings;
    }

    public static String shapeToWktPolygon(JSONObject shape){
        String geom = "";
        JSONArray coordinates = shape.getJSONObject("geometry").getJSONArray("coordinates");
        for (int i=0;i<coordinates.size();i++){
            JSONArray zbc = coordinates.getJSONArray(i).getJSONArray(0);
            String zbcstr = "";
            for (int j=0;j<zbc.size();j++){
                JSONArray xy = zbc.getJSONArray(j);
                for (int k=0;k<xy.size();k++){
                    if (k==0){
                        zbcstr += xy.getString(k)+" ";
                    }else if (k==1){
                        zbcstr += xy.getString(k)+",";
                    }
                }
            }
            geom ="MULTIPOLYGON((("+zbcstr.substring(0,zbcstr.lastIndexOf(","))+")))";
        }
        return geom;
    }

	 public static String geomToWkt(Geometry geometry) {
	       String wkt = null;
	       WKTWriter writer = new WKTWriter();
	       wkt = writer.write(geometry);
	       return wkt;
	 }

	 public static Geometry wktToGeom(String wkt) throws ParseException {
	       Geometry geometry = null;
	       WKTReader reader = new WKTReader();
	       geometry = reader.read(wkt);
	       return geometry;
	 }


}
//测试
   public static void main(String[] args) throws Exception {
       
       List<String> list = new ArrayList<>();

       //list.add("POLYGON ((116.21278950384274 39.90557982319698, 116.21177234433465 39.90610963061354, 116.21106912279264 39.90264172209895, 116.21399502548638 39.902612822554126, 116.21629305278306 39.905011479365406, 116.21278950384274 39.90557982319698))");
       //list.add("POLYGON((113.38185597038 34.54828048706,113.38224220848 34.548355588913,113.38249970055 34.548108825684,113.38237095451 34.54787279129,113.38208127594 34.547786960602,113.38185597038 34.54828048706))");
       
       list.add("[116.28338813781738,39.82858807695661,0.0]");
       
       
       List<Geometry> geometryList = new ArrayList<>();
       for (String str : list) {
           Geometry geom = GeometryUtil.wktToGeom(str);
           geometryList.add(geom);
       }
       
       String url = "D:\\attachment\\ZBDC\\ceshi88889999.shp";
       File file = new File(url);
       if (!file.getParentFile().exists()) {
    	   file.getParentFile().mkdirs();
       }
       
       ShapeUtil.write2Shape(url, "utf-8", "Point", geometryList);
       ShapeUtil.zipShapeFile(url);

   }

3、测试结果

 

H早起的鸟
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
使用GEOTools创建空shp文件
SCNU_Arain的博客
07-28 933
在地理信息中最常用的数据就是shp矢量数据，下面介绍使用GEOTools创建shp文件的大概步骤（这里考虑到创建要素的代码繁复，不容易看懂，所以先抽丝剥茧地把新建一个空的SHP文件的原理介绍一下）： 1、设置SHP的文件属性 2、创建一个数据存储空间生成工厂 3、创建一个数据存储空间 4、通过数据存储空间生成带文件属性架构的SHP文件 具体代码如下： import ...
Java拉伸缩放图像
03-16
摘要:Java源码,图形操作,图片拉伸,图像放大 Java拉伸缩放图像，滑动滑块时，图像实时地在相应的方向上拉伸缩放；当单击“Reset”按钮后，则显示原始图像。具体来说是使用java.awt.geom 包中的AffineTransform 类，来实现图像的拉伸缩放。 运行环境：Java/Eclipse
java 使用GeoTools工具 geojson 与shp 相互转换
qiaobing1226的博客
10-31 3049
java 使用GeoTools工具 geojson 与shp 相互转换
Geotools例子2，解析csv文件保存为shp
01-20
前言 本教程包括以下内容： 创建FeatureType，FeatureCollection和Features 使用GeometryFactory建立点 写出一个Shapefile 强制投影 csv文件 创建一个文本文件location.csv，然后将以下位置复制并粘贴到其中： LAT, LON, CITY, NUMBER 46.066667, 11.116667, Trento, 140 44.9441, -93.0852, St Paul, 125 13.752222, 100.493889, Bangkok, 150 45.420833, -75.69, Ottawa, 200 44.98
【GIS系列】GeoTools简介及工具类分享
c18213590220的博客
03-17 1574
本文将从基本概念入手，介绍GeoTools的功能和使用方法，并重点分享一些实用的工具类和技巧，希望能为您在GIS应用开发中提供帮助和启发。
geotools相关jar包集合
07-02
geotools相关的jar包集合，方便大家快速下载，集成到自己的项目。
geotools读取*dbf/*shp文件
03-22
NULL 博文链接：https://javaeye-hua.iteye.com/blog/1009362
shp文件解析java实现
09-03
提供通过meteoInfo+geotools解析shp文件，提取出shp文件中的数据，javaj技术实现，获取边界线数据、中心点坐标、最大、最小经纬度值等
Java使用geotools将Geometry导出为shp文件
杉叔的专栏
04-08 6474
将地图要素导出成shp文件，并且打包的方法。 1、maven依赖 <geotools.version>14.1</geotools.version> <dependency> <groupId>org.geotools</groupId> <artifactId>gt-shapefi...
Java Spring Boot 配置Geotools和GDAL
u011505575的博客
08-11 3691
Java Spring Boot 配置Geotools和GDAL 环境：win10系统 java jdk1.8 一、配置Geotools 仓库网址 https://repo.osgeo.org/#browse/search= 方法1 1、搜索下载需要的相应的包，常用的有 #24-SNAPSHOT版本 org.geotools:gt-main:24-SNAPSHOT org.geotools:gt-geojsondatastore:24-SNAPSHOT org.geotools:gt-shapefile:
geotools将几何相交结果输出shp，并压缩成zip
技术分享
06-04 344
GeoTools是一套操作和显示地图的开源Java 代码库，提供了一系列符合规范的操作地理空间数据的方法，GeoTools被许多项目使用，在地理信息领域有着广泛的应用。
Java使用Geotools将地图元素Geometry导出shp文件
杉叔的专栏
04-15 1588
1、环境版本 序号 类别 版本 1 JDK 1.8 2 Junit 4.13.1 3 Geotools 25.4 4 Collections 3.2.2 2、pom文件编写 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
等值线等值面功能实现.使用技术包括Java+Geotools+WContour+Openlayers
06-04
等值线等值面功能实现.使用技术包括Java+Geotools+WContour+Openlayers
geotools读取shp文件及shp文件操作工具类代码.pdf
04-24
geotools读取shp文件及shp文件操作工具类代码.pdf
java解析上传的shp文件，包含jar，方法，shp文件
07-21
java使用geotools解析shp文件，内容包含 解析方法，使用的各种jar包，以及单区域shp和多区域shp文件
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 971
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 925
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 892
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
geotool 导出shp_JAVA用geotools读取shape格式文件
05-31
要使用 GeoTools 读取 Shape 格式文件，需要进行以下步骤： 1. 导入 GeoTools 依赖包。可以在 Maven 项目中添加以下依赖： ``` <groupId>org.geotools <artifactId>gt-shapefile <version>23.2 ``` 2. 读取 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值