private static Polyline readMultiLineString(Stream stream, WKBByteOrder byteOrder)
{
int numLineStrings = (int)readUInt32(stream, byteOrder);
Polyline result = new Polyline();
result.Paths = new List <LinePath>((int)numLineStrings);
for (int i = 0; i < numLineStrings; i++)
{
// порядок байтов
stream.ReadByte();
// тип фигуры
readUInt32(stream, byteOrder);
// количество вершин
int numPoints = (int)readUInt32(stream, byteOrder);
result.Paths.Add(new LinePath());
// вершины
for (int j = 0; j < numPoints; j++)
{
result.Paths[i].Vertices.Add(PlanimetryEnvironment.NewCoordinate(readDouble(stream, byteOrder), readDouble(stream, byteOrder)));
}
}
return(result);
}
private static Polygon readMultiPolygon(Stream stream, WKBByteOrder byteOrder)
{
// количество полигонов
int numPolygons = (int)readUInt32(stream, byteOrder);
Polygon polygon = new Polygon();
// полигоны
for (int i = 0; i < numPolygons; i++)
{
// порядок байтов
stream.ReadByte();
// тип геометрической фигуры
readUInt32(stream, byteOrder);
// количество контуров
int numContours = (int)readUInt32(stream, byteOrder);
if (numContours < 1)
{
throw new ArgumentException(_degeneratePolygon, "stream");
}
for (int j = 0; j < numContours; j++)
{
polygon.Contours.Add(readContour(stream, byteOrder));
}
}
return(polygon);
}
/// <summary>
/// Serializes a geometry into stream using a specified byte order.
/// </summary>
/// <param name="stream">A stream instance</param>
/// <param name="geometry">A geometry to serialize</param>
/// /// <param name="byteOrder">A byte order which is used to write integer and double values</param>
public static void SerializeGeometry(Stream stream, IGeometry geometry, WKBByteOrder byteOrder)
{
if (geometry == null)
{
return;
}
if (geometry is PointD)
{
SerializePoint(stream, (PointD)geometry, byteOrder);
return;
}
if (geometry is Polyline)
{
SerializePolyline(stream, (Polyline)geometry, byteOrder);
return;
}
if (geometry is Polygon)
{
SerializePolygon(stream, (Polygon)geometry, byteOrder);
return;
}
if (geometry is MultiPoint)
{
SerializeMultiPoint(stream, (MultiPoint)geometry, byteOrder);
return;
}
throw new NotSupportedException("Geometry \"" + geometry.GetType().Name + "\" is not supported");
}
private static Polyline readLineString(Stream stream, WKBByteOrder byteOrder)
{
LinePath path = new LinePath();
path.Vertices = readCoordsList(stream, byteOrder);
Polyline pl = new Polyline();
pl.Paths.Add(path);
return(pl);
}
/// <summary>
/// Serializes a point geometry into stream using a specified byte order.
/// </summary>
/// <param name="stream">A stream instance</param>
/// <param name="point">A point geometry to serialize</param>
/// <param name="byteOrder">A byte order which is used to write integer and double values</param>
public static void SerializePoint(Stream stream, PointD point, WKBByteOrder byteOrder)
{
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.Point, stream, byteOrder);
// значения координат
writeDouble(point.X, stream, byteOrder);
writeDouble(point.Y, stream, byteOrder);
}
private static List <ICoordinate> readCoordsList(Stream stream, WKBByteOrder byteOrder)
{
int numPoints = (int)readUInt32(stream, byteOrder);
List <ICoordinate> result = new List <ICoordinate>(numPoints);
for (int i = 0; i < numPoints; i++)
{
result.Add(PlanimetryEnvironment.NewCoordinate(readDouble(stream, byteOrder), readDouble(stream, byteOrder)));
}
return(result);
}
/// <summary>
/// Writes a double value to stream using specified byte order.
/// </summary>
/// <param name="value">A double value to write</param>
/// <param name="stream">A stream instance</param>
/// <param name="byteOrder">A byte order</param>
private static void writeDouble(double value, Stream stream, WKBByteOrder byteOrder)
{
byte[] bytes = BitConverter.GetBytes(value);
if (byteOrder == WKBByteOrder.Xdr)
{
Array.Reverse(bytes);
stream.Write(bytes, 0, bytes.Length);
}
else
{
stream.Write(bytes, 0, bytes.Length);
}
}
private double ReadDouble(BinaryReader reader, WKBByteOrder byteOrder)
{
if (byteOrder == WKBByteOrder.Xdr)
{
byte[] bytes = BitConverter.GetBytes(reader.ReadDouble());
Array.Reverse(bytes);
return(BitConverter.ToDouble(bytes, 0));
}
else
{
return(reader.ReadDouble());
}
}
private 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
{
return(reader.ReadUInt32());
}
}
private void Write(double value, 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 void writeContour(Stream stream, Contour contour, WKBByteOrder byteOrder)
{
// количество вершин
writeUInt32((uint)contour.Vertices.Count + 1, stream, byteOrder);
// вершины
foreach (ICoordinate p in contour.Vertices)
{
writeDouble(p.X, stream, byteOrder);
writeDouble(p.Y, stream, byteOrder);
}
writeDouble(contour.Vertices[0].X, stream, byteOrder);
writeDouble(contour.Vertices[0].Y, stream, byteOrder);
}
private static void writeLineString(Stream stream, LinePath part, WKBByteOrder byteOrder)
{
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.LineString, stream, byteOrder);
// количество вершин
writeUInt32((uint)part.Vertices.Count, stream, byteOrder);
// вершины
foreach (ICoordinate p in part.Vertices)
{
writeDouble(p.X, stream, byteOrder);
writeDouble(p.Y, stream, byteOrder);
}
}
private static double readDouble(Stream stream, WKBByteOrder byteOrder)
{
byte[] bytes = new byte[sizeof(double)];
stream.Read(bytes, 0, sizeof(double));
if (byteOrder == WKBByteOrder.Xdr)
{
Array.Reverse(bytes);
}
else
if (byteOrder != WKBByteOrder.Ndr)
{
throw new ArgumentException(_unrecognizedByteOrder);
}
return(BitConverter.ToDouble(bytes, 0));
}
private Coordinate[] ReadCoordinates(BinaryReader reader, WKBByteOrder byteOrder)
{
// Get the number of points in this linestring.
int numPoints = (int)this.ReadUInt32(reader, byteOrder);
// Create a new array of coordinates.
Coordinate[] coords = new Coordinate[numPoints];
// Loop on the number of points in the ring.
for (int i = 0; i < numPoints; i++)
{
// Add the coordinate.
coords[i] = new Coordinate(this.ReadDouble(reader, byteOrder), this.ReadDouble(reader, byteOrder));
}
return(coords);
}
/// <summary>
/// Returns a byte[] containing the supplied <b>Geometry</b> object's Well-known binary representation.
/// </summary>
/// <param name="geometry">The <b>Geometry</b> object.</param>
/// <param name="factory">The <b>GeometryFactory</b>.</param>
/// <param name="byteOrder">The desired <see cref="WKBByteOrder">WKBByteOrder</see>.</param>
/// <returns>A byte[] containing the supplied <b>Geometry</b> object's Well-known binary representation.</returns>
public static byte[] GetBytes(Geometry geometry, GeometryFactory factory, WKBByteOrder byteOrder)
{
if (geometry == null)
{
throw new ArgumentNullException("geometry");
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
{
new GeometryWKBWriter(writer, factory).WriteGeometry(geometry, byteOrder);
return(ms.ToArray());
}
}
}
private void WritePoint(Point point, WKBByteOrder byteOrder, bool writeHeader)
{
if (writeHeader)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(point, byteOrder);
}
// Write the x coordinate.
this.Write(point.getX(), byteOrder);
// Write the y coordinate.
this.Write(point.getY(), byteOrder);
}
/// <summary>
/// Returns a byte[] containing the supplied <b>Geometry</b> object's Well-known binary representation.
/// </summary>
/// <param name="geometry">The <b>Geometry</b> object.</param>
/// <param name="factory">The <b>GeometryFactory</b>.</param>
/// <param name="byteOrder">The desired <see cref="WKBByteOrder">WKBByteOrder</see>.</param>
/// <returns>A byte[] containing the supplied <b>Geometry</b> object's Well-known binary representation.</returns>
public static byte[] GetBytes(Geometry geometry, GeometryFactory factory, WKBByteOrder byteOrder)
{
if (geometry == null)
{
throw new ArgumentNullException("geometry");
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
{
new GeometryWKBWriter(writer, factory).WriteGeometry(geometry, byteOrder);
return ms.ToArray();
}
}
}
private static MultiPoint readMultiPoint(Stream stream, WKBByteOrder byteOrder)
{
MultiPoint multiPoint = new MultiPoint();
int numPoints = (int)readUInt32(stream, byteOrder);
for (int i = 0; i < numPoints; i++)
{
// порядок байтов
stream.ReadByte();
// тип фигуры
readUInt32(stream, byteOrder);
multiPoint.Points.Add(PlanimetryEnvironment.NewCoordinate(readDouble(stream, byteOrder), readDouble(stream, byteOrder)));
}
return(multiPoint);
}
private void WriteMultiLineString(MultiLineString mls, WKBByteOrder byteOrder)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(mls, byteOrder);
//Write the number of linestrings.
this.Write((uint)mls.getNumGeometries(), byteOrder);
//Loop on the number of linestrings.
for (int i = 0; i < mls.getNumGeometries(); i++)
{
// Write each linestring.
this.WriteLineString((LineString)mls.getGeometryN(i), byteOrder, true);
}
}
private Geometry CreateWKBGeometryCollection(BinaryReader reader, WKBByteOrder byteOrder)
{
// The next byte in the array tells the number of geometries in this collection.
int numGeometries = (int)this.ReadUInt32(reader, byteOrder);
// Create a new array for the geometries.
Geometry[] geometries = new Geometry[numGeometries];
// Loop on the number of geometries.
for (int i = 0; i < numGeometries; i++)
{
// Call the main create function with the next geometry.
geometries[i] = this.Create(reader);
}
// Create and return the next geometry.
return(_factory.createGeometryCollection(geometries));
}
private void WriteGeometryCollection(GeometryCollection gc, WKBByteOrder byteOrder)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(gc, byteOrder);
// Write the number of geometries.
this.Write((uint)gc.getNumGeometries(), byteOrder);
// Loop on the number of geometries.
for (int i = 0; i < gc.getNumGeometries(); i++)
{
// Write each geometry.
this.WriteGeometry(gc.getGeometryN(i), byteOrder);
}
}
private static Polygon readPolygon(Stream stream, WKBByteOrder byteOrder)
{
int numContours = (int)readUInt32(stream, byteOrder);
if (numContours < 1)
{
throw new ArgumentException(_degeneratePolygon, "stream");
}
Polygon polygon = new Polygon();
for (int i = 0; i < numContours; i++)
{
polygon.Contours.Add(readContour(stream, byteOrder));
}
return(polygon);
}
private static Contour readContour(Stream stream, WKBByteOrder byteOrder)
{
Contour c = new Contour();
c.Vertices = readCoordsList(stream, byteOrder);
int cnt = c.Vertices.Count - 1;
if (c.Vertices[0].Equals(c.Vertices[cnt]))
{
c.Vertices.RemoveAt(cnt);
}
//if (c.Vertices.Count < 3)
// throw new ArgumentException("Degenerate contour.", "stream");
return(c);
}
private Polygon CreateWKBPolygon(BinaryReader reader, WKBByteOrder byteOrder)
{
// Get the Number of rings in this Polygon.
int numRings = (int)this.ReadUInt32(reader, byteOrder);
Debug.Assert(numRings >= 1, "Number of rings in polygon must be 1 or more.");
LinearRing shell = this.CreateWKBLinearRing(reader, byteOrder);
// Create a new array of linearrings for the interior rings.
LinearRing[] interiorRings = new LinearRing[numRings - 1];
for (int i = 0; i < (numRings - 1); i++)
{
interiorRings[i] = this.CreateWKBLinearRing(reader, byteOrder);
}
// Create and return the Poylgon.
return(_factory.createPolygon(shell, interiorRings));
}
private void WriteMultiPolygon(MultiPolygon mp, WKBByteOrder byteOrder)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(mp, byteOrder);
// Get the number of polygons in this multipolygon.
int numpolygons = mp.getNumGeometries();
// Write the number of polygons.
this.Write((uint)numpolygons, byteOrder);
for (int i = 0; i < numpolygons; i++)
{
// Write each polygon.
this.WritePolygon((Polygon)mp.getGeometryN(i), byteOrder);
}
}
private void WriteLineString(LineString ls, WKBByteOrder byteOrder, bool writeHeader)
{
if (writeHeader)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(ls, byteOrder);
}
// Write the number of points in this linestring.
this.Write((uint)ls.getNumPoints(), byteOrder);
// Loop on each set of coordinates.
foreach (Coordinate coord in ls.getCoordinates())
{
// Create a new point from the coordinates & write it.
WritePoint(_factory.createPoint(coord), byteOrder, false);
}
}
private void WriteMultiPoint(MultiPoint mp, WKBByteOrder byteOrder)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(mp, byteOrder);
// Get the number of points in this multipoint.
int numPoints = mp.getNumPoints();
// Write the number of points.
this.Write((uint)numPoints, byteOrder);
// Loop on the number of points.
for (int i = 0; i < numPoints; i++)
{
// Write each point.
this.WritePoint((Point)mp.getGeometryN(i), byteOrder, true);
}
}
/// <summary>
/// Serializes a multipoint geometry into stream using a specified byte order.
/// </summary>
/// <param name="stream">A stream instance</param>
/// <param name="multiPoint">A multipoint geometry to serialize</param>
/// <param name="byteOrder">A byte order which is used to write integer and double values</param>
public static void SerializeMultiPoint(Stream stream, MultiPoint multiPoint, WKBByteOrder byteOrder)
{
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.MultiPoint, stream, byteOrder);
// количество вершин
writeUInt32((uint)multiPoint.Points.Count, stream, byteOrder);
// вершины
foreach (ICoordinate p in multiPoint.Points)
{
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.Point, stream, byteOrder);
writeDouble(p.X, stream, byteOrder);
writeDouble(p.Y, stream, byteOrder);
}
}
private void WritePolygon(Polygon poly, WKBByteOrder byteOrder)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(poly, byteOrder);
// Get the number of rings in this polygon.
int numRings = poly.getNumInteriorRing() + 1;
// Write the number of rings to the stream (add one for the shell)
this.Write((uint)numRings, byteOrder);
// Get the shell of this polygon.
this.WriteLineString(poly.getExteriorRing(), byteOrder, false);
// Loop on the number of rings - 1 because we already wrote the shell.
for (int i = 0; i < numRings - 1; i++)
{
this.WriteLineString(poly.getInteriorRingN(i), byteOrder, false);
}
}
/// <summary>
/// Serializes a polyline geometry into stream using a specified byte order.
/// </summary>
/// <param name="stream">A stream instance</param>
/// <param name="polyline">A polyline geometry to serialize</param>
/// <param name="byteOrder">A byte order which is used to write integer and double values</param>
public static void SerializePolyline(Stream stream, Polyline polyline, WKBByteOrder byteOrder)
{
if (polyline == null)
{
return;
}
if (polyline.Paths.Count == 0)
{
throw new ArgumentException("Polyline must contain at least two points", "polyline");
}
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
if (polyline.Paths.Count == 1)
{
writeLineString(stream, polyline.Paths[0], byteOrder);
}
else
{
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.MultiLineString, stream, byteOrder);
// количество частей полилинии
writeUInt32((uint)polyline.Paths.Count, stream, byteOrder);
// части
foreach (LinePath path in polyline.Paths)
{
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
writeLineString(stream, path, byteOrder);
}
}
}
private MultiPolygon CreateWKBMultiPolygon(BinaryReader reader, WKBByteOrder byteOrder)
{
// Get the number of Polygons.
int numPolygons = (int)this.ReadUInt32(reader, byteOrder);
// Create a new array for the Polygons.
Polygon[] polygons = new Polygon[numPolygons];
// Loop on the number of polygons.
for (int i = 0; i < numPolygons; i++)
{
// read polygon header
reader.ReadByte();
this.ReadUInt32(reader, byteOrder);
// TODO: Validate type
// Create the next polygon and add it to the array.
polygons[i] = this.CreateWKBPolygon(reader, byteOrder);
}
//Create and return the MultiPolygon.
return(_factory.createMultiPolygon(polygons));
}
private void WriteMultiLineString(MultiLineString mls, WKBByteOrder byteOrder)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(mls, byteOrder);
//Write the number of linestrings.
this.Write((uint)mls.getNumGeometries(), byteOrder);
//Loop on the number of linestrings.
for (int i = 0; i < mls.getNumGeometries(); i++)
{
// Write each linestring.
this.WriteLineString((LineString)mls.getGeometryN(i), byteOrder, true);
}
}
private static PointD readPoint(Stream stream, WKBByteOrder byteOrder)
{
return new PointD(PlanimetryEnvironment.NewCoordinate(readDouble(stream, byteOrder), readDouble(stream, byteOrder)));
}
private static Polyline readLineString(Stream stream, WKBByteOrder byteOrder)
{
LinePath path = new LinePath();
path.Vertices = readCoordsList(stream, byteOrder);
Polyline pl = new Polyline();
pl.Paths.Add(path);
return pl;
}
private static List<ICoordinate> readCoordsList(Stream stream, WKBByteOrder byteOrder)
{
int numPoints = (int)readUInt32(stream, byteOrder);
List<ICoordinate> result = new List<ICoordinate>(numPoints);
for (int i = 0; i < numPoints; i++)
result.Add(PlanimetryEnvironment.NewCoordinate(readDouble(stream, byteOrder), readDouble(stream, byteOrder)));
return result;
}
private static Polyline readMultiLineString(Stream stream, WKBByteOrder byteOrder)
{
int numLineStrings = (int)readUInt32(stream, byteOrder);
Polyline result = new Polyline();
result.Paths = new List<LinePath>((int)numLineStrings);
for (int i = 0; i < numLineStrings; i++)
{
// порядок байтов
stream.ReadByte();
// тип фигуры
readUInt32(stream, byteOrder);
// количество вершин
int numPoints = (int)readUInt32(stream, byteOrder);
result.Paths.Add(new LinePath());
// вершины
for (int j = 0; j < numPoints; j++)
result.Paths[i].Vertices.Add(PlanimetryEnvironment.NewCoordinate(readDouble(stream, byteOrder), readDouble(stream, byteOrder)));
}
return result;
}
private static Polygon readPolygon(Stream stream, WKBByteOrder byteOrder)
{
int numContours = (int)readUInt32(stream, byteOrder);
if (numContours < 1)
throw new ArgumentException(_degeneratePolygon, "stream");
Polygon polygon = new Polygon();
for (int i = 0; i < numContours; i++)
polygon.Contours.Add(readContour(stream, byteOrder));
return polygon;
}
private void WriteMultiPolygon(MultiPolygon mp, WKBByteOrder byteOrder)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(mp, byteOrder);
// Get the number of polygons in this multipolygon.
int numpolygons = mp.getNumGeometries();
// Write the number of polygons.
this.Write((uint)numpolygons, byteOrder);
for (int i = 0; i < numpolygons; i++)
{
// Write each polygon.
this.WritePolygon((Polygon)mp.getGeometryN(i), byteOrder);
}
}
private static Contour readContour(Stream stream, WKBByteOrder byteOrder)
{
Contour c = new Contour();
c.Vertices = readCoordsList(stream, byteOrder);
int cnt = c.Vertices.Count - 1;
if (c.Vertices[0].Equals(c.Vertices[cnt]))
c.Vertices.RemoveAt(cnt);
//if (c.Vertices.Count < 3)
// throw new ArgumentException("Degenerate contour.", "stream");
return c;
}
private static void writeLineString(Stream stream, LinePath part, WKBByteOrder byteOrder)
{
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.LineString, stream, byteOrder);
// количество вершин
writeUInt32((uint)part.Vertices.Count, stream, byteOrder);
// вершины
foreach (ICoordinate p in part.Vertices)
{
writeDouble(p.X, stream, byteOrder);
writeDouble(p.Y, stream, byteOrder);
}
}
private void WritePolygon(Polygon poly, WKBByteOrder byteOrder)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(poly, byteOrder);
// Get the number of rings in this polygon.
int numRings = poly.getNumInteriorRing() + 1;
// Write the number of rings to the stream (add one for the shell)
this.Write((uint)numRings, byteOrder);
// Get the shell of this polygon.
this.WriteLineString(poly.getExteriorRing(), byteOrder, false);
// Loop on the number of rings - 1 because we already wrote the shell.
for (int i = 0; i < numRings-1; i++)
{
this.WriteLineString(poly.getInteriorRingN(i), byteOrder, false);
}
}
private static ICoordinate readPointCoords(Stream stream, WKBByteOrder byteOrder)
{
return PlanimetryEnvironment.NewCoordinate(readDouble(stream, byteOrder), readDouble(stream, byteOrder));
}
private void WriteGeometryCollection(GeometryCollection gc, WKBByteOrder byteOrder)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(gc, byteOrder);
// Write the number of geometries.
this.Write((uint)gc.getNumGeometries(), byteOrder);
// Loop on the number of geometries.
for (int i = 0; i < gc.getNumGeometries(); i++)
{
// Write each geometry.
this.WriteGeometry(gc.getGeometryN(i), byteOrder);
}
}
private void Write(double value, 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>
/// Serializes a polygon geometry into stream using a specified byte order.
/// </summary>
/// <param name="stream">A stream instance</param>
/// <param name="polygon">A polygon geometry to serialize</param>
/// <param name="byteOrder">A byte order which is used to write integer and double values</param>
public static void SerializePolygon(Stream stream, Polygon polygon, WKBByteOrder byteOrder)
{
SerializePolygon(stream, polygon, byteOrder, false);
}
/// <summary>
/// Serializes a polygon geometry into stream using a specified byte order.
/// </summary>
/// <param name="stream">A stream instance</param>
/// <param name="polygon">A polygon geometry to serialize</param>
/// <param name="byteOrder">A byte order which is used to write integer and double values</param>
/// <param name="reverseVertices">A value indicating whether a standart order of vertices
/// should be inverted in WKB</param>
public static void SerializePolygon(Stream stream, Polygon polygon, WKBByteOrder byteOrder, bool reverseVertices)
{
List<Polygon> polygons = polygon.SplitToConnectedDomains();
if (polygons.Count == 0)
throw new ArgumentException(_degeneratePolygon, "polygon");
if (reverseVertices)
foreach (Polygon p in polygons)
foreach (Contour c in p.Contours)
c.Reverse();
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
if (polygons.Count == 1)
{
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.Polygon, stream, byteOrder);
// количество контуров
writeUInt32((uint)polygons[0].Contours.Count, stream, byteOrder);
foreach (Contour c in polygons[0].Contours)
writeContour(stream, c, byteOrder);
}
else
{
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.MultiPolygon, stream, byteOrder);
// количество полигонов
writeUInt32((uint)polygons.Count, stream, byteOrder);
// полигоны
foreach (Polygon p in polygons)
{
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.Polygon, stream, byteOrder);
// количество контуров
writeUInt32((uint)p.Contours.Count, stream, byteOrder);
// контуры
foreach (Contour c in p.Contours)
writeContour(stream, c, byteOrder);
}
}
}
private static Polygon readMultiPolygon(Stream stream, WKBByteOrder byteOrder)
{
// количество полигонов
int numPolygons = (int)readUInt32(stream, byteOrder);
Polygon polygon = new Polygon();
// полигоны
for (int i = 0; i < numPolygons; i++)
{
// порядок байтов
stream.ReadByte();
// тип геометрической фигуры
readUInt32(stream, byteOrder);
// количество контуров
int numContours = (int)readUInt32(stream, byteOrder);
if (numContours < 1)
throw new ArgumentException(_degeneratePolygon, "stream");
for (int j = 0; j < numContours; j++)
polygon.Contours.Add(readContour(stream, byteOrder));
}
return polygon;
}
private static MultiPoint readMultiPoint(Stream stream, WKBByteOrder byteOrder)
{
MultiPoint multiPoint = new MultiPoint();
int numPoints = (int)readUInt32(stream, byteOrder);
for (int i = 0; i < numPoints; i++)
{
// порядок байтов
stream.ReadByte();
// тип фигуры
readUInt32(stream, byteOrder);
multiPoint.Points.Add(PlanimetryEnvironment.NewCoordinate(readDouble(stream, byteOrder), readDouble(stream, byteOrder)));
}
return multiPoint;
}
private void WriteGeometry(Geometry geometry, WKBByteOrder byteOrder)
{
switch (geometry.getGeometryType().ToUpper())
{
case "POINT":
this.WritePoint((Point)geometry, byteOrder, true);
break;
case "LINESTRING":
this.WriteLineString((LineString)geometry, byteOrder, true);
break;
case "POLYGON":
this.WritePolygon((Polygon)geometry, byteOrder);
break;
case "MULTIPOINT":
this.WriteMultiPoint((MultiPoint)geometry, byteOrder);
break;
case "MULTILINESTRING":
this.WriteMultiLineString((MultiLineString)geometry, byteOrder);
break;
case "MULTIPOLYGON":
this.WriteMultiPolygon((MultiPolygon)geometry, byteOrder);
break;
case "GEOMETRYCOLLECTION":
this.WriteGeometryCollection((GeometryCollection)geometry, byteOrder);
break;
default:
throw new ArgumentException("Invalid Geometry Type");
}
}
/// <summary>
/// Writes a double value to stream using specified byte order.
/// </summary>
/// <param name="value">A double value to write</param>
/// <param name="stream">A stream instance</param>
/// <param name="byteOrder">A byte order</param>
private static void writeDouble(double value, Stream stream, WKBByteOrder byteOrder)
{
byte[] bytes = BitConverter.GetBytes(value);
if (byteOrder == WKBByteOrder.Xdr)
{
Array.Reverse(bytes);
stream.Write(bytes, 0, bytes.Length);
}
else
stream.Write(bytes, 0, bytes.Length);
}
private void WriteLineString(LineString ls, WKBByteOrder byteOrder, bool writeHeader)
{
if (writeHeader)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(ls, byteOrder);
}
// Write the number of points in this linestring.
this.Write((uint)ls.getNumPoints(), byteOrder);
// Loop on each set of coordinates.
foreach (Coordinate coord in ls.getCoordinates())
{
// Create a new point from the coordinates & write it.
WritePoint(_factory.createPoint(coord), byteOrder, false);
}
}
private static double readDouble(Stream stream, WKBByteOrder byteOrder)
{
byte[] bytes = new byte[sizeof(double)];
stream.Read(bytes, 0, sizeof(double));
if (byteOrder == WKBByteOrder.Xdr)
Array.Reverse(bytes);
else
if (byteOrder != WKBByteOrder.Ndr)
throw new ArgumentException(_unrecognizedByteOrder);
return BitConverter.ToDouble(bytes, 0);
}
private void WriteMultiPoint(MultiPoint mp, WKBByteOrder byteOrder)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(mp, byteOrder);
// Get the number of points in this multipoint.
int numPoints = mp.getNumPoints();
// Write the number of points.
this.Write((uint)numPoints, byteOrder);
// Loop on the number of points.
for (int i = 0; i < numPoints; i++)
{
// Write each point.
this.WritePoint((Point)mp.getGeometryN(i), byteOrder, true);
}
}
/// <summary>
/// Serializes a geometry into stream using a specified byte order.
/// </summary>
/// <param name="stream">A stream instance</param>
/// <param name="geometry">A geometry to serialize</param>
/// /// <param name="byteOrder">A byte order which is used to write integer and double values</param>
public static void SerializeGeometry(Stream stream, IGeometry geometry, WKBByteOrder byteOrder)
{
if (geometry == null)
return;
if (geometry is PointD)
{
SerializePoint(stream, (PointD)geometry, byteOrder);
return;
}
if (geometry is Polyline)
{
SerializePolyline(stream, (Polyline)geometry, byteOrder);
return;
}
if (geometry is Polygon)
{
SerializePolygon(stream, (Polygon)geometry, byteOrder);
return;
}
if (geometry is MultiPoint)
{
SerializeMultiPoint(stream, (MultiPoint)geometry, byteOrder);
return;
}
throw new NotSupportedException("Geometry \"" + geometry.GetType().Name + "\" is not supported");
}
private void WritePoint(Point point, WKBByteOrder byteOrder, bool writeHeader)
{
if (writeHeader)
{
// Write byte order
_writer.Write((byte)byteOrder);
// Write type
this.WriteType(point, byteOrder);
}
// Write the x coordinate.
this.Write(point.getX(), byteOrder);
// Write the y coordinate.
this.Write(point.getY(), byteOrder);
}
/// <summary>
/// Serializes a multipoint geometry into stream using a specified byte order.
/// </summary>
/// <param name="stream">A stream instance</param>
/// <param name="multiPoint">A multipoint geometry to serialize</param>
/// <param name="byteOrder">A byte order which is used to write integer and double values</param>
public static void SerializeMultiPoint(Stream stream, MultiPoint multiPoint, WKBByteOrder byteOrder)
{
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.MultiPoint, stream, byteOrder);
// количество вершин
writeUInt32((uint)multiPoint.Points.Count, stream, byteOrder);
// вершины
foreach (ICoordinate p in multiPoint.Points)
{
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.Point, stream, byteOrder);
writeDouble(p.X, stream, byteOrder);
writeDouble(p.Y, stream, byteOrder);
}
}
private void WriteType(Geometry geometry, WKBByteOrder byteOrder)
{
switch(geometry.getGeometryType().ToUpper())
{
case "POINT":
this.Write((uint)WKBGeometryType.WKBPoint, byteOrder);
break;
case "LINESTRING":
this.Write((uint)WKBGeometryType.WKBLineString, byteOrder);
break;
case "POLYGON":
this.Write((uint)WKBGeometryType.WKBPolygon, byteOrder);
break;
case "MULTIPOINT":
this.Write((uint)WKBGeometryType.WKBMultiPoint, byteOrder);
break;
case "MULTILINESTRING":
this.Write((uint)WKBGeometryType.WKBMultiLineString, byteOrder);
break;
case "MULTIPOLYGON":
this.Write((uint)WKBGeometryType.WKBMultiPolygon, byteOrder);
break;
case "GEOMETRYCOLLECTION":
this.Write((uint)WKBGeometryType.WKBGeometryCollection, byteOrder);
break;
default:
throw new ArgumentException("Invalid Geometry Type");
}
}
/// <summary>
/// Serializes a point geometry into stream using a specified byte order.
/// </summary>
/// <param name="stream">A stream instance</param>
/// <param name="point">A point geometry to serialize</param>
/// <param name="byteOrder">A byte order which is used to write integer and double values</param>
public static void SerializePoint(Stream stream, PointD point, WKBByteOrder byteOrder)
{
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.Point, stream, byteOrder);
// значения координат
writeDouble(point.X, stream, byteOrder);
writeDouble(point.Y, stream, byteOrder);
}
/// <summary>
/// Writes the <b>Geometry</b> object.
/// </summary>
/// <param name="geometry">The <b>Geometry</b> object to write.</param>
/// <param name="byteOrder">The desired <see cref="WKBByteOrder">WKBByteOrder</see>.</param>
public void Write(Geometry geometry, WKBByteOrder byteOrder)
{
// Write the geometry
this.WriteGeometry(geometry, byteOrder);
}
/// <summary>
/// Serializes a polyline geometry into stream using a specified byte order.
/// </summary>
/// <param name="stream">A stream instance</param>
/// <param name="polyline">A polyline geometry to serialize</param>
/// <param name="byteOrder">A byte order which is used to write integer and double values</param>
public static void SerializePolyline(Stream stream, Polyline polyline, WKBByteOrder byteOrder)
{
if (polyline == null)
return;
if (polyline.Paths.Count == 0)
throw new ArgumentException("Polyline must contain at least two points", "polyline");
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
if (polyline.Paths.Count == 1)
writeLineString(stream, polyline.Paths[0], byteOrder);
else
{
// тип геометрической фигуры
writeUInt32((uint)WKBGeometryType.MultiLineString, stream, byteOrder);
// количество частей полилинии
writeUInt32((uint)polyline.Paths.Count, stream, byteOrder);
// части
foreach (LinePath path in polyline.Paths)
{
// порядок байтов
stream.Write(new byte[] { (byte)byteOrder }, 0, sizeof(byte));
writeLineString(stream, path, byteOrder);
}
}
}
