/// <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;
}
private IEnumerable <MapPoint> ReadCoordinates(BinaryReader reader, WkbByteOrder byteOrder, WkbGeometryType type, SpatialReference spatialReference)
{
// Get the number of points in this linestring.
int numPoints = (int)readUInt32(reader, byteOrder);
// Loop on the number of points in the ring.
for (int i = 0; i < numPoints; i++)
{
yield return(ReadCoordinate(reader, byteOrder, type, null));
}
}
/// <summary>
/// Writes a linestring.
/// </summary>
/// <param name="ls">The linestring to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WriteLineString(LineString ls, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Write the number of points in this linestring.
WriteUInt32((uint)ls.Vertices.Count, bWriter, byteorder);
//Loop on each vertices.
foreach (Point p in ls.Vertices)
{
WritePoint(p, bWriter, byteorder);
}
}
/// <summary> Reads a double value from a binary. </summary>
/// <param name="reader"> The binary reader. </param>
/// <param name="byteOrder"> The byte order. </param>
/// <returns> The double value. </returns>
private static double ReadDouble(BinaryReader reader, WkbByteOrder byteOrder)
{
if (byteOrder != WkbByteOrder.Xdr)
{
return(reader.ReadDouble());
}
byte[] bytes = BitConverter.GetBytes(reader.ReadDouble());
Array.Reverse(bytes);
return(BitConverter.ToDouble(bytes, 0));
}
/// <summary> Reads an unsigned integer value from a binary. </summary>
/// <param name="reader"> The binary reader. </param>
/// <param name="byteOrder"> The byte order. </param>
/// <returns> The unsigned integer value. </returns>
private static uint ReadUInt32(BinaryReader reader, WkbByteOrder byteOrder)
{
if (byteOrder != WkbByteOrder.Xdr)
{
return(reader.ReadUInt32());
}
byte[] bytes = BitConverter.GetBytes(reader.ReadUInt32());
Array.Reverse(bytes);
return(BitConverter.ToUInt32(bytes, 0));
}
public static void WriteIntToStream(int value, Stream stream, WkbByteOrder byteOrder)
{
byte[] bytes = BitConverter.GetBytes(value);
if (byteOrder == WkbByteOrder.BigEndian)
{
Array.Reverse(bytes);
}
stream.Write(bytes, 0, 4);
}
/// <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);
}
private static LinearRing CreateWKBLinearRing(BinaryReader reader, WkbByteOrder byteOrder)
{
SharpMap.Geometries.LinearRing l = new SharpMap.Geometries.LinearRing();
l.Vertices.AddRange(ReadCoordinates(reader, byteOrder));
//if polygon isn't closed, add the first point to the end (this shouldn't occur for correct WKB data)
if (l.Vertices[0].X != l.Vertices[l.Vertices.Count - 1].X || l.Vertices[0].Y != l.Vertices[l.Vertices.Count - 1].Y)
{
l.Vertices.Add(new Point(l.Vertices[0].X, l.Vertices[0].Y));
}
return(l);
}
private static LineString CreateWKBLineString(BinaryReader reader, WkbByteOrder byteOrder)
{
LineString l = new LineString();
Point[] arrPoint = ReadCoordinates(reader, byteOrder);
for (int i = 0; i < arrPoint.Length; i++)
{
l.Vertices.Add(arrPoint[i]);
}
return(l);
}
private static Point[] ReadCoordinates(BinaryReader reader, WkbByteOrder byteOrder)
{
int numPoints = (int)ReadUInt32(reader, byteOrder);
Point[] coords = new Point[numPoints];
for (int i = 0; i < numPoints; i++)
{
coords[i] = new Point(ReadDouble(reader, byteOrder), ReadDouble(reader, byteOrder));
}
return(coords);
}
private static LineString CreateWKBLineString(BinaryReader reader, WkbByteOrder byteOrder)
{
SharpMap.Geometries.LineString l = new SharpMap.Geometries.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 Polygon ReadWkbPolygon(BinaryReader reader, WkbByteOrder byteOrder, WkbGeometryType type, SpatialReference spatialReference)
{
// Get the Number of rings in this Polygon.
int numRings = (int)readUInt32(reader, byteOrder);
List <IEnumerable <MapPoint> > rings = new List <IEnumerable <MapPoint> >();
foreach (var ring in CoordinateCollectionEnumerator(numRings, reader, byteOrder, type, null))
{
rings.Add(new List <MapPoint>(ring));
}
return(new Polygon(rings, spatialReference));
}
public static int ReadIntFromStream(Stream stream, WkbByteOrder byteOrder)
{
byte[] tempArray = new byte[4];
stream.Read(tempArray, 0, 4);
if (byteOrder == WkbByteOrder.BigEndian)
{
Array.Reverse(tempArray);
}
return(BitConverter.ToInt32(tempArray, 0));
}
private static Geometry CreateWKBGeometryCollection(BinaryReader reader, WkbByteOrder byteOrder)
{
int numGeometries = (int)ReadUInt32(reader, byteOrder);
GeometryCollection geometries = new GeometryCollection();
for (int i = 0; i < numGeometries; i++)
{
geometries.Collection.Add(Parse(reader));
}
return(geometries);
}
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);
}
}
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 an unsigned integer to the binarywriter using the specified encoding
/// </summary>
/// <param name="value">Value to write</param>
/// <param name="writer">Binary Writer</param>
/// <param name="byteOrder">byteorder</param>
private static void WriteUInt32(uint value, BinaryWriter writer, WkbByteOrder byteOrder)
{
if (byteOrder == WkbByteOrder.Xdr)
{
var bytes = BitConverter.GetBytes(value);
Array.Reverse(bytes);
writer.Write(BitConverter.ToUInt32(bytes, 0));
}
else
{
writer.Write(value);
}
}
/// <summary>
/// Create a Polygon
/// </summary>
/// <param name="reader">Stream</param>
/// <param name="byteOrder">Byte order</param>
/// <returns>IPolygon</returns>
private IPolygon CreatePolygon(BinaryReader reader, WkbByteOrder byteOrder)
{
var poly = this._geometryFactory.CreatePolygon();
var numRings = (int)ReadUInt32(reader, byteOrder);
for (int i = 0; i < numRings; i++)
{
poly.Rings.Add(this.CreateLinearRing(reader, byteOrder));
}
return(poly);
}
private static LineString CreateWKBLineString(BinaryReader reader, WkbByteOrder byteOrder)
{
var l = new LineString();
//l.Vertices.AddRange(ReadCoordinates(reader, byteOrder));
Point[] arrPoint = ReadCoordinates(reader, byteOrder);
foreach (Point t in arrPoint)
{
l.Vertices.Add(t);
}
return(l);
}
/// <summary>
/// Writes a linestring.
/// </summary>
/// <param name="ls">The linestring to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WriteLineString(ILineString ls, BinaryWriter bWriter, WkbByteOrder byteorder)
{
var vertices = ls.Coordinates;
//Write the number of points in this linestring.
WriteUInt32((uint)vertices.Length, bWriter, byteorder);
//Loop on each vertices.
foreach (var p in vertices)
{
WritePoint(p, bWriter, byteorder);
}
}
/// <summary>
/// Create a LinearRing
/// </summary>
/// <param name="reader">Stream</param>
/// <param name="byteOrder">Byte order</param>
/// <returns>ILinearRing</returns>
private ILinearRing CreateLinearRing(BinaryReader reader, WkbByteOrder byteOrder)
{
var line = this._geometryFactory.CreateLinearRing();
var numVertices = (int)ReadUInt32(reader, byteOrder);
for (int i = 0; i < numVertices; i++)
{
line.Vertices.Add(this.CreateMapPoint(reader, byteOrder));
}
return(line);
}
private static void WritePolygon(Polygon poly, BinaryWriter bWriter, WkbByteOrder byteorder)
{
int numRings = poly.InteriorRings.Count + 1;
WriteUInt32((uint)numRings, bWriter, byteorder);
WriteLineString(poly.ExteriorRing, bWriter, byteorder);
foreach (LinearRing lr in poly.InteriorRings)
{
WriteLineString(lr, bWriter, byteorder);
}
}
public static byte[] Write(Geometry g, WkbByteOrder wkbByteOrder)
{
MemoryStream ms = new MemoryStream();
BinaryWriter bw = new BinaryWriter(ms);
bw.Write((byte)wkbByteOrder);
WriteType(g, bw, wkbByteOrder);
WriteGeometry(g, bw, wkbByteOrder);
return(ms.ToArray());
}
private static uint ReadUInt32(BinaryReader reader, WkbByteOrder byteOrder)
{
if (byteOrder == WkbByteOrder.Xdr)
{
byte[] bytes = BitConverter.GetBytes(reader.ReadUInt32());
Array.Reverse(bytes);
return(BitConverter.ToUInt32(bytes, 0));
}
if (byteOrder == WkbByteOrder.Ndr)
{
return(reader.ReadUInt32());
}
throw new ArgumentException("Byte order not recognized");
}
private static MultiPoint CreateWKBMultiPoint(BinaryReader reader, WkbByteOrder byteOrder)
{
int numPoints = (int)ReadUInt32(reader, byteOrder);
MultiPoint points = new MultiPoint();
for (int i = 0; i < numPoints; i++)
{
reader.ReadByte();
ReadUInt32(reader, byteOrder);
points.Points.Add(CreateWKBPoint(reader, byteOrder));
}
return(points);
}
private static double ReadDouble(BinaryReader reader, WkbByteOrder byteOrder)
{
if (byteOrder == WkbByteOrder.Xdr)
{
var 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");
}
/// <summary>
/// Writes a multipoint.
/// </summary>
/// <param name="mp">The multipoint to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WriteMultiPoint(MultiPoint mp, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Write the number of points.
WriteUInt32((uint)mp.Points.Count, bWriter, byteorder);
//Loop on the number of points.
foreach (Point p in mp.Points)
{
//Write Points Header
bWriter.Write((byte)byteorder);
WriteUInt32((uint)WKBGeometryType.wkbPoint, bWriter, byteorder);
//Write each point.
WritePoint((Point)p, bWriter, byteorder);
}
}
private static Polygon CreateWKBPolygon(BinaryReader reader, WkbByteOrder byteOrder)
{
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));
for (int i = 0; i < (numRings - 1); i++)
{
shell.InteriorRings.Add(CreateWKBLinearRing(reader, byteOrder));
}
return(shell);
}
/// <summary>
/// Writes a polygon.
/// </summary>
/// <param name="poly">The polygon to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WritePolygon(Polygon poly, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Get the number of rings in this polygon.
var numRings = poly.Parts.Count;
//Write the number of rings to the stream (add one for the shell)
WriteUInt32((uint)numRings, bWriter, byteorder);
//Loop on the number of rings - agnostic of whether its the shell.
foreach (var pc in poly.Parts)
{
//Write the (lineString)LinearRing.
WriteLineString(pc.GetPoints(), 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(MultiPolygon mp, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Write the number of polygons.
WriteUInt32((uint)mp.Polygons.Count, bWriter, byteorder);
//Loop on the number of polygons.
foreach (Polygon poly in mp.Polygons)
{
//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(Polyline mls, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Write the number of linestrings.
WriteUInt32((uint)mls.Parts.Count, bWriter, byteorder);
//Loop on the number of linestrings.
foreach (var ls in mls.Parts.GetPartsAsPoints())
{
//Write LineString Header
bWriter.Write((byte)byteorder);
WriteUInt32((uint)WkbGeometryType.WkbLineString, bWriter, byteorder);
//Write each linestring.
WriteLineString(ls, bWriter, byteorder);
}
}
/// <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");
}
/// <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)
{
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 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;
}
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 MultiPoint CreateWKBMultiPoint(BinaryReader reader, WkbByteOrder byteOrder)
{
// Get the number of points in this multipoint.
int numPoints = (int) ReadUInt32(reader, byteOrder);
// Create a new array for the points.
MultiPoint points = new MultiPoint();
// Loop on the number of points.
for (int i = 0; i < numPoints; i++)
{
// Read point header
reader.ReadByte();
ReadUInt32(reader, byteOrder);
// TODO: Validate type
// Create the next point and add it to the point array.
points.Points.Add(CreateWKBPoint(reader, byteOrder));
}
return points;
}
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 LinearRing CreateWKBLinearRing(BinaryReader reader, WkbByteOrder byteOrder)
{
LinearRing l = new LinearRing();
//l.Vertices.AddRange(ReadCoordinates(reader, byteOrder));
Point[] arrPoint = ReadCoordinates(reader, byteOrder);
for (int i = 0; i < arrPoint.Length; i++)
l.Vertices.Add(arrPoint[i]);
//if polygon isn't closed, add the first point to the end (this shouldn't occur for correct WKB data)
if (l.Vertices[0].X != l.Vertices[l.Vertices.Count - 1].X ||
l.Vertices[0].Y != l.Vertices[l.Vertices.Count - 1].Y)
l.Vertices.Add(new Point(l.Vertices[0].X, l.Vertices[0].Y));
return l;
}
/// <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);
}
}
private static Point[] ReadCoordinates(BinaryReader reader, WkbByteOrder byteOrder)
{
// Get the number of points in this linestring.
int numPoints = (int) ReadUInt32(reader, byteOrder);
// Create a new array of coordinates.
Point[] coords = new Point[numPoints];
// Loop on the number of points in the ring.
for (int i = 0; i < numPoints; i++)
{
// Add the coordinate.
coords[i] = new Point(ReadDouble(reader, byteOrder), ReadDouble(reader, byteOrder));
}
return coords;
}
/// <summary>
/// Writes a point.
/// </summary>
/// <param name="point">The point to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WritePoint(Coordinate point, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Write the x coordinate.
WriteDouble(point.X, bWriter, byteorder);
//Write the y coordinate.
WriteDouble(point.Y, bWriter, byteorder);
}
/// <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");
}
}
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;
}
/// <summary>
/// Writes a point.
/// </summary>
/// <param name="point">The point to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WritePoint(IPoint point, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Write the coordinate.
WritePoint(point.Coordinate, bWriter, byteorder);
}
private static uint ReadUInt32(BinaryReader reader, WkbByteOrder byteOrder)
{
if (byteOrder == WkbByteOrder.Xdr)
{
byte[] bytes = BitConverter.GetBytes(reader.ReadUInt32());
Array.Reverse(bytes);
return BitConverter.ToUInt32(bytes, 0);
}
else if (byteOrder == WkbByteOrder.Ndr)
return reader.ReadUInt32();
else
throw new ArgumentException("Byte order not recognized");
}
/// <summary>
/// Writes a linestring.
/// </summary>
/// <param name="ls">The linestring to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WriteLineString(ILineString ls, BinaryWriter bWriter, WkbByteOrder byteorder)
{
var vertices = ls.Coordinates;
//Write the number of points in this linestring.
WriteUInt32((uint) vertices.Length, bWriter, byteorder);
//Loop on each vertices.
foreach (var p in vertices)
WritePoint(p, bWriter, byteorder);
}
/// <summary>
/// Writes a polygon.
/// </summary>
/// <param name="poly">The polygon to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WritePolygon(IPolygon poly, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Get the number of rings in this polygon.
var numRings = poly.NumInteriorRings + 1;
//Write the number of rings to the stream (add one for the shell)
WriteUInt32((uint) numRings, bWriter, byteorder);
//Write the exterior of this polygon.
WriteLineString(poly.ExteriorRing, bWriter, byteorder);
//Loop on the number of rings - 1 because we already wrote the shell.
foreach (ILinearRing lr in poly.InteriorRings)
//Write the (lineString)LinearRing.
WriteLineString(lr, bWriter, byteorder);
}
private static MultiPolygon CreateWKBMultiPolygon(BinaryReader reader, WkbByteOrder byteOrder)
{
// Get the number of Polygons.
int numPolygons = (int) ReadUInt32(reader, byteOrder);
// Create a new array for the Polygons.
MultiPolygon polygons = new MultiPolygon();
// 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.
polygons.Polygons.Add(CreateWKBPolygon(reader, byteOrder));
}
//Create and return the MultiPolygon.
return polygons;
}
private static Point CreateWKBPoint(BinaryReader reader, WkbByteOrder byteOrder)
{
// Create and return the point.
return new Point(ReadDouble(reader, byteOrder), ReadDouble(reader, 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;
}
/// <summary>
/// Writes a multipoint.
/// </summary>
/// <param name="mp">The multipoint to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WriteMultiPoint(IMultiPoint mp, BinaryWriter bWriter, WkbByteOrder byteorder)
{
var vertices = mp.Coordinates;
//Write the number of points.
WriteUInt32((uint) vertices.Length, bWriter, byteorder);
//Loop on the number of points.
foreach (var p in vertices)
{
//Write Points Header
bWriter.Write((byte) byteorder);
WriteUInt32((uint) WKBGeometryType.wkbPoint, bWriter, byteorder);
//Write each point.
WritePoint(p, 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 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;
}
/// <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");
}
}
/// <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);
}
}
