java代码如何对geojson文件数据抽稀

Question

geojson文件太大了，java代码如何对geojson文件数据抽稀

GPT回答就算了，代码能不能运行难道不验证一下吗。。

Answer 1

• 这篇文章讲的很详细，请看：java根据一个完整的geojson文件，根据图层名称导出单个图层的geojson文件
• 除此之外, 这篇博客: java实现geojson格式数据与shp文件相互转换中的 java实现geojson格式数据与shp文件相互转换 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• package com.zimax.zplan.admin.util;
  
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONArray;
  import com.alibaba.fastjson.JSONObject;
  import com.vividsolutions.jts.geom.*;
  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.data.simple.SimpleFeatureCollection;
  import org.geotools.data.simple.SimpleFeatureIterator;
  import org.geotools.data.simple.SimpleFeatureSource;
  import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
  import org.geotools.geojson.feature.FeatureJSON;
  import org.geotools.geojson.geom.GeometryJSON;
  import org.geotools.referencing.crs.DefaultGeographicCRS;
  import org.opengis.feature.simple.SimpleFeature;
  import org.opengis.feature.simple.SimpleFeatureType;
  
  import java.io.*;
  import java.nio.charset.Charset;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  
  public class ShpToGeojson {
      /**
       * geojson转换为shp文件
       *
       * @param
       * @param shpPath
       * @return
       */
      public Map geojson2Shape(String jsonPath, String shpPath) {
          Map map = new HashMap();
          GeometryJSON gjson = new GeometryJSON();
          try {
              // 读文件到Stringbuffer
              StringBuffer sb = new StringBuffer();
              BufferedReader br = null;
              try {
                  br = new BufferedReader(new FileReader(jsonPath));
                  String str;
                  while ((str = br.readLine()) != null) {// 逐行读取
                      sb.append(str + "\r\n");
                  }
                  br.close();
              } catch (Exception e) {
                  System.out.println(e.getMessage());
              }
              JSONObject json = JSONObject.parseObject(sb.toString());
  //            JSONObject json = JSONObject.fromObject(sb.toString());
              JSONArray features = (JSONArray) json.get("features");
              JSONObject feature0 = JSONObject.parseObject(features.get(0).toString());
              // 获取属性名称
              Set properties = JSONObject.parseObject(feature0.getString("properties")).keySet();
              String strType = ((JSONObject) feature0.get("geometry")).getString("type").toString();
  
              Class<?> geoType = null;
              switch (strType) {
              case "Point":
                  geoType = Point.class;
                  break;
              case "MultiPoint":
                  geoType = MultiPoint.class;
                  break;
              case "LineString":
                  geoType = LineString.class;
                  break;
              case "MultiLineString":
                  geoType = MultiLineString.class;
                  break;
              case "Polygon":
                  geoType = Polygon.class;
                  break;
              case "MultiPolygon":
                  geoType = MultiPolygon.class;
                  break;
              }
              // 创建shape文件对象
              File file = new File(shpPath);
              Map<String, Serializable> params = new HashMap<String, Serializable>();
              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");
              tb.add("the_geom", geoType);// 类型，Point/MultiPoint/LineString/MultiLineString/Polygon/MultiPolygon
              Iterator propertiesIter = properties.iterator();
              // 设置属性
              while (propertiesIter.hasNext()) {
                  String str = propertiesIter.next().toString();
                  tb.add(str, String.class);// 此处设置为string，如需修改请自行改写代码
              }
  
              ds.createSchema(tb.buildFeatureType());
              // 设置编码
              Charset charset = Charset.forName("GBK");
              ds.setCharset(charset);
              // 设置Writer
              FeatureWriter<SimpleFeatureType, SimpleFeature> writer = ds.getFeatureWriter(ds.getTypeNames()[0],
                      Transaction.AUTO_COMMIT);
  
              for (int i = 0, len = features.size(); i < len; i++) {
                  String strFeature = features.get(i).toString();
                  Reader reader = new StringReader(strFeature);
                  SimpleFeature feature = writer.next();
                  switch (strType) {
                  case "Point":
                      feature.setAttribute("the_geom", gjson.readPoint(reader));
                      break;
                  case "MultiPoint":
                      feature.setAttribute("the_geom", gjson.readMultiPoint(reader));
                      break;
                  case "LineString":
                      feature.setAttribute("the_geom", gjson.readLine(reader));
                      break;
                  case "MultiLineString":
                      feature.setAttribute("the_geom", gjson.readMultiLine(reader));
                      break;
                  case "Polygon":
                      feature.setAttribute("the_geom", gjson.readPolygon(reader));
                      break;
                  case "MultiPolygon":
                      feature.setAttribute("the_geom", gjson.readMultiPolygon(reader));
                      break;
                  }
                  Iterator propertiesset = properties.iterator();
                  while (propertiesset.hasNext()) {
                      String str = propertiesset.next().toString();
                      JSONObject featurei = JSONObject.parseObject(features.get(i).toString());
                      feature.setAttribute(str, JSONObject.parseObject(featurei.getString("properties")).get(str));
                  }
                  writer.write();
              }
              writer.close();
              ds.dispose();
              map.put("status", "success");
              map.put("message", shpPath);
          } catch (Exception e) {
              map.put("status", "failure");
              map.put("message", e.getMessage());
              e.printStackTrace();
          }
          return map;
      }
  
      /**
       * shp文件转换geojson数据
       * @param shpPath
       * @return
       */
      public static Object shp2geojson(String shpPath)
      {
          Map map = new HashMap();
          //新建json对象
          FeatureJSON fjson = new FeatureJSON();
          JSONObject geojsonObject=new JSONObject();
          geojsonObject.put("type","FeatureCollection");
          try{
              //获取featurecollection
              File file = new File(shpPath);
              ShapefileDataStore shpDataStore = null;
              shpDataStore = new ShapefileDataStore(file.toURL());
              //设置编码
  /*            Charset charset = Charset.forName("GBK");
              shpDataStore.setCharset(charset);*/
              String typeName = shpDataStore.getTypeNames()[0];
              SimpleFeatureSource featureSource = null;
              featureSource =  shpDataStore.getFeatureSource (typeName);
              SimpleFeatureCollection result = featureSource.getFeatures();
              SimpleFeatureIterator itertor = result.features();
              JSONArray array = new JSONArray();
              //遍历feature转为json对象
              while (itertor.hasNext())
              {
                  SimpleFeature feature = itertor.next();
                  StringWriter writer = new StringWriter();
                  fjson.writeFeature(feature, writer);
                  String temp=writer.toString();
                  Object geometry = JSONObject.parseObject(temp).getString("geometry");
                  byte[] b=temp.getBytes("iso8859-1");
                  temp=new String(b,"gbk");
                  JSONObject json =  JSON.parseObject(temp);
                  array.add(geometry);
              }
              itertor.close();
              return array;
  //            geojsonObject.put("features",array);
  //            itertor.close();
  
  //            long startTime=System.currentTimeMillis();
  
              //将json字符串使用字符流写入文件
  /*            File outputfile=new File(jsonPath);
              BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter(outputfile));
              bufferedWriter.write(JSON.toJSONString(geojsonObject));
              bufferedWriter.flush();
              bufferedWriter.close();*/
  //            File outputfile=new File(jsonPath);
  //            FileOutputStream fileOutputStream=new FileOutputStream(outputfile);
  //            OutputStreamWriter outputStreamWriter=new OutputStreamWriter(fileOutputStream,"utf-8");
  //            outputStreamWriter.write(JSON.toJSONString(geojsonObject));
  //            outputStreamWriter.flush();
  //            outputStreamWriter.close();
  
              //将json字符串使用字节流写入文件
  /*            File outputfile=new File(jsonPath);
              BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream(outputfile));
              byte[] bytes= JSON.toJSONString(geojsonObject).getBytes("utf-8");
              bufferedOutputStream.write(bytes);
              //fileOutputStream.write(JSON.toJSONString(geojsonObject));
              bufferedOutputStream.flush();
              bufferedOutputStream.close();*/
  
  //            long endTime=System.currentTimeMillis();
  //            System.out.println("当前程序耗时："+(endTime-startTime)+"ms");
          }
          catch(Exception e){
              map.put("status", "failure");
              map.put("message", e.getMessage());
              e.printStackTrace();
  
          }
  //
          return geojsonObject;
      }
  
      /**
       * 工具类测试方法
       *
       * @param args
       */
      public static void main(String[] args) {
          ShpToGeojson shpToGeojson = new ShpToGeojson();
          long start = System.currentTimeMillis();
          // shape2Geojson
  //      String shpPath = "D:/geojsonTest/gaosu.shp";
  //      String jsonPath = "D:/geojsonTest/gaosu.geojson1";
  //      Map map = fileFormat.shape2Geojson(shpPath, jsonPath);
  
          // geojson2Shape
          String shpPath = "D:/矢量下载/123.shp";
          String jsonPath = "D:/123.geojson";
          Map map = shpToGeojson.geojson2Shape(jsonPath, shpPath);
  
          System.out.println(shpPath +" "+ jsonPath + ",共耗时" + (System.currentTimeMillis() - start) + "ms");
      }
  }
  

