C# IPolygon.GetInteriorRingN方法代码示例

        /// <summary>
        /// 
        /// </summary>
        /// <param name="polygon"></param>
        /// <param name="writer"></param>
        public void Write(IPolygon polygon, BinaryWriter writer)
        {
            writer.Write((int) ShapeGeometryTypes.Polygon);

            // Write BoundingBox            
            WriteBoundingBox(polygon, writer);

            // Write NumParts and NumPoints            
            writer.Write((int) (polygon.NumInteriorRings + 1));
            writer.Write((int)  polygon.NumPoints);

            // Write IndexParts
            int count = 0;
            writer.Write((int) count);
            if (polygon.NumInteriorRings != 0)
            {
                // Write external shell index
                count += polygon.ExteriorRing.NumPoints;
                writer.Write((int) count);
                for (int i = 1; i < polygon.NumInteriorRings; i++)
                {
                    // Write internal holes index
                    count += polygon.GetInteriorRingN(i - 1).NumPoints;
                    writer.Write((int) count);
                }
            }

            // Write Coordinates
            for (int i = 0; i < polygon.NumPoints; i++)
                Write(polygon.Coordinates[i], writer);
        }

 public static void ComputeDistance(IPolygon poly, Coordinate pt, PointPairDistance ptDist)
 {
     ComputeDistance(poly.ExteriorRing, pt, ptDist);
     for (var i = 0; i < poly.NumInteriorRings; i++)
     {
         ComputeDistance(poly.GetInteriorRingN(i), pt, ptDist);
     }
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="p"></param>
 /// <returns></returns>
 private bool HasRepeatedPoint(IPolygon p)
 {
     if (HasRepeatedPoint(p.ExteriorRing.Coordinates))
         return true;
     for (int i = 0; i < p.NumInteriorRings; i++)
         if (HasRepeatedPoint(p.GetInteriorRingN(i).Coordinates)) 
             return true;            
     return false;
 }

 public static Boolean ContainsPointInPolygon(Coordinate p, IPolygon poly)
 {
     if (poly.IsEmpty) return false;
     ILinearRing shell = (ILinearRing)poly.ExteriorRing;
     if (!IsPointInRing(p, shell)) return false;
     // now test if the point lies in or on the holes
     for (int i = 0; i < poly.NumInteriorRings; i++)
     {
         ILinearRing hole = (ILinearRing)poly.GetInteriorRingN(i);
         if (IsPointInRing(p, hole)) return false;
     }
     return true;
 }

        public static void DrawPolygon(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IPolygon pol, D2D1.Brush brush, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, bool clip, Map map)
        {
            if (pol.ExteriorRing == null)
                return;

            Vector2[] points;
            var startPoint = TransformToImage(pol.ExteriorRing, map, out points);
            if (points.Length > 1)
            {
                using (var geom = new D2D1.PathGeometry(factory))
                {
                    using (var gs = geom.Open())
                    {
                        gs.SetFillMode(D2D1.FillMode.Alternate);

                        gs.BeginFigure(startPoint, D2D1.FigureBegin.Filled);
                        gs.AddLines(points);
                        gs.EndFigure(D2D1.FigureEnd.Closed);

                        for (var i = 0; i < pol.NumInteriorRings; i++)
                        {
                            startPoint = TransformToImage(pol.GetInteriorRingN(i), map, out points);
                            if (points.Length > 1)
                            {
                                gs.BeginFigure(startPoint, D2D1.FigureBegin.Filled);
                                gs.AddLines(points);
                                gs.EndFigure(D2D1.FigureEnd.Closed);
                            }
                        }

                        gs.Close();
                    }

                    if (brush != null)
                        renderTarget.FillGeometry(geom, brush);
                    if (pen != null)
                        renderTarget.DrawGeometry(geom, pen, penWidth, penStrokeStyle);
                }
            }
        }

        private GraphicsPath ToShape(IPolygon p)
        {
            var poly = new PolygonGraphicsPath();

            Append(poly, p.ExteriorRing.Coordinates);
            for (int j = 0; j < p.NumInteriorRings; j++)
            {
                Append(poly, p.GetInteriorRingN(j).Coordinates);
            }

            return poly.Path;
        }

        /// <summary>
        /// Writes <paramref name="polygon"/> to a stream using <paramref name="writer"/>
        /// </summary>
        /// <param name="polygon">The polygon to write</param>
        /// <param name="writer">The writer to use</param>
        public void Write(IPolygon polygon, BinaryWriter writer)
        {
            writer.Write((int) ShapeGeometryType.Polygon);

            // Write BoundingBox            
            WriteBoundingBox(polygon.EnvelopeInternal, writer);

            // Write NumParts and NumPoints            
            writer.Write((int) (polygon.NumInteriorRings + 1));
            writer.Write((int)  polygon.NumPoints);

            // Write IndexParts
            int count = 0;
            writer.Write((int) count);
            var seq = polygon.Factory.CoordinateSequenceFactory.Create(polygon.NumPoints,
                                                                       polygon.ExteriorRing.CoordinateSequence.Ordinates);
            
            // Gather coordinate information
            var ring = polygon.ExteriorRing.CoordinateSequence;
            CoordinateSequences.Copy(ring, 0, seq, count, ring.Count);

            // If we have interior rings write the index parts and gather coordinate information
            if (polygon.NumInteriorRings > 0)
            {
                // Write exterior shell index
                count += ring.Count;
                writer.Write((int) count);

                // Gather coordinates and write interior shell index
                for (int i = 0; i < polygon.NumInteriorRings; i++)
                {
                    // Write internal holes index
                    ring = polygon.GetInteriorRingN(i).CoordinateSequence;
                    CoordinateSequences.Copy(ring, 0, seq, count, ring.Count);
                    if (i < polygon.NumInteriorRings - 1)
                    {
                        count += ring.Count;
                        writer.Write((int) count);
                    }
                }
            }

            // Write Coordinates
            WriteCoordinates(seq, writer, Ordinates.XY);
        }

        /// <summary>
        /// Transforms a <see cref="GeoAPI.Geometries.IPolygon"/>.
        /// </summary>
        /// <param name="p">Polygon 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 Polygon</returns>
        public static IPolygon TransformPolygon(IPolygon p, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
        {
            var shell = toFactory.CreateLinearRing(TransformSequence(p.Shell.CoordinateSequence, from, to, toFactory.CoordinateSequenceFactory));
            var holes = new ILinearRing[p.NumInteriorRings];
            for (var i = 0; i < p.NumInteriorRings; i++)
                holes[i] = toFactory.CreateLinearRing(TransformSequence(p.GetInteriorRingN(i).CoordinateSequence, from, to, toFactory.CoordinateSequenceFactory));

            return toFactory.CreatePolygon(shell, holes);
        }

        private void WritePolygon(IPolygon p, int level,
            StringBuilder sb)
        {
            StartLine(GeometryTag("Polygon") + "\n", level, sb);
            WriteModifiers(level, sb);

            StartLine("  <outerBoundaryIs>\n", level, sb);
            WriteLinearRing((ILinearRing)p.ExteriorRing, level + 1, sb, false);
            StartLine("  </outerBoundaryIs>\n", level, sb);

            for (int t = 0; t < p.NumInteriorRings; t++)
            {
                StartLine("  <innerBoundaryIs>\n", level, sb);
                WriteLinearRing((ILinearRing)p.GetInteriorRingN(t), level + 1, sb, false);
                StartLine("  </innerBoundaryIs>\n", level, sb);
            }

            StartLine("</Polygon>\n", level, sb);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="p"></param>
 /// <param name="poly"></param>
 /// <returns></returns>
 public static bool ContainsPointInPolygon(Coordinate p, IPolygon poly)
 {
     if(poly.IsEmpty) 
         return false;
     LinearRing shell = (LinearRing)poly.Shell;
     if (!CGAlgorithms.IsPointInRing(p, shell.Coordinates)) 
         return false;
     // now test if the point lies in or on the holes
     for(int i = 0; i < poly.NumHoles; i++)
     {
         LinearRing hole = (LinearRing)poly.GetInteriorRingN(i);
         if(CGAlgorithms.IsPointInRing(p, hole.Coordinates)) 
             return false;
     }
     return true;
 }

        private Coordinate[][] WriteGeom(JsonWriter writer, IPolygon poly)
        {
            if (poly == null)
                throw new ArgumentNullException("poly");

            int numHoles = poly.NumInteriorRings;
            Coordinate[][] arr = new Coordinate[numHoles + 1][];
            writer.WritePropertyName("arcs");
            writer.WriteStartArray();
            writer.WriteStartArray();
            // shell            
            writer.WriteValue(0);
            arr[0] = poly.Shell.Coordinates;
            // holes
            for (int i = 0; i < numHoles; i++)
            {
                writer.WriteValue(i + 1);
                arr[i + 1] = poly.GetInteriorRingN(i).Coordinates;
            }
            writer.WriteEndArray();
            writer.WriteEndArray();
            return arr;
        }

 /// <summary>Compute distance between a polygon and the rings of another.</summary>
 private void ComputeMinDistancePolygonRings(PlanarPolygon3D poly, IPolygon ringPoly,
     bool flip)
 {
     // compute shell ring
     ComputeMinDistancePolygonLine(poly, ringPoly.ExteriorRing, flip);
     if (_isDone) return;
     // compute hole rings
     int nHole = ringPoly.NumInteriorRings;
     for (int i = 0; i < nHole; i++)
     {
         ComputeMinDistancePolygonLine(poly, ringPoly.GetInteriorRingN(i), flip);
         if (_isDone) return;
     }
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="geom"></param>
        /// <param name="parent"></param>
        /// <returns></returns>
        protected virtual IGeometry TransformPolygon(IPolygon geom, IGeometry parent) 
        {
            bool isAllValidLinearRings = true;
            IGeometry shell = TransformLinearRing(geom.Shell);

            if (shell == null || ! (shell is LinearRing) || shell.IsEmpty)
                isAllValidLinearRings = false;

            ArrayList holes = new ArrayList();
            for (int i = 0; i < geom.NumHoles; i++) 
            {
                IGeometry hole = TransformLinearRing((ILinearRing) geom.GetInteriorRingN(i));
                if (hole == null || hole.IsEmpty) continue;            
                if (!(hole is LinearRing))
                    isAllValidLinearRings = false;
                holes.Add(hole);
            }

            if (isAllValidLinearRings)
                return _factory.CreatePolygon((ILinearRing)   shell, 
                                             (ILinearRing[]) holes.ToArray(typeof(ILinearRing)));
            ArrayList components = new ArrayList();
            if (shell != null) 
                components.Add(shell);                
            foreach (object hole in holes)
                components.Add(hole);
            return _factory.BuildGeometry(components);
        }

        private static void WritePolygon(IPolygon geometry, PostGis2GeometryHeader pgh, BinaryWriter writer)
        {
            writer.Write((uint)PostGis2GeometryType.Polygon);
            if (geometry.IsEmpty)
            {
                writer.Write(0);
                return;
            }

            var numRings = 1 + geometry.NumInteriorRings;
            
            //shell
            writer.Write(numRings);
            writer.Write(geometry.Shell.NumPoints);

            //holes
            for (var i = 0; i < geometry.NumInteriorRings; i++ )
                writer.Write(geometry.GetInteriorRingN(i).NumPoints);
            
            //pad
            if (numRings % 2 != 0)
                writer.Write(0);

            WriteSequence(geometry.Shell.CoordinateSequence, pgh, writer, geometry.Shell.NumPoints);
            for (var i = 0; i < geometry.NumInteriorRings; i++ )
            {
                var sequence = geometry.GetInteriorRingN(i).CoordinateSequence;
                WriteSequence(sequence, pgh, writer, sequence.Count);
            }
        }

 private static void WritePolygon(IPolygon geom, WriteCoordinates writeCoordinates, GaiaExport gaiaExport, BinaryWriter bw)
 {
     gaiaExport.WriteInt32(bw, geom.NumInteriorRings + 1);
     WriteLineString(geom.Shell, writeCoordinates, gaiaExport, bw);
     for (var i = 0; i < geom.NumInteriorRings; i++)
         WriteLineString(geom.GetInteriorRingN(i), writeCoordinates, gaiaExport, bw);
 }