读写shp等空间数据，进行geometry、SimpleFeature等转换的工具类

╰+攻爆jí腚メ 2021-09-22 02:10 802阅读 0赞

直接上代码

import org.geotools.data.*;
    import org.geotools.data.collection.ListFeatureCollection;
    import org.geotools.data.shapefile.ShapefileDataStore;
    import org.geotools.data.shapefile.ShapefileDataStoreFactory;
    import org.geotools.data.simple.SimpleFeatureCollection;
    import org.geotools.data.simple.SimpleFeatureSource;
    import org.geotools.data.simple.SimpleFeatureStore;
    import org.geotools.feature.FeatureCollection;
    import org.geotools.feature.FeatureIterator;
    import org.geotools.feature.simple.SimpleFeatureBuilder;
    import org.geotools.geojson.GeoJSONUtil;
    import org.geotools.geojson.feature.FeatureJSON;
    import org.geotools.geojson.geom.GeometryJSON;
    import org.geotools.referencing.CRS;
    import org.locationtech.jts.geom.*;
    import org.opengis.feature.simple.SimpleFeature;
    import org.opengis.feature.simple.SimpleFeatureType;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import java.io.*;
    import java.nio.charset.StandardCharsets;
    import java.util.*;
    
    public class RwUtils {
        private static Logger logger = LoggerFactory.getLogger(RwUtils.class);
    
        public static List<? extends Geometry> toSimple(List<? extends Geometry> geometryList) {
            List< Geometry> simpleLineList = new ArrayList<>();
            for (Geometry geometry : geometryList) {
                if (geometry instanceof MultiLineString || geometry instanceof MultiPolygon || geometry instanceof MultiPoint) {
                    for (int j = 0; j < geometry.getNumGeometries(); j += 1) {
                        simpleLineList.add(geometry.getGeometryN(j));
                    }
                } else if (geometry instanceof LineString || geometry instanceof Polygon || geometry instanceof Point) {
                    simpleLineList.add(geometry);
                }
            }
            return simpleLineList;
        }
    
        public static List<SimpleFeature> toSimpleFeature(List<SimpleFeature> simpleFeatureList){
            List<SimpleFeature> resultList = new ArrayList<>();
            for (SimpleFeature simpleFeature: simpleFeatureList) {
                Geometry geometry = (Geometry) simpleFeature.getDefaultGeometry();
                if (geometry instanceof MultiLineString || geometry instanceof MultiPolygon || geometry instanceof MultiPoint) {
                    for (int i = 0; i < geometry.getNumGeometries(); i += 1) {
                        SimpleFeature clone = SimpleFeatureBuilder.deep(simpleFeature);
                        clone.setDefaultGeometry(geometry.getGeometryN(i));
                        resultList.add(clone);
                    }
                } else if (geometry instanceof LineString || geometry instanceof Polygon || geometry instanceof Point) {
                    resultList.add(simpleFeature);
                }
            }
            return resultList;
        }
    
    
        public static List<LineString> toSimpleLine(List<? extends Geometry> geometryList) {
            List<LineString> simpleLineList = new ArrayList<>();
            for (Geometry geometry : geometryList) {
                if (geometry instanceof MultiLineString) {
                    for (int j = 0; j < geometry.getNumGeometries(); j += 1) {
                        simpleLineList.add((LineString) geometry.getGeometryN(j));
                    }
                } else if (geometry instanceof LineString) {
                    simpleLineList.add((LineString) geometry);
                }
            }
            return simpleLineList;
        }
    
        public static List<Geometry>  readFeaturesShp(String path){
            List<Geometry> geometryList = new ArrayList<>();
            try {
                File file = new File(path);
                Map<String, Object> map = new HashMap<>();
                map.put("url", file.toURI().toURL());
                DataStore dataStore = DataStoreFinder.getDataStore(map);
                String typeName = dataStore.getTypeNames()[0];
                FeatureSource<SimpleFeatureType, SimpleFeature> source =
                        dataStore.getFeatureSource(typeName);
    //            Filter filter = Filter.INCLUDE; // ECQL.toFilter("BBOX(THE_GEOM, 10,20,30,40)")
                geometryList = new ArrayList<>();
                FeatureCollection<SimpleFeatureType, SimpleFeature> collection = source.getFeatures();
    //            features = collection.features();
    //            dataStore.dispose();
                try (FeatureIterator<SimpleFeature> features = collection.features()) {
                    while (features.hasNext()) {
                        SimpleFeature feature = features.next();
                        Geometry geomrtry = (Geometry)feature.getDefaultGeometry();
                        geometryList.add(geomrtry);
                    }
                    features.close();
                    dataStore.dispose();
                }
            }catch (Exception e){
                System.out.println(e);
            }
    
            return geometryList;
        }
    
        public static List<LineString>  readCenterLineFeaturesShp(String path){
    
            List<Geometry> geometryList = readFeaturesShp(path);
            return toSimpleLine(geometryList);
        }
    
        public static List<Geometry> readGeoJson(String geojsonPath){
            List<Geometry> geometryList = new ArrayList<>();
            InputStreamReader reader = null;
            try{
                reader = new InputStreamReader(new FileInputStream(geojsonPath), "UTF-8");
                FeatureIterator<SimpleFeature> features = new FeatureJSON().streamFeatureCollection(GeoJSONUtil.toReader(reader));
                geometryList = new ArrayList<>();
                while (features.hasNext()) {
                    SimpleFeature feature = features.next();
                    Geometry line = (Geometry) feature.getDefaultGeometry();
                    geometryList.add(line);
                }
    
            }catch (Exception e){
                logger.error("=======================读取异常：" + e);
            }finally {
                try {
                    assert reader != null;
                    reader.close();
                }catch (Exception e){
                    logger.error("=======================读取流关闭异常：" + e);
                }
            }
            return geometryList;
        }
    
    
        public static List<LineString> readCenterLine(String path){
            List<LineString> centerLineList = new ArrayList<>();
            InputStreamReader reader = null;
            try{
                reader = new InputStreamReader(new FileInputStream(path), "UTF-8");
                FeatureIterator<SimpleFeature> features = new FeatureJSON().streamFeatureCollection(GeoJSONUtil.toReader(reader));
                List<Geometry> centerGeomList = new ArrayList<>();
                while (features.hasNext()) {
                    SimpleFeature feature = features.next();
                    Geometry line = (Geometry) feature.getDefaultGeometry();
                    centerGeomList.add(line);
                }
                centerLineList = toSimpleLine(centerGeomList);
            }catch (Exception e){
                logger.error("=======================读取异常：" + e);
            }finally {
                try {
                    assert reader != null;
                    reader.close();
                }catch (Exception e){
                    logger.error("=======================读取流关闭异常：" + e);
                }
            }
            return centerLineList;
        }
    
    
        public static List<SimpleFeature> readCenterLineFeatures(String path){
            List<SimpleFeature> featureList = new ArrayList<>();
            InputStreamReader reader = null;
            try{
                reader = new InputStreamReader(new FileInputStream(path), "UTF-8");
                FeatureIterator<SimpleFeature> features = new FeatureJSON().streamFeatureCollection(GeoJSONUtil.toReader(reader));
                while (features.hasNext()) {
                    SimpleFeature feature = features.next();
                    featureList.add(feature);
                }
            }catch (Exception e){
                logger.error("=======================读取异常：" + e);
            }finally {
                try {
                    assert reader != null;
                    reader.close();
                }catch (Exception e){
                    logger.error("=======================读取流关闭异常：" + e);
                }
            }
            return featureList;
        }
    
    
    
        public static void featureToShp(String path, List<SimpleFeature> outFeatures){
            try {
                FileDataStoreFactorySpi factory = new ShapefileDataStoreFactory();
                File file = new File(path);
                if (file.exists()) {
                    return;
                }
                Map map = Collections.singletonMap("url", file.toURI().toURL());
                ShapefileDataStore dataStore = (ShapefileDataStore)factory.createNewDataStore(map);
                SimpleFeatureType featureType =outFeatures.get(0).getType();
                dataStore.createSchema(featureType);
                dataStore.forceSchemaCRS(CRS.decode("EPSG:3857"));
    
                /*
                 * Write the features to the shapefile
                 */
                Transaction transaction = new DefaultTransaction("create");
    
                String typeName = dataStore.getTypeNames()[0];
                SimpleFeatureSource featureSource = dataStore.getFeatureSource(typeName);
    
                if (featureSource instanceof SimpleFeatureStore) {
                    SimpleFeatureStore featureStore = (SimpleFeatureStore) featureSource;
                    SimpleFeatureCollection collection = new ListFeatureCollection(featureType, outFeatures);
                    featureStore.setTransaction(transaction);
                    try {
                        featureStore.addFeatures(collection);
                        transaction.commit();
                    } catch (Exception problem) {
                        problem.printStackTrace();
                        transaction.rollback();
                    } finally {
                        transaction.close();
                    }
    //                System.exit(0); // success!
                } else {
                    System.out.println(typeName + " does not support read/write access");
    //                System.exit(1);
                }
            }catch (Exception e){
                System.out.println(e);
            }
    
        }
    
    
        public static void featureToGeojson(String path, List<SimpleFeature> outFeatures){
            Writer gjsonWriter = null;
            try{
                File file = new File(path);
                if (file.exists()) {
                    file.delete();
                }
                if (outFeatures.isEmpty()) {
                    return;
                }
                FeatureJSON featureJSON = new FeatureJSON(new GeometryJSON(6));
    //            CoordinateReferenceSystem sourceCRS = CRS.decode("EPSG:3857");
                gjsonWriter = new OutputStreamWriter(new FileOutputStream(singleRoadPath), StandardCharsets.UTF_8);
    //            featureJSON.writeCRS(sourceCRS,gjsonWriter);
                featureJSON.writeFeatureCollection(new ListFeatureCollection(outFeatures.get(0).getType(), outFeatures), gjsonWriter);
    
            }catch (Exception e){
                logger.error("=======================feature写入异常：" + e);
            }finally {
                try{
                    if (gjsonWriter != null) {
                        gjsonWriter.flush();
                        gjsonWriter.close();
                    }
                }catch (IOException ie){
                    logger.error("=======================流关闭异常：" + ie);
                }
            }
        }
        public static List<SimpleFeature> geometrysToGeojson( List<? extends Geometry> lineStringList, String lineType){
            List<SimpleFeature> lineFeatures = new ArrayList<>();
            try {
                SimpleFeatureType type = DataUtilities.createType("line", lineType);
                SimpleFeatureBuilder linefeatureBuilder = new SimpleFeatureBuilder(type);
                linefeatureBuilder.add("id");
                for (int i = 0; i < lineStringList.size(); i++) {
                    Geometry centerLine = lineStringList.get(i);
                    if(centerLine == null){
                        continue;
                    }
    
                    //linefeatureBuilder.set("id", String.valueOf(i));
    
                    SimpleFeature featureLine = linefeatureBuilder.buildFeature(String.valueOf(i));
                    featureLine.setDefaultGeometry(centerLine);
                    featureLine.setAttribute("id",String.valueOf(i));
                    lineFeatures.add(featureLine);
                }
            }catch (Exception e){
                logger.error("异常：" + e);
            }
            return lineFeatures;
        }
    
        public static void geometrysToGeojson(String output, List<? extends Geometry> lineStringList, String lineType){
            List<SimpleFeature> lineFeatures = geometrysToGeojson(lineStringList, lineType);
            featureToGeojson(output, lineFeatures);
        }
    
        public static void geometrysToShp(String output, List<? extends Geometry> lineStringList, String lineType){
            List<SimpleFeature> lineFeatures = geometrysToGeojson(lineStringList, lineType);
            featureToShp(output, lineFeatures);
        }
    
        public static List<LineString> filterLinesByLen(List<LineString> simpleLineList, float filterLen){
            List<LineString> filterLineList = new ArrayList<>();
            for (LineString simpleLine: simpleLineList) {
                if(simpleLine.getLength() >= filterLen){
                    filterLineList.add(simpleLine);
                }
            }
            return filterLineList;
        }
    
    }