• 以下回答由chatgpt基于相关博客总结生成:

  我可以根据以下步骤使用Java代码对geojson文件进行抽稀：

  1. 导入所需依赖库，包括geojson-jackson、jts-core等，以便进行geojson文件的解析和处理。

  2. 使用java.io.File类读取待处理的geojson文件，并将其转化为FeatureCollection对象，如下所示：

  File file = new File("path/to/geojson/file");
  FeatureCollection features = (FeatureCollection) new ObjectMapper().readValue(file, GeoJson.class);
  

  1. 对FeatureCollection对象进行抽稀操作，可以使用jts-simplify库和jts-geojson库来实现。具体步骤如下：

  3.1 将FeatureCollection对象中的每一个Feature对象转换为JtsGeometry对象，例如将Polygon对象转换为MultiPolygon对象：

  GeometryFactory geometryFactory = new GeometryFactory();
  List<Geometry> geometries = new ArrayList<>();
  for (Feature feature : features) {
      JtsSpatialContext geoContext = JtsSpatialContext.GEO;
      Geometry geometry = geoContext.read(feature.getGeometry().toString());
      // 将Polygon转化为MultiPolygon
      if (geometry instanceof Polygon) {
          geometry = geometryFactory.createMultiPolygon(new Polygon[]{(Polygon) geometry});
      }
      geometries.add(geometry);
  }
  

  3.2 将JtsGeometry对象进行抽稀操作，这里使用DouglasPeuckerSimplifier对象来实现：

  double distanceTolerance = 0.001; // 设置抽稀距离阈值
  List<Geometry> simplified = new ArrayList<>();
  for (Geometry geometry : geometries) {
      Geometry simplifiedGeometry = DouglasPeuckerSimplifier.simplify(geometry, distanceTolerance);
      simplified.add(simplifiedGeometry);
  }
  

  3.3 将抽稀后的JtsGeometry对象转换为Feature对象，并构建新的FeatureCollection对象：

  FeatureCollection simplifiedFeatures = new FeatureCollection();
  for (Geometry geometry : simplified) {
      WKTWriter wktWriter = new WKTWriter();
      Feature feature = new Feature();
      feature.setGeometry(wktWriter.write(geometry));
      simplifiedFeatures.add(feature);
  }
  

  1. 将抽稀后的FeatureCollection对象转换为geojson格式的字符串，并写入到新的文件中：

  String simplifiedGeoJson = new ObjectMapper().writeValueAsString(simplifiedFeatures);
  File outFile = new File("path/to/output/file");
  FileUtils.writeStringToFile(outFile, simplifiedGeoJson, StandardCharsets.UTF_8);
  

  需要注意的是，抽稀距离阈值需要根据实际情况进行调整，以确保抽稀后的结果在视觉上仍然保持足够的精度。