public static IGeometry MergeLines(IGeometry g)
 {
     LineMerger merger = new LineMerger();
     merger.Add(g);
     IList<IGeometry> lines = merger.GetMergedLineStrings();
     return g.Factory.BuildGeometry(lines);
 }

 /// <summary>
 /// Computes the set-theoretic union of two <c>Geometry</c>s, using enhanced precision.
 /// </summary>
 /// <param name="geom0">The first Geometry.</param>
 /// <param name="geom1">The second Geometry.</param>
 /// <returns>The Geometry representing the set-theoretic union of the input Geometries.</returns>
 public static IGeometry Union(IGeometry geom0, IGeometry geom1)
 {
     ApplicationException originalEx;
     try
     {
         IGeometry result = geom0.Union(geom1);
         return result;
     }
     catch (ApplicationException ex)
     {
         originalEx = ex;
     }
     /*
      * If we are here, the original op encountered a precision problem
      * (or some other problem).  Retry the operation with
      * enhanced precision to see if it succeeds
      */
     try
     {
         CommonBitsOp cbo = new CommonBitsOp(true);
         IGeometry resultEp = cbo.Union(geom0, geom1);
         // check that result is a valid point after the reshift to orginal precision
         if (!resultEp.IsValid)
             throw originalEx;
         return resultEp;
     }
     catch (ApplicationException)
     {
         throw originalEx;
     }
 }

 protected void CheckEqual(IGeometry expected, IGeometry actual)
 {
     var actualNorm = actual.Normalized();       
     var expectedNorm = expected.Normalized();                 
     var equal = actualNorm.EqualsExact(expectedNorm);
     Assert.That(equal, Is.True, String.Format("Expected = {0}\nactual   = {1}", expected, actual));
 }

        /// <summary>
        /// Tests whether the given Geometry intersects the query rectangle.
        /// </summary>
        /// <param name="geom">The Geometry to test (may be of any type)</param>
        /// <returns><value>true</value> if an intersection must occur 
        /// or <value>false</value> if no conclusion about intersection can be made</returns>
        public bool Intersects(IGeometry geom)
        {
            if (!_rectEnv.Intersects(geom.EnvelopeInternal))
                return false;

            /**
             * Test if rectangle envelope intersects any component envelope.
             * This handles Point components as well
             */
            var visitor = new EnvelopeIntersectsVisitor(_rectEnv);
            visitor.ApplyTo(geom);
            if (visitor.Intersects)
                return true;

            /**
             * Test if any rectangle vertex is contained in the target geometry
             */
            var ecpVisitor = new GeometryContainsPointVisitor(_rectangle);
            ecpVisitor.ApplyTo(geom);
            if (ecpVisitor.ContainsPoint)
                return true;

            /**
             * Test if any target geometry line segment intersects the rectangle
             */
            var riVisitor = new RectangleIntersectsSegmentVisitor(_rectangle);
            riVisitor.ApplyTo(geom);
            return riVisitor.Intersects;
        }

