JTS自相交处理

自相交一般来说都比较麻烦，会导致面与面 面与线之间做相交，包含等关系时直接报错，这里是将自相交的面拆成两个独立的面，直接上代码

/**
     * 使用jts的两线相交方法解决线的自相交问题
     */
    public static Geometry getPolygonByInteriorPoint(Polygon polygon) {
        IsValidOp isValidOp = new IsValidOp(polygon);
        TopologyValidationError validationError = isValidOp.getValidationError();
        // 如果为空 说明没有自相交的线
        if (validationError == null) {
            return polygon;
        }

        LineString exteriorRing = polygon.getExteriorRing();
        Coordinate[] coordinates = exteriorRing.intersection(exteriorRing).getCoordinates();

        // 使用点集合重新生成面
        Geometry polygon1 = coordinates2Polygon(coordinates);

        // 对内部点进行重新挖空
        int numInteriorRing = polygon.getNumInteriorRing();
        for (int i = 0; i < numInteriorRing; i++) {
            LineString interiorRingN = polygon.getInteriorRingN(i);
            Polygon interiorPolygon = polygon.getFactory().createPolygon(interiorRingN.getCoordinates());
            polygon1 = polygon1.difference(interiorPolygon);
        }
        return polygon1;
    }

    /**
     * 遍历所有的点集合 将他们压如栈中 同时判断栈中是否有相同点 如果有就祛除栈中的点生成局部面
     * 通过这种方式 可以达到遍历一次点 就可以矫正面的线的相交的问题
     * 终极奥义就是 压栈--出栈
     */
    private static Geometry coordinates2Polygon(Coordinate[] coordinates) {
        Geometry resultPolygon = null;
        Stack<Coordinate> coordinateStack = new Stack<>();
        Coordinate lastCoord = null;
        Coordinate nowDouble;
        for (Coordinate coordinate : coordinates) {
            nowDouble = coordinate;
            // 因为传入的点集合 有连续两个点坐标一样的点 这样的点需要提出 没有中间点的两个点怎么能组合成面呢
            if (nowDouble.equals(lastCoord)) {
                continue;
            }
            lastCoord = nowDouble;

            // 判断栈中是否已经包含相同的点 如果有 就可以提取相同点到相同点之间的所有点 组合成局部面
            if (coordinateStack.contains(nowDouble)) {
                List<Coordinate> topoCoords = new ArrayList<>();
                topoCoords.add(nowDouble);
                Coordinate pop;
                do {
                    pop = coordinateStack.pop();
                    topoCoords.add(pop);
                } while (!pop.equals(nowDouble));
                // 将交点再放回栈中
                coordinateStack.push(nowDouble);
                // 生成局部面
                resultPolygon = coordinateToPolygon(resultPolygon, topoCoords);
            } else {
                coordinateStack.push(nowDouble);
            }
        }
        if (coordinateStack.size() > 1) {
            resultPolygon = coordinateToPolygon(resultPolygon, coordinateStack);
        }
        return resultPolygon;
    }

    /**
     * 点组合成面
     */
    private static Geometry coordinateToPolygon(Geometry resultPolygon, List<Coordinate> topoCoords) {
        // 小于四个点的不进行处理 因为组织一个面最少4个点(收尾两个点坐标一致)
        if (topoCoords.size() < 4 || !topoCoords.get(0).equals(topoCoords.get(topoCoords.size() - 1))) {
            return resultPolygon;
        }
        Geometry polygon = geometryFactory.createPolygon(topoCoords.toArray(new Coordinate[]{})).buffer(0);
        if (resultPolygon == null) {
            resultPolygon = polygon;
        } else {
            resultPolygon = resultPolygon.symDifference(polygon);
        }
        return resultPolygon;
    }

这里的结果是MULTIPOLYGON 类型的数据，如果需要独立的POLYGON类型，也可以继续拆

public static List<Geometry> getPolyList(Geometry geometry) {
        List<Geometry> list = new ArrayList<>();
        if(geometry==null){
            return list;
        }

        // 几何类型
        String geometryType = geometry.getGeometryType();

        // Polygon || LineString
        if (geometryType.equals(Geometry.TYPENAME_POLYGON)) {
            list.add(geometry);
        }

        // GeometryCollection || MultiPolygon || MultiLineString
        if (geometryType.equals(Geometry.TYPENAME_GEOMETRYCOLLECTION)
                || geometryType.equals(Geometry.TYPENAME_MULTIPOLYGON)
                || geometryType.equals(Geometry.TYPENAME_MULTILINESTRING)) {
            for (int i = 0; i < geometry.getNumGeometries(); i++) {
                Geometry geometryN = geometry.getGeometryN(i);
                if (geometryN.getGeometryType().equals(Geometry.TYPENAME_POLYGON)) {
                    list.add(geometryN);
                }
            }
        }

        return list;
    }