/// <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>
        /// 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();
            */
        }

 private Geometry ToBinaryAndBack(Geometry gIn, WkbByteOrder byteOrder)
 {
     MemoryStream stream = new MemoryStream();
     BinaryWriter writer = new BinaryWriter(stream);
     writer.Write(GeometryToWKB.Write(gIn, byteOrder));
     BinaryReader reader = new BinaryReader(stream);
     stream.Position = 0;
     Geometry gOut = GeometryFromWKB.Parse(reader);
     return gOut;
 }

 /// <summary>
 /// Writes a double to the stream
 /// </summary>
 /// <param name="value">Value to write</param>
 /// <param name="writer">Binary Writer</param>
 /// <param name="byteOrder">byteorder</param>
 private static void WriteDouble(double value, BinaryWriter writer, WkbByteOrder byteOrder)
 {
     if (byteOrder == WkbByteOrder.Xdr)
     {
         byte[] bytes = BitConverter.GetBytes(value);
         Array.Reverse(bytes);
         writer.Write(BitConverter.ToDouble(bytes, 0));
     }
     else
         writer.Write(value);
 }

        /// <summary>
        /// Read double value from reader
        /// </summary>
        /// <param name="reader">Stream Reader</param>
        /// <param name="byteOrder">Byte order</param>
        /// <returns>Double value</returns>
        private static double ReadDouble(BinaryReader reader, WkbByteOrder byteOrder)
        {
            if (byteOrder == WkbByteOrder.Xdr)
            {
                byte[] bytes = BitConverter.GetBytes(reader.ReadDouble());
                Array.Reverse(bytes);
                return BitConverter.ToDouble(bytes, 0);
            }

            if (byteOrder == WkbByteOrder.Ndr)
            {
                return reader.ReadDouble();
            }

            throw new ArgumentException("Byte order not recognized");
        }

        //private const byte WKBByteOrder = 0;
        /// <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(Geometry g, WkbByteOrder wkbByteOrder = WkbByteOrder.Ndr)
        {
            var ms = new MemoryStream();
            var 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>
 /// Write the geometry
 /// </summary>
 /// <param name="geometry">Geometry</param>
 /// <param name="writer">BinaryWriter</param>
 /// <param name="byteOrder">Byte order</param>
 private static void WriteGeometry(IGeometry geometry, BinaryWriter writer, WkbByteOrder byteOrder)
 {
     if (geometry is IMapPoint)
     {
         WriteUInt32((uint) WkbGeometryTypes.WkbPoint, writer, byteOrder);
         WriteMapPoint(geometry as IMapPoint, writer, byteOrder);
     }
     else if(geometry is ILinearRing)
     {
         WriteUInt32((uint)WkbGeometryTypes.WkbLineString, writer, byteOrder);
         WriteLineString(geometry as ILineString, writer, byteOrder);
     }
     else if(geometry is IPolygon)
     {
         WriteUInt32((uint)WkbGeometryTypes.WkbPolygon, writer, byteOrder);
         WritePolygon(geometry as IPolygon, writer, byteOrder);
     }
     else
     {
         throw new ArgumentOutOfRangeException("geometry", "Geometry not supported.");
     }
 }

        private static GraphicsPath CreateWKBMultiPolygon(BinaryReader reader, WkbByteOrder byteOrder, Func<System.Windows.Point, System.Windows.Point> geoToPixel)
        {
            GraphicsPath gp = new GraphicsPath();

            // Get the number of Polygons.
            int numPolygons = (int)ReadUInt32(reader, byteOrder);

            // Loop on the number of polygons.
            for (int i = 0; i < numPolygons; i++)
            {
                // read polygon header
                reader.ReadByte();
                ReadUInt32(reader, byteOrder);

                // TODO: Validate type

                // Create the next polygon and add it to the array.
                gp.AddPath(CreateWKBPolygon(reader, byteOrder, geoToPixel), false);
            }

            //Create and return the MultiPolygon.
            return gp;
        }

 /// <summary>
 /// Writes the geometry to the binary writer.
 /// </summary>
 /// <param name="geometry">The geometry to be written.</param>
 /// <param name="bWriter"></param>
 /// <param name="byteorder">Byte order</param>
 private static void WriteGeometry(IGeometry geometry, BinaryWriter bWriter, WkbByteOrder byteorder)
 {
     switch (geometry.OgcGeometryType)
     {
             //Write the point.
         case OgcGeometryType.Point:
             WritePoint((IPoint) geometry, bWriter, byteorder);
             break;
         case OgcGeometryType.LineString:
             var ls = (ILineString) geometry;
             WriteLineString(ls, bWriter, byteorder);
             break;
         case OgcGeometryType.Polygon:
             WritePolygon((IPolygon) geometry, bWriter, byteorder);
             break;
             //Write the Multipoint.
         case OgcGeometryType.MultiPoint:
             WriteMultiPoint((IMultiPoint) geometry, bWriter, byteorder);
             break;
             //Write the Multilinestring.
         case OgcGeometryType.MultiLineString:
             WriteMultiLineString((IMultiLineString) geometry, bWriter, byteorder);
             break;
             //Write the Multipolygon.
         case OgcGeometryType.MultiPolygon:
             WriteMultiPolygon((IMultiPolygon) geometry, bWriter, byteorder);
             break;
             //Write the Geometrycollection.
         case OgcGeometryType.GeometryCollection:
             WriteGeometryCollection((IGeometryCollection) geometry, bWriter, byteorder);
             break;
             //If the type is not of the above 7 throw an exception.
         default:
             throw new ArgumentException("Invalid Geometry Type");
     }
 }

        /// <summary>
        /// Writes a geometrycollection.
        /// </summary>
        /// <param name="gc">The geometrycollection to be written.</param>
        /// <param name="bWriter">Stream to write to.</param>
        /// <param name="byteorder">Byte order</param>
        private static void WriteGeometryCollection(IGeometryCollection gc, BinaryWriter bWriter, WkbByteOrder byteorder)
        {
            //Get the number of geometries in this geometrycollection.
            var num = gc.NumGeometries;

            //Write the number of geometries.
            WriteUInt32((uint) num, bWriter, byteorder);

            //Loop on the number of geometries.
            //NOTE: by contract, the first item returned 
            //      from GetEnumerator (i.e. using foreach) is the IGeometryCollection itself!
            for (var i = 0; i < num; i++)
            {
                IGeometry geom = gc.GetGeometryN(i);
                //Write the byte-order format of the following geometry.
                bWriter.Write((byte) byteorder);
                //Write the type of each geometry.                
                WriteType(geom, bWriter, byteorder);
                //Write each geometry.
                WriteGeometry(geom, bWriter, byteorder);
            }
        }

        /// <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>
        /// Writes a multilinestring.
        /// </summary>
        /// <param name="mls">The multilinestring to be written.</param>
        /// <param name="bWriter">Stream to write to.</param>
        /// <param name="byteorder">Byte order</param>
        private static void WriteMultiLineString(IMultiLineString mls, BinaryWriter bWriter, WkbByteOrder byteorder)
        {
            //Write the number of linestrings.
            int num = mls.NumGeometries;
            WriteUInt32((uint) num, bWriter, byteorder);

            //Loop on the number of linestrings. 
            //NOTE: by contract, the first item returned 
            //      from GetEnumerator (i.e. using foreach) is the IMultiLineString itself!
            for (int i = 0; i < num; i++)
            {
                ILineString ls = (ILineString) mls.GetGeometryN(i);
                //Write LineString Header
                bWriter.Write((byte)byteorder);
                WriteUInt32((uint)WKBGeometryType.wkbLineString, bWriter, byteorder);
                //Write each linestring.
                WriteLineString(ls, bWriter, byteorder);
            }
        }

        private static Geometry CreateWKBGeometryCollection(BinaryReader reader, WkbByteOrder byteOrder)
        {
            // The next byte in the array tells the number of geometries in this collection.
            int numGeometries = (int) ReadUInt32(reader, byteOrder);

            // Create a new array for the geometries.
            GeometryCollection geometries = new GeometryCollection();

            // Loop on the number of geometries.
            for (int i = 0; i < numGeometries; i++)
            {
                // Call the main create function with the next geometry.
                geometries.Collection.Add(Parse(reader));
            }

            // Create and return the next geometry.
            return geometries;
        }

        private static MultiLineString CreateWKBMultiLineString(BinaryReader reader, WkbByteOrder byteOrder)
        {
            // Get the number of linestrings in this multilinestring.
            int numLineStrings = (int) ReadUInt32(reader, byteOrder);

            // Create a new array for the linestrings .
            MultiLineString mline = new MultiLineString();

            // Loop on the number of linestrings.
            for (int i = 0; i < numLineStrings; i++)
            {
                // Read linestring header
                reader.ReadByte();
                ReadUInt32(reader, byteOrder);

                // Create the next linestring and add it to the array.
                mline.LineStrings.Add(CreateWKBLineString(reader, byteOrder));
            }

            // Create and return the MultiLineString.
            return mline;
        }

        private static Polygon CreateWKBPolygon(BinaryReader reader, WkbByteOrder byteOrder)
        {
            // Get the Number of rings in this Polygon.
            int numRings = (int) ReadUInt32(reader, byteOrder);

            Debug.Assert(numRings >= 1, "Number of rings in polygon must be 1 or more.");

            Polygon shell = new Polygon(CreateWKBLinearRing(reader, byteOrder));

            // Create a new array of linearrings for the interior rings.
            for (int i = 0; i < (numRings - 1); i++)
                shell.InteriorRings.Add(CreateWKBLinearRing(reader, byteOrder));

            // Create and return the Poylgon.
            return shell;
        }

        private static LineString CreateWKBLineString(BinaryReader reader, WkbByteOrder byteOrder)
        {
            LineString l = new LineString();
            //l.Vertices.AddRange(ReadCoordinates(reader, byteOrder));
            Point[] arrPoint = ReadCoordinates(reader, byteOrder);
            for (int i = 0; i < arrPoint.Length; i++)
                l.Vertices.Add(arrPoint[i]);

            return l;
        }

 private static Point CreateWKBPoint(BinaryReader reader, WkbByteOrder byteOrder)
 {
     // Create and return the point.
     return new Point(ReadDouble(reader, byteOrder), ReadDouble(reader, byteOrder));
 }

 /// <summary>
 /// Writes the type number for this geometry.
 /// </summary>
 /// <param name="geometry">The geometry to determine the type of.</param>
 /// <param name="bWriter">Binary Writer</param>
 /// <param name="byteorder">Byte order</param>
 private static void WriteType(IGeometry geometry, BinaryWriter bWriter, WkbByteOrder byteorder)
 {
     //Determine the type of the geometry.
     switch (geometry.OgcGeometryType)
     {
             //Points are type 1.
         case OgcGeometryType.Point:
             WriteUInt32((uint) WKBGeometryType.wkbPoint, bWriter, byteorder);
             break;
             //Linestrings are type 2.
         case OgcGeometryType.LineString:
             WriteUInt32((uint) WKBGeometryType.wkbLineString, bWriter, byteorder);
             break;
             //Polygons are type 3.
         case OgcGeometryType.Polygon:
             WriteUInt32((uint) WKBGeometryType.wkbPolygon, bWriter, byteorder);
             break;
             //Mulitpoints are type 4.
         case OgcGeometryType.MultiPoint:
             WriteUInt32((uint) WKBGeometryType.wkbMultiPoint, bWriter, byteorder);
             break;
             //Multilinestrings are type 5.
         case OgcGeometryType.MultiLineString:
             WriteUInt32((uint) WKBGeometryType.wkbMultiLineString, bWriter, byteorder);
             break;
             //Multipolygons are type 6.
         case OgcGeometryType.MultiPolygon:
             WriteUInt32((uint) WKBGeometryType.wkbMultiPolygon, bWriter, byteorder);
             break;
             //Geometrycollections are type 7.
         case OgcGeometryType.GeometryCollection:
             WriteUInt32((uint) WKBGeometryType.wkbGeometryCollection, bWriter, byteorder);
             break;
             //If the type is not of the above 7 throw an exception.
         default:
             throw new ArgumentException("Invalid Geometry Type");
     }
 }

        private static LinearRing CreateWKBLinearRing(BinaryReader reader, WkbByteOrder byteOrder)
        {
            //l.Vertices.AddRange(ReadCoordinates(reader, byteOrder));
            Point[] arrPoint = ReadCoordinates(reader, byteOrder);
            Coordinate clasurePoint = null;

            //if polygon isn't closed, add the first point to the end (this shouldn't occur for correct WKB data)
            if (arrPoint[0].X != arrPoint[arrPoint.Length - 1].X ||
                arrPoint[0].Y != arrPoint[arrPoint.Length - 1].Y)
            {
                clasurePoint = new Coordinate(arrPoint[0].X, arrPoint[0].Y);
            }

            Coordinate[] arrCoordinate;

            if (clasurePoint == null)
            {
                arrCoordinate = new Coordinate[arrPoint.Length];
            }
            else
            {
                arrCoordinate = new Coordinate[arrPoint.Length+1];
            }

            for (int i = 0; i < arrPoint.Length; i++)
                arrCoordinate[i] = new Coordinate(arrPoint[i].X, arrPoint[i].Y);

            if (clasurePoint != null)
                arrCoordinate[arrCoordinate.Length - 1] = clasurePoint;

            LinearRing l = new LinearRing(arrCoordinate);

            return l;
        }

        private static LineString CreateWKBLineString(BinaryReader reader, WkbByteOrder byteOrder)
        {
            //l.Vertices.AddRange(ReadCoordinates(reader, byteOrder));
            Point[] arrPoint = ReadCoordinates(reader, byteOrder);
            var arrCoordinate = new Coordinate[arrPoint.Length];

            for (int i = 0; i < arrPoint.Length; i++)
                arrCoordinate[i] = new Coordinate(arrPoint[i].X, arrPoint[i].Y);

            LineString l = new LineString(arrCoordinate);
            return l;
        }