//		#region Methods

		/// <summary>
		/// Converts a Geometry to its Well-known Text representation.
		/// </summary>
		/// <param name="geometry">A Geometry to write.</param>
		/// <returns>A &lt;Geometry Tagged Text&gt; string (see the OpenGIS Simple
		///  Features Specification)</returns>
		public static string Write(IGeometry geometry)
		{
			return new WKTWriter().Write(geometry);
//			StringWriter sw = new StringWriter();
//			Write(geometry, sw);
//			return sw.ToString();
		}

 private static AndroidBitmap ToAndroidBitmap(IGeometry geometry)
 {
     var raster = (IRaster)geometry;
     var rasterData = raster.Data.ToArray();
     var bitmap = BitmapFactory.DecodeByteArray(rasterData, 0, rasterData.Length);
     return bitmap;
 }

        public void GetHashCodeShouldBeComputedLazyAndShouldBeVeryFast()
        {
            var geometryCount = 1000000;
            var geometries = new IGeometry[geometryCount];

            for (int i = 0; i < geometryCount; i++)
            {
                geometries[i] = new Polygon(new LinearRing(new[] { new Coordinate(1.0, 2.0), new Coordinate(2.0, 3.0), new Coordinate(3.0, 4.0), new Coordinate(1.0, 2.0) }));
            }

            var polygon = new Polygon(new LinearRing(new[] { new Coordinate(1.0, 2.0), new Coordinate(2.0, 3.0), new Coordinate(3.0, 4.0), new Coordinate(1.0, 2.0) }));

            // computes hash code every call
            var t0 = DateTime.Now;
            for (int i = 0; i < geometryCount; i++)
            {
                geometries[i].GetHashCode();
            }
            var t1 = DateTime.Now;

            var dt1 = t1 - t0;

            // computes hash code only first time (lazy)
            t0 = DateTime.Now;
            for (int i = 0; i < geometryCount; i++)
            {
                polygon.GetHashCode();
            }
            t1 = DateTime.Now;

            var dt2 = t1 - t0;

            Assert.IsTrue(dt2.TotalMilliseconds < 15 * dt1.TotalMilliseconds);
        }

        protected override byte[] Write(IGeometry gIn)
        {
            var geoWriter = new MsSql2008GeometryWriter();
            var b = geoWriter.WriteGeometry(gIn);
            var b2 = geoWriter.Write(gIn);
            using( var conn = new SqlConnection(ConnectionString))
            {
                conn.Open();
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "INSERT INTO [nts_io_geometry] VALUES(@P1, @P2, @P3);";
                    var p1 = new SqlParameter("P1", SqlDbType.Int) { SqlValue = Counter };
                    var p2 = new SqlParameter("P2", SqlDbType.Text) { SqlValue = gIn.AsText() };
                    var p3 = new SqlParameter("P3", SqlDbType.Udt) { UdtTypeName = "geometry", SqlValue = b };
                    cmd.Parameters.AddRange(new[] { p1, p2, p3 });
                    cmd.ExecuteNonQuery();

                    /*
                    p1.SqlValue = 100000 + Counter;
                    cmd.Parameters.Remove(p3);
                    p3 = new SqlParameter("P3", SqlDbType.Image) { SqlValue = b };
                    cmd.Parameters.Add(p3);
                    p3.SqlValue = b2;
                    cmd.ExecuteNonQuery();
                     */
                }

            }
            return b2;
        }

 private IGeometry BufferUnion(IGeometry g0, IGeometry g1)
 {
     IGeometryFactory factory = g0.Factory;
     IGeometry gColl = factory.CreateGeometryCollection(new IGeometry[] { g0, g1 });
     IGeometry unionAll = gColl.Buffer(0.0);
     return unionAll;
 }

 public static IGeometry Circumcentre(IGeometry g)
 {
     Coordinate[] pts = TrianglePts(g);
     Coordinate cc = Triangle.Circumcentre(pts[0], pts[1], pts[2]);
     IGeometryFactory geomFact = FunctionsUtil.GetFactoryOrDefault(g);
     return geomFact.CreatePoint(cc);
 }

 private static Coordinate[] TrianglePts(IGeometry g)
 {
     Coordinate[] pts = g.Coordinates;
     if (pts.Length < 3)
         throw new ArgumentException("Input geometry must have at least 3 points");
     return pts;
 }

        public static IGeometry BufferMitredJoin(IGeometry g, double distance)
        {
            BufferParameters bufParams = new BufferParameters();
            bufParams.JoinStyle = JoinStyle.Mitre;

            return BufferOp.Buffer(g, distance, bufParams);
        }

 /// <summary>
 ///
 /// </summary>
 /// <param name="p"></param>
 /// <param name="geom"></param>
 private void ComputeLocation(Coordinate p, IGeometry geom)
 {
     if (geom is ILineString)
         UpdateLocationInfo(Locate(p, geom));
     else if (geom is IPolygon)
         UpdateLocationInfo(Locate(p, geom));
     else if (geom is IMultiLineString)
     {
         IMultiLineString ml = (IMultiLineString)geom;
         foreach (ILineString l in ml.Geometries)
             UpdateLocationInfo(Locate(p, l));
     }
     else if (geom is IMultiPolygon)
     {
         IMultiPolygon mpoly = (IMultiPolygon)geom;
         foreach (IPolygon poly in mpoly.Geometries)
             UpdateLocationInfo(Locate(p, poly));
     }
     else if (geom is IGeometryCollection)
     {
         IEnumerator geomi = new GeometryCollection.Enumerator((IGeometryCollection)geom);
         while (geomi.MoveNext())
         {
             IGeometry g2 = (IGeometry)geomi.Current;
             if (g2 != geom)
                 ComputeLocation(p, g2);
         }
     }
 }

		public SimplePointCursor(string filePath, IFields fields, int OID, 
			System.Array fieldMap, IEnvelope queryEnv, esriGeometryType geomType)	
		{
			//HIGHLIGHT: 0 - Set up cursor
			m_bIsFinished = false;
			m_pStreamReader = new System.IO.StreamReader(filePath);
			m_fields = fields;
			m_iOID = OID;
			m_fieldMap = fieldMap;
			m_searchEnv = queryEnv;
			switch (geomType)
			{
				case esriGeometryType.esriGeometryPolygon:
					m_wkGeom = new Polygon() as IGeometry;
					m_workPts = new PointClass[5];
					for (int i = 0; i < m_workPts.Length; i++)
						m_workPts[i] = new PointClass();
					break;
				case esriGeometryType.esriGeometryPolyline:
					m_wkGeom = new PolylineClass() as IGeometry;
					m_workPts = new PointClass[5];
					for (int i = 0; i < m_workPts.Length; i++)
						m_workPts[i] = new PointClass();
					break;
				
				case esriGeometryType.esriGeometryPoint:
					m_wkGeom = new PointClass() as IGeometry;
					break;
				default:	//doesn't need to set worker geometry if it is table 
					break;
			}

			//advance cursor so data is readily available
			this.NextRecord();
		}

 /// <summary>
 /// ���캯��
 /// </summary>
 /// <param name="bRead">�Ƿ��Ƕ�ȡ</param>
 /// <param name="strFilePathName">�����ļ�����</param>
 /// <param name="pCutGeometry">���з�Χ</param>
 /// <param name="pCutGeometry">���з�Χ</param>
 public MDBFile(bool bRead, string strFilePathName,bool bCut,IGeometry pCutGeometry)
 {
     this.m_bRead = bRead;
     this.m_strFilePathName = strFilePathName;
     base.m_dataType = ArcDataType.MDB;
     base.m_CutGeometry = pCutGeometry;
     base.m_bCut = bCut;
     if (this.m_bRead == true)
     {
         //�ж�MDB�ļ��Ƿ����
         if (File.Exists(this.m_strFilePathName) == true)
         {
             //����MDB����Դ
             this.Workspace = ConnectWorkspace();
         }
     }
     else
     {
         //�ж�MDB�ļ��Ƿ����
         if (File.Exists(this.m_strFilePathName) == true)
         {
             //����MDB����Դ
             this.Workspace = ConnectWorkspace();
         }
         else
         {
             //����MDB����Դ
             this.Workspace = CreateWorkspace();
         }
     }
 }

		/// <summary>
		/// Writes a geometry to a byte array using the specified encoding.
		/// </summary>
		/// <param name="g">The geometry to write</param>
		/// <param name="wkbByteOrder">Byte order</param>
		/// <returns>WKB representation of the geometry</returns>
		public static byte[] Write(IGeometry geometry, WkbByteOrder wkbByteOrder)
		{
			byte[] result = null;
			switch (wkbByteOrder)
			{
				case WkbByteOrder.Ndr:
					result = new WKBWriter(ByteOrder.LittleEndian).Write(geometry);
					break;
				case WkbByteOrder.Xdr:
					result = new WKBWriter(ByteOrder.BigEndian).Write(geometry);
					break;
			}
			return result;
			
//			MemoryStream ms = new MemoryStream();
//			BinaryWriter bw = new BinaryWriter(ms);
//
//			//Write the byteorder format.
//			bw.Write((byte)wkbByteOrder);
//
//			//Write the type of this geometry
//			WriteType(g, bw, wkbByteOrder);
//
//			//Write the geometry
//			WriteGeometry(g, bw, wkbByteOrder);
//
//			return ms.ToArray();
		}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="g0"></param>
        public GeometryGraphOperation(IGeometry g0) 
        {
            ComputationPrecision = g0.PrecisionModel;

            arg = new GeometryGraph[1];
            arg[0] = new GeometryGraph(0, g0);;
        }

        public virtual void Move(IGeometry targetGeometry, IGeometry sourceGeometry, IList<IGeometry> geometries, IList<int> handleIndices, 
                         int mouseIndex, double deltaX, double deltaY)
        {
            if ((targetGeometry != null) && (sourceGeometry != null))
            {
                if (targetGeometry.Coordinates.Length != sourceGeometry.Coordinates.Length)
                {
                    throw new ArgumentException("Source and target geometries should have same number of coordinates.");
                }

                //for performance reasons, get the coordinates once: for example for polygons this is a heavy call
                var targetCoordinates = targetGeometry.Coordinates; 
                var sourceCoordinates = sourceGeometry.Coordinates;

                for (int i = 0; i < handleIndices.Count; i++)
                {
                    GeometryHelper.MoveCoordinate(targetCoordinates, sourceCoordinates, handleIndices[i], deltaX, deltaY);
                    targetGeometry.GeometryChangedAction();

                    if (null != geometries)
                    {
                        IGeometry tracker = geometries[handleIndices[i]];
                        GeometryHelper.MoveCoordinate(tracker, 0, deltaX, deltaY);
                        tracker.GeometryChangedAction();
                    }
                }
            }
        }

 public static bool IsValid(IGeometry g, double distance, IGeometry result)
 {
     BufferResultValidator validator = new BufferResultValidator(g, distance, result);
     if (validator.IsValid())
         return true;
     return false;
 }

        /// <summary>
        /// Writes a geometry to a byte array using the specified encoding.
        /// </summary>
        /// <param name="g">The geometry to write</param>
        /// <param name="wkbByteOrder">Byte order</param>
        /// <returns>WKB representation of the geometry</returns>
        public static byte[] Write(IGeometry g, WkbByteOrder wkbByteOrder)
        {
            ByteOrder order;
            switch (wkbByteOrder)
            {
                case WkbByteOrder.Xdr:
                    order = ByteOrder.BigEndian;
                    break;
                case WkbByteOrder.Ndr:
                    order = ByteOrder.LittleEndian;
                    break;
                default:
                    throw new ArgumentOutOfRangeException("wkbByteOrder");
            }

            WKBWriter wkb = new WKBWriter(order);
            return wkb.Write(g);

            /*
            MemoryStream ms = new MemoryStream();
            BinaryWriter bw = new BinaryWriter(ms);

            //Write the byteorder format.
            bw.Write((byte) wkbByteOrder);

            //Write the type of this geometry
            WriteType(g, bw, wkbByteOrder);

            //Write the geometry
            WriteGeometry(g, bw, wkbByteOrder);

            return ms.ToArray();
            */
        }