C# IMultiPolygon类代码示例

        private void AddMultiPolygon(IMultiPolygon geometry, GraphicsPath graphicsPath)
        {
            if (geometry == null)
                throw new ArgumentNullException("geometry");

            foreach (var geom in geometry.Geometries)
                this.AddPolygon((IPolygon)geom, graphicsPath);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPolygon"></param>
 /// <param name="writer"></param>
 protected void Write(IMultiPolygon multiPolygon, BinaryWriter writer)
 {
     WriteByteOrder(writer);     // LittleIndian
     if (Double.IsNaN(multiPolygon.Coordinate.Z))
          writer.Write((int)WKBGeometryTypes.WKBMultiPolygon);
     else writer.Write((int)WKBGeometryTypes.WKBMultiPolygonZ);
     writer.Write((int) multiPolygon.NumGeometries);
     for (int i = 0; i < multiPolygon.NumGeometries; i++)
         Write(multiPolygon.Geometries[i] as IPolygon, writer);
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="geometry"></param>
        /// <returns></returns>
        protected int SetByteStream(IMultiPolygon geometry)
        {
			// 4-byte count + subgeometries
			return 4 + SetByteStream(geometry.Geometries);
		}

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPolygon"></param>
 /// <param name="writer"></param>
 protected void Write(IMultiPolygon multiPolygon, BinaryWriter writer)
 {
     WriteByteOrder(writer);     // LittleIndian
     writer.Write((int) WKBGeometryTypes.WKBMultiPolygon);
     writer.Write((int) multiPolygon.NumGeometries);
     for (int i = 0; i < multiPolygon.NumGeometries; i++)
         Write(multiPolygon.Geometries[i] as IPolygon, writer);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPolygon"></param>
 /// <returns></returns>
 protected int SetByteStreamLength(IMultiPolygon multiPolygon)
 {            
     int numParts = multiPolygon.NumGeometries;               // Exterior rings count            
     foreach (IPolygon polygon in multiPolygon.Geometries)    // Adding interior rings count            
         numParts += polygon.NumInteriorRings;
     int numPoints = multiPolygon.NumPoints;
     return CalculateLength(numParts, numPoints);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPolygon"></param>
 /// <returns></returns>
 protected int SetByteStreamLength(IMultiPolygon multiPolygon)
 {
     int count = InitValue;
     foreach (IPolygon p in multiPolygon.Geometries)
         count += SetByteStreamLength(p);
     return count;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="geom"></param>
 /// <param name="parent"></param>
 /// <returns></returns>
 protected override IGeometry TransformMultiPolygon(IMultiPolygon geom, IGeometry parent)
 {
     IGeometry roughGeom = base.TransformMultiPolygon(geom, parent);
     return CreateValidArea(roughGeom);
 }

 /// <summary>
 ///
 /// </summary>
 /// <param name="multiPolygon"></param>
 /// <param name="writer"></param>
 protected virtual void Write(IMultiPolygon multiPolygon, BinaryWriter writer)
 {
     WriteByteOrder(writer);
     writer.Write((int)WkbGeometryType.MultiPolygon);
     writer.Write(multiPolygon.NumGeometries);
     for (int i = 0; i < multiPolygon.NumGeometries; i++)
         Write(multiPolygon.Geometries[i] as Polygon, writer);
 }

        private static DSMultiPolygon FromMultiPolygon(IMultiPolygon geometry, DSGeometryFactory factory, bool setUserData)
        {
            var dsPolygons = new DotSpatial.Topology.IPolygon[geometry.NumGeometries];

            for (var i = 0; i < dsPolygons.Length; i++)
                dsPolygons[i] = FromPolygon((IPolygon)geometry.GetGeometryN(i), factory, setUserData);

            var result = factory.CreateMultiPolygon(dsPolygons);
            if (setUserData)
                result.UserData = geometry.UserData;
            return result;
        }

        private static GeoAPIMultiPolygon FromMultiPolygon(IMultiPolygon geometry, GeoAPIGeometryFactory factory, bool copyUserData)
        {
            var dsPolygons = new GeoAPI.Geometries.IPolygon[geometry.NumGeometries];

            for (var i = 0; i < dsPolygons.Length; i++)
                dsPolygons[i] = FromPolygon((IPolygon)geometry.GetGeometryN(i), factory, copyUserData);

            var result = factory.CreateMultiPolygon(dsPolygons);
            if (copyUserData)
                result.UserData = geometry.UserData;
            return result;
        }

 /// <summary>
 /// Tests that no element polygon is wholly in the interior of another element polygon.
 /// Preconditions:
 /// Shells do not partially overlap.
 /// Shells do not touch along an edge.
 /// No duplicate rings exists.
 /// This routine relies on the fact that while polygon shells may touch at one or
 /// more vertices, they cannot touch at ALL vertices.
 /// </summary>
 private void CheckShellsNotNested(IMultiPolygon mp, GeometryGraph graph)
 {            
     for (int i = 0; i < mp.NumGeometries; i++)
     {                
         IPolygon p = (IPolygon) mp.GetGeometryN(i);
         ILinearRing shell = p.Shell;
         for (int j = 0; j < mp.NumGeometries; j++)
         {                    
             if (i == j)
                 continue;
             IPolygon p2 = (IPolygon) mp.GetGeometryN(j);                    
             CheckShellNotNested(shell, p2, graph);
             if (validErr != null) return;
         }                
     }         
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="g"></param>
        private void CheckValid(IMultiPolygon g)
        {
            foreach(IPolygon p in g.Geometries)
            {                                                
                CheckInvalidCoordinates(p);
                if (validErr != null) return;
                CheckClosedRings(p);
                if (validErr != null) return;
            }

            GeometryGraph graph = new GeometryGraph(0, g);
            CheckTooFewPoints(graph);
            if (validErr != null) return;
            CheckConsistentArea(graph);
            if (validErr != null) return;
            if (!IsSelfTouchingRingFormingHoleValid)
            {
                CheckNoSelfIntersectingRings(graph);
                if (validErr != null) return;
            }
            foreach(IPolygon p in g.Geometries)
            {                
                CheckHolesInShell(p, graph);
                if (validErr != null) return;
            }
            foreach (IPolygon p in g.Geometries)
            {                                
                CheckHolesNotNested(p, graph);
                if (validErr != null) return;
            }
            CheckShellsNotNested(g, graph);
            if (validErr != null) return;
            CheckConnectedInteriors(graph);
        }

        /// <summary>
        /// Method to write a multi polygon geometry to the <paramref name="writer"/>
        /// </summary>
        /// <param name="areas">The multi polygon geometry</param>
        /// <param name="writer">The JSON writer</param>
        public static void Write(IMultiPolygon areas, TextWriter writer)
        {
            if (areas == null)
                return;
            if (writer == null)
                throw new ArgumentNullException("writer", "A valid text writer object is required");

            Write(areas, CreateWriter(writer));
        }

 public static void DrawMultiPolygon(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IMultiPolygon pols, D2D1.Brush brush, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, bool clip, Map map)
 {
     for (var i = 0; i < pols.NumGeometries; i++)
     {
         var p = (IPolygon)pols[i];
         DrawPolygon(renderTarget, factory, p, brush, pen, penWidth, penStrokeStyle, clip, map);
     }
 }

        /// <summary>
        /// Writes a multipolygon.
        /// </summary>
        /// <param name="mp">The mulitpolygon to be written.</param>
        /// <param name="bWriter">Stream to write to.</param>
        /// <param name="byteorder">Byte order</param>
        private static void WriteMultiPolygon(IMultiPolygon mp, BinaryWriter bWriter, WkbByteOrder byteorder)
        {
            //Write the number of polygons.
            int num = mp.NumGeometries;
            WriteUInt32((uint) num, bWriter, byteorder);

            //Loop on the number of polygons.
            //NOTE: by contract, the first item returned 
            //      from GetEnumerator (i.e. using foreach) is the IMultiPolygon itself!
            for (int i = 0; i < num; i++)
            {
                IPolygon poly = (IPolygon) mp.GetGeometryN(i);
                //Write polygon header
                bWriter.Write((byte) byteorder);
                WriteUInt32((uint) WKBGeometryType.wkbPolygon, bWriter, byteorder);
                //Write each polygon.
                WritePolygon(poly, bWriter, byteorder);
            }
        }