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);
            }
        }

        /// <summary>
        /// Transforms a <see cref="GeoAPI.Geometries.IMultiPolygon"/>.
        /// </summary>
        /// <param name="polys">MultiPolygon to transform</param>
        /// <param name="from">Source Projection</param>
        /// <param name="to">Target Projection</param>
        /// <param name="toFactory">The factory to create geometries for <paramref name="to"/></param>
        /// <returns>Transformed MultiPolygon</returns>
        public static IMultiPolygon TransformMultiPolygon(IMultiPolygon polys, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
        {
            var pOut = new IPolygon[polys.Count];
            for (var i = 0; i < polys.Count; i++)
                pOut[i] = TransformPolygon((IPolygon)polys.GetGeometryN(i), from, to, toFactory);

            return toFactory.CreateMultiPolygon(pOut);
        }

        private void Write(IMultiPolygon multiPoly)
        {
            EnsureGeometryFactory(multiPoly);

            int contentLength = ContentLength(multiPoly);

            _writerIndex.WriteBE(_filePos);
            _writerIndex.WriteBE(contentLength);

            _writerShape.WriteBE(_recordNumber++);
            _writerShape.WriteBE(contentLength);
            _writerShape.Write((int)ShapefileGeometryType.Polygon);

            Write(multiPoly.EnvelopeInternal);

            int numParts = multiPoly.Geometries.Cast<IPolygon>().Sum(g => g.Holes.Length + 1);
            int numPoints = multiPoly.NumPoints;

            _writerShape.Write(numParts);
            _writerShape.Write(numPoints);

            // write the offsets to the points
            int offset = 0;
            foreach (IPolygon poly in multiPoly.Geometries)
            {
                // offset to the shell points
                _writerShape.Write(offset);
                offset = offset + poly.Shell.NumPoints;

                // offstes to the holes
                foreach (ILinearRing ring in poly.Holes)
                {
                    _writerShape.Write(offset);
                    offset = offset + ring.NumPoints;
                }
            }

            // write the points
            foreach (IPolygon poly in multiPoly.Geometries)
            {
                Write(poly.Shell.Coordinates);
                foreach (ILinearRing ring in poly.Holes)
                    Write(ring.Coordinates);
            }

            _filePos += 4 + contentLength;
        }

 /// <summary>
 ///
 /// </summary>
 /// <param name="geometry"></param>
 /// <returns></returns>
 protected virtual int SetByteStream(IMultiPolygon geometry)
 {
     int count = INIT_COUNT;
     count += 4;
     foreach (Polygon geom in geometry.Geometries)
         count += SetByteStream(geom);
     return count;
 }

 public int ContentLength(IMultiPolygon poly)
 {
     int numParts = poly.Geometries.Cast<IPolygon>().Sum(g => g.Holes.Length + 1);
     return (22 + (2 * numParts) + (poly.NumPoints * 8)); // 22 => shapetype(2) + bbox(4*4) + numparts(2) + numpoints(2)
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPolygon"></param>
 /// <param name="writer"></param>
 protected void Write(IMultiPolygon multiPolygon, XmlTextWriter writer)
 {
     writer.WriteStartElement("MultiPolygon", GMLElements.gmlNS);
     for (int i = 0; i < multiPolygon.NumGeometries; i++)
     {
         writer.WriteStartElement("polygonMember", GMLElements.gmlNS);
         Write(multiPolygon.Geometries[i] as IPolygon, writer);
         writer.WriteEndElement();
     }
     writer.WriteEndElement();
 }