NetTopologySuite 工具类

using System.Threading;
using System.Collections.Generic;
using GeoAPI.Geometries;
using NetTopologySuite.Geometries;
using NetTopologySuite.Operation.Polygonize;
using System.Linq;

namespace Test.Workspace
{
    public static class NTSExpend
    {
        public static IGeometry Validate(this IGeometry geometry) => NTSUtils.Instance.Validate(geometry);
    }
    public class NTSUtils
    {
        private static NTSUtils _this = null;
        private static object lockObj = new object();

        /// <summary>
        /// 单例创建对象
        /// </summary>
        /// <returns></returns>
        public static NTSUtils Instance
        {
            get
            {
                if (_this == null)
                {
                    lock (lockObj)
                    {
                        if (_this == null)
                            _this = new NTSUtils();
                        return _this;
                    }
                }
                else
                    return _this;
            }
        }

        /// <summary>
        /// 处理图形自相交
        /// </summary>
        /// <returns></returns>
        public IGeometry Validate(IGeometry geometry)
        {
            Polygonizer polygonizer = null;
            if (geometry is Polygon)
            {
                if (geometry.IsValid)
                {
                    geometry.Normalize();
                    return geometry;
                }
                polygonizer = new Polygonizer();

                AddPolygon((Polygon)geometry, polygonizer);
            }
            else if (geometry is MultiPolygon)
            {
                if (geometry.IsValid)
                {
                    geometry.Normalize();
                    return geometry;
                }
                polygonizer = new Polygonizer();
                for (int n = geometry.NumGeometries; n-- > 0;)
                {
                    AddPolygon((Polygon)geometry.GetGeometryN(n), polygonizer);
                }
            }
            else if (geometry is GeometryCollection)
            {
                if (geometry.IsValid)
                {
                    geometry.Normalize();
                    return geometry;
                }
                polygonizer = new Polygonizer();
                for (int n = geometry.NumGeometries; n-- > 0;)
                {
                    IGeometry temp = geometry.GetGeometryN(n);
                    if (temp is Polygon)
                    {
                        AddPolygon((Polygon)temp, polygonizer);
                    }
                    else if (temp is MultiPolygon)
                    {
                        for (int m = temp.NumGeometries; m-- > 0;)
                        {
                            AddPolygon((Polygon)temp.GetGeometryN(m), polygonizer);
                        }
                    }
                }
            }
            else
                return geometry;

            return ToPolygonGeometry(polygonizer.GetPolygons(), geometry.Factory);
        }

        void AddPolygon(Polygon polygon, Polygonizer polygonizer)
        {
            AddLineString(polygon.ExteriorRing, polygonizer);
            for (int n = polygon.NumInteriorRings; n-- > 0;)
            {
                AddLineString(polygon.GetInteriorRingN(n), polygonizer);
            }
        }

        void AddLineString(ILineString lineString, Polygonizer polygonizer)
        {

            if (lineString is LinearRing)
            { // LinearRings are treated differently to line strings : we need a LineString NOT a LinearRing
                lineString = lineString.Factory.CreateLineString(lineString.CoordinateSequence);
            }

            // unioning the linestring with the point makes any self intersections explicit.

            IPoint point = lineString.Factory.CreatePoint(lineString.GetCoordinateN(0));
            IGeometry toAdd = lineString.Union(point);

            //Add result to polygonizer
            polygonizer.Add(toAdd);
        }

        /**
         * Get a geometry from a collection of polygons.
         * 
         * @param polygons collection
         * @param factory factory to generate MultiPolygon if required
         * @return null if there were no polygons, the polygon if there was only one, or a MultiPolygon containing all polygons otherwise
         */
        IGeometry ToPolygonGeometry(ICollection<IGeometry> polygons, IGeometryFactory factory)// geoSource.factory 可以创建多边形
        {
            switch (polygons.Count())
            {
                case 0:
                    return null; // No valid polygons!
                case 1:
                    return polygons.FirstOrDefault(); // single polygon - no need to wrap
                default:
                    //polygons may still overlap! Need to sym difference them
                    List<IGeometry> ps = polygons.ToList();
                    double maxArea = ps.Select(x => x.Envelope.Area).Max();
                    IGeometry geometry = ps.FirstOrDefault(x => x.Envelope.Area == maxArea);
                    IGeometry result = geometry;
                    for (int i = 0; i < ps.Count; i++)
                    {
                        IGeometry currentGeo = ps[i];

                        //string testStr = currentGeo.ToString();
                        //string res = GdalShapeOperate.Instance.GetPoints(OSGeo.OGR.Ogr.CreateGeometryFromWkt(ref testStr, null));
                        if (currentGeo == null || currentGeo.Equals(geometry))
                            continue;

                        //1. 判断当前图形是否是多环图形

                        //Covers 优于 Contains  
                        // symDifference 并集去掉重合部分
                        IPolygon p = result as IPolygon;
                        if (p?.NumInteriorRings > 0)
                        {
                            //多环的话 需要把内部空环依次和当前图形比对 判断是否是重叠 (重叠取diff)
                            Polygonizer polygonizer = new Polygonizer();
                            for (int n = p.NumInteriorRings; n-- > 0;)
                            {
                                AddLineString(p.GetInteriorRingN(n), polygonizer);
                            }
                            List<IGeometry> interPolygons = polygonizer.GetPolygons().ToList();
                            //内环存在的话 需要和当前图形比对 如果基本匹配(重合面积>90) 取差集
                            if (interPolygons.Count > 0)
                            {
                                bool isIntersect = false;
                                foreach (var item in interPolygons)
                                {
                                    if (item.Intersects(currentGeo) && item.Intersection(currentGeo).Area / currentGeo.Area > 0.9)
                                    {
                                        isIntersect = true;
                                        break;
                                    }
                                }
                                if (isIntersect)
                                {
                                    result = result.Difference(currentGeo);
                                    continue;
                                }
                            }
                        }

                        //不是多环图形, 如果重叠 且重叠面积>当前图形面积的90%则 交集, 否则并集
                        if (geometry.Intersects(currentGeo) && geometry.Intersection(currentGeo).Area / currentGeo.Area > 0.9)
                            result = result.Difference(currentGeo);
                        else
                            result = result.Union(currentGeo);

                    }
                    return result;
            }
        }

        /// <summary>
        /// wkt转geometry
        /// </summary>
        /// <param name="wkt"></param>
        /// <returns></returns>
        public IGeometry WktToGeometry(string wkt)
        {
            NetTopologySuite.IO.WKTReader reader = new NetTopologySuite.IO.WKTReader();
            IGeometry geo = reader.Read(wkt);
            return geo;
        }

        /// <summary>
        /// rings 转 geometry
        /// </summary>
        /// <param name="rings"></param>
        /// <returns></returns>
        public IGeometry RingsToGeometry(string rings)
        {
            OSGeo.OGR.Geometry geometry = GdalShapeOperate.Instance.GetGeometryFromShapeJson(rings);

            string wkt = string.Empty;
            while (wkt == string.Empty)
            {
                wkt = GdalShapeOperate.Instance.ExportToWkt(geometry);
                Thread.Sleep(50);
            }
            return WktToGeometry(wkt);
        }

        public string WktToRings(string wkt) => GdalShapeOperate.Instance.GetPoints(OSGeo.OGR.Geometry.CreateFromWkt(wkt));

        public string GeometryToRings(Geometry geo) => GdalShapeOperate.Instance.GetPoints(OSGeo.OGR.Geometry.CreateFromWkt(geo.ToString()));
    }
}