public void TestAreaPrecisionPerformance()
        {

            const double originX = 1000000;
            const double originY = 5000000;
            var sw = new Stopwatch();
            var sw1 = new Stopwatch();
            var sw2 = new Stopwatch();
            var sw3 = new Stopwatch();
                                   
            //-2,23057128323489E-11

            sw.Start();
            for (var nrVertices = 4; nrVertices <= 5000000; nrVertices *= 2)
            {
                var coordinates = new Coordinate[nrVertices + 1];

                for (var i = 0; i <= nrVertices; i++)
                {
                    var vertex = new Coordinate(originX + (1d + Math.Sin( i/(double) nrVertices*2*Math.PI)),
                                                originY + (1d + Math.Cos( i/(double) nrVertices*2*Math.PI)));
                    coordinates[i] = vertex;
                }
                // close ring
                coordinates[nrVertices] = coordinates[0];

                var g1 = new GeometryFactory().CreateLinearRing(coordinates);
                var holes = new ILinearRing[] {};
                var polygon = (Polygon) new GeometryFactory().CreatePolygon(g1, holes);
                //Console.WriteLine(polygon);

                sw1.Start();
                var area = polygon.Area;
                sw1.Stop();
                sw2.Start();
                var area2 = AccurateSignedArea(coordinates);
                sw2.Stop();
                sw3.Start();
                var areaOld = OriginalSignedArea(coordinates);
                sw3.Stop();

                var exactArea = 0.5 * nrVertices * Math.Sin(2 * Math.PI / nrVertices);
                var eps1 = exactArea - area;
                var eps2 = exactArea - area2;
                var eps3 = exactArea - areaOld;
                
                //Assert.IsTrue(Math.Abs(eps2) <= Math.Abs(eps3));

                Console.WriteLine(string.Format("{0,10},\tnow err: {1,23},\tacc err: {2,23},\told err: {3,23}", nrVertices ,eps1, eps2 ,eps3));
            }
            
            sw.Stop();

            Console.WriteLine("\n\nTime: " + sw.Elapsed);
            Console.WriteLine("Time Now: " + sw1.ElapsedTicks);
            Console.WriteLine("Time Acc: " + sw2.ElapsedTicks);
            Console.WriteLine("Time Old: " + sw3.ElapsedTicks);
            
            Assert.IsTrue(true);
        }

 ///<summary>
 /// Determines whether a point lies in a LinearRing, using the ring envelope to short-circuit if possible.
 ///</summary>
 /// <param name="p">The point to test</param>
 /// <param name="ring">A linear ring</param>
 /// <returns><c>true</c> if the point lies inside the ring</returns>
 private static Boolean IsPointInRing(Coordinate p, ILinearRing ring)
 {
     // short-circuit if point is not in ring envelope
     if (!ring.EnvelopeInternal.Intersects(p))
         return false;
     return CGAlgorithms.IsPointInRing(p, ring.Coordinates);
 }

 /// <summary>
 /// Find a point from the list of testCoords
 /// that is NOT a node in the edge for the list of searchCoords.
 /// </summary>
 /// <param name="testCoords"></param>
 /// <param name="searchRing"></param>
 /// <param name="graph"></param>
 /// <returns>The point found, or <c>null</c> if none found.</returns>
 public static ICoordinate FindPointNotNode(ICoordinate[] testCoords, ILinearRing searchRing, GeometryGraph graph)
 {
     // find edge corresponding to searchRing.
     Edge searchEdge = graph.FindEdge(searchRing);
     // find a point in the testCoords which is not a node of the searchRing
     EdgeIntersectionList eiList = searchEdge.EdgeIntersectionList;
     // somewhat inefficient - is there a better way? (Use a node map, for instance?)
     foreach(ICoordinate pt in testCoords)
         if(!eiList.IsIntersection(pt))
             return pt;            
     return null;
 }

 /// <summary>
 /// Constructs a <c>Polygon</c> with the given exterior boundary and
 /// interior boundaries.
 /// </summary>       
 /// <param name="shell">
 /// The outer boundary of the new <c>Polygon</c>,
 /// or <c>null</c> or an empty <c>LinearRing</c> if the empty
 /// point is to be created.
 /// </param>
 /// <param name="holes">
 /// The inner boundaries of the new <c>Polygon</c>
 /// , or <c>null</c> or empty <c>LinearRing</c>s if the empty
 /// point is to be created.
 /// </param>
 /// <param name="factory"></param>
 public Polygon(ILinearRing shell, ILinearRing[] holes, IGeometryFactory factory) : base(factory)
 {        
     if (shell == null) 
         shell = Factory.CreateLinearRing((ICoordinateSequence) null);            
     if (holes == null) 
         holes = new ILinearRing[] { };
     if (HasNullElements(holes)) 
         throw new ArgumentException("holes must not contain null elements");
     if (shell.IsEmpty && HasNonEmptyElements(holes)) 
         throw new ArgumentException("shell is empty but holes are not");
     this.shell = shell;
     this.holes = holes;
 }

        public static IPolygon Reproject(this IPolygon polygon, ProjectionInfo source, ProjectionInfo target)
        {
            var shell = Reproject(polygon.Shell, source, target);
            ILinearRing[] holes = null;
            if (polygon.NumHoles > 0)
            {
                holes = new ILinearRing[polygon.NumHoles];
                var i = 0;
                foreach (var hole in polygon.Holes)
                    holes[i++] = Reproject(hole, source, target);
            }

            return polygon.Factory.CreatePolygon(shell, holes);
        }

 /// <summary>
 /// 
 /// </summary>
 public PolygonSamples() : base(new GeometryFactory(new PrecisionModel(PrecisionModels.Fixed)))
 {
     shell = Factory.CreateLinearRing(new ICoordinate[] { new Coordinate(100,100),
                                                          new Coordinate(200,100),
                                                          new Coordinate(200,200),                
                                                          new Coordinate(100,200),
                                                          new Coordinate(100,100), });
     hole = Factory.CreateLinearRing(new ICoordinate[] {  new Coordinate(120,120),
                                                          new Coordinate(180,120),
                                                          new Coordinate(180,180),                                                                                
                                                          new Coordinate(120,180),                                                                
                                                          new Coordinate(120,120), });
     polygon = Factory.CreatePolygon(shell, new ILinearRing[] { hole, });
 }

 public void Init()
 {
     shell = Factory.CreateLinearRing(new ICoordinate[] {    new Coordinate(100,100),
                                                             new Coordinate(200,100),
                                                             new Coordinate(200,200),                
                                                             new Coordinate(100,200),
                                                             new Coordinate(100,100), });
     // NOTE: Hole is created with not correct order for holes
     hole = Factory.CreateLinearRing(new ICoordinate[] {      new Coordinate(120,120),
                                                             new Coordinate(180,120),
                                                             new Coordinate(180,180),                                                                                
                                                             new Coordinate(120,180),                                                                
                                                             new Coordinate(120,120), });
     polygon = Factory.CreatePolygon(shell, new ILinearRing[] { hole, });
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="innerRing"></param>
 /// <param name="searchRing"></param>
 /// <returns></returns>
 private bool IsInside(ILinearRing innerRing, ILinearRing searchRing)
 {
     ICoordinate[] innerRingPts = innerRing.Coordinates;
     ICoordinate[] searchRingPts = searchRing.Coordinates;
     if (!innerRing.EnvelopeInternal.Intersects(searchRing.EnvelopeInternal))
         return false;
     ICoordinate innerRingPt = IsValidOp.FindPointNotNode(innerRingPts, searchRing, graph);
     Assert.IsTrue(innerRingPt != null, "Unable to find a ring point not a node of the search ring");
     bool isInside = CGAlgorithms.IsPointInRing(innerRingPt, searchRingPts);
     if (isInside) 
     {
         nestedPt = innerRingPt;
         return true;
     }
     return false;
 }

        /// <summary>
        /// 
        /// </summary>
        public GMLTesting() 
        {
            point = Factory.CreatePoint(new Coordinate(100, 100));

            ICoordinate[] coordinates = new ICoordinate[]
            {
                 new Coordinate(10,10),
                 new Coordinate(20,20),
                 new Coordinate(20,10),                 
            };
            line = Factory.CreateLineString(coordinates);

            coordinates = new ICoordinate[]
            {
                new Coordinate(100,100),
                new Coordinate(200,100),
                new Coordinate(200,200),                
                new Coordinate(100,200),
                new Coordinate(100,100),
            };
            ICoordinate[] interior1 = new ICoordinate[] 
            { 
                new Coordinate(120,120),
                new Coordinate(180,120),
                new Coordinate(180,180),                
                new Coordinate(120,180),
                new Coordinate(120,120),
            };
            ILinearRing linearRing = Factory.CreateLinearRing(coordinates);
            ILinearRing[] holes = new ILinearRing[] { Factory.CreateLinearRing(interior1), };
            polygon = Factory.CreatePolygon(linearRing, holes);

            coordinates = new ICoordinate[]
            {
                new Coordinate(100,100),
                new Coordinate(200,200),
                new Coordinate(300,300),                
                new Coordinate(400,400),
                new Coordinate(500,500),
            };
            multiPoint = Factory.CreateMultiPoint(coordinates);

            writer = new GMLWriter();
            reader = new GMLReader();
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="geometryFactory"></param>
 /// <returns></returns>
 public IPolygon ToPolygon(IGeometryFactory geometryFactory)
 {
     ILinearRing[] holeLR = new ILinearRing[_holes.Count];
     for (int i = 0; i < _holes.Count; i++)
         holeLR[i] = _holes[i].LinearRing;
     IPolygon poly = geometryFactory.CreatePolygon(LinearRing, holeLR);
     return poly;
 }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="geometry"></param>
		/// <returns></returns>
		protected int SetByteStream(ILinearRing geometry)
		{
			return SetByteStream(geometry.Coordinates, geometry);
		}

        private static PolygonType ExtractShellPolygon(ref ILinearRing shell, SurfacePropertyType member)
        {
            PolygonType sur = member.Surface as PolygonType;
            LinearRingType li = sur.Exterior.Ring as LinearRingType;
            foreach (DirectPositionListType rings in li.Items)
            {
                List<Coordinate> lstCoor = ExtractCoordinates(rings);

                shell = new LinearRing(lstCoor);

            }
            return sur;
        }

        private IBasicGeometry GetPolygon(MultiSurfaceType multi)
        {
            Polygon[] p = new Polygon[multi.SurfaceMemberItems.Count];
                ;
           
            int npoly = 0;
            foreach (SurfacePropertyType member in multi.SurfaceMemberItems)
            {
                ILinearRing shell = null;
                ILinearRing[] holes = null;
                PolygonType sur = ExtractShellPolygon(ref shell, member);

                if (sur.Interior.Count == 0  && shell !=null)
                        p[npoly] = new Polygon(shell);
                else
                {
                    holes = new ILinearRing[sur.Interior.Count];
                    ExtractInteriorPolygon(holes, sur);
                    p[npoly] = new Polygon(shell, holes);
                }
                npoly++;
            }
            return new MultiPolygon(p);

        }

 /// <summary>
 ///
 /// </summary>
 /// <param name="ring"></param>
 public McPointInRing(ILinearRing ring)
 {
     _ring = ring;
     BuildIndex();
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="linearRing"></param>
 /// <param name="writer"></param>
 protected void Write(ILinearRing linearRing, XmlTextWriter writer)
 {
     writer.WriteStartElement("LinearRing", GMLElements.gmlNS);
     WriteCoordinates(linearRing.Coordinates, writer);
     writer.WriteEndElement();
 }

            ///<summary>
            /// Simplifies a LinearRing.  If the simplification results in a degenerate ring, remove the component.
            ///</summary>
            /// <returns>null if the simplification results in a degenerate ring</returns>
            protected override IGeometry TransformLinearRing(ILinearRing geom, IGeometry parent)
            {
                Boolean removeDegenerateRings = parent is IPolygon;
                IGeometry simpResult = base.TransformLinearRing(geom, parent);

                if (removeDegenerateRings && !(simpResult is ILinearRing))
                    return null;
                return simpResult;
            }

        public void PolygonHoles()
        {
            var coords = new Coordinate[20];
            var rnd = new Random();
            var center = new Coordinate((rnd.NextDouble() * 360) - 180, (rnd.NextDouble() * 180) - 90);

            // Shell Coordinates
            var coordscheck = new GeoAPI.Geometries.Coordinate[20];
            for (var i = 0; i < 19; i++)
            {
                var x = center.X + Math.Cos((i * 10) * Math.PI / 10);
                var y = center.Y + (i * 10) * Math.PI / 10;
                coords[i] = new Coordinate(x, y);
                coordscheck[i] = new GeoAPI.Geometries.Coordinate(x, y);
            }
            coordscheck[19] = new GeoAPI.Geometries.Coordinate(coords[0].X, coords[0].Y);
            coords[19] = new Coordinate(coords[0].X, coords[0].Y);


            // Shell Rings
            var ring = new LinearRing(coords);
            var gf = new NetTopologySuite.Geometries.GeometryFactory();
            var ringCheck = gf.CreateLinearRing(coordscheck);


            // Hole Coordinates
            var coordsholecheck = new GeoAPI.Geometries.Coordinate[20];
            var coordshole = new Coordinate[20];
            for (var i = 0; i < 20; i++)
            {
                var x = center.X + Math.Cos((i * 10) * Math.PI / 20);
                var y = center.Y + (i * 10) * Math.PI / 20;
                coordshole[i] = new Coordinate(x, y);
                coordsholecheck[i] = new GeoAPI.Geometries.Coordinate(x, y);
            }
            coordshole[19] = new Coordinate(coordshole[0].X, coordshole[0].Y);
            coordsholecheck[19] = new GeoAPI.Geometries.Coordinate(coordshole[0].X, coordshole[0].Y);

            // Hole LinearRing Arrays
            var hole = new LinearRing(coordshole);
            var holes = new ILinearRing[1];
            var holeCheck = gf.CreateLinearRing(coordsholecheck);
            var holescheck = new GeoAPI.Geometries.ILinearRing[1];
            holes[0] = hole;
            holescheck[0] = holeCheck;


            var pg = new Polygon(ring, holes);
            var polygonCheck = gf.CreatePolygon(ringCheck, holescheck);
            var areaCheck = polygonCheck.Area;
            var area = pg.Area;
            Assert.IsTrue(Math.Abs(area - areaCheck) < 1e-6);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="ring"></param>
 public void Add(ILinearRing ring)
 {
     rings.Add(ring);
 }

		public static IPolygon CreatePolygon(ILinearRing shell, ILinearRing[] holes)
		{
			return geomFactory.CreatePolygon(shell, holes);
		}		

 /// <summary>
 /// Transforms a <see cref="GeoAPI.Geometries.ILinearRing"/>.
 /// </summary>
 /// <param name="r">LinearRing 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 LinearRing</returns>
 public static ILinearRing TransformLinearRing(ILinearRing r, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
 {
     try
     {
         var toSeq = TransformSequence(r.CoordinateSequence, from, to, toFactory.CoordinateSequenceFactory);
         return toFactory.CreateLinearRing(toSeq);
     }
     catch
     {
         return null;
     }
 }