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