/// <inheritdoc cref="IGeometryWriter{TSink}.Write(IGeometry, Stream)"/>>
public void Write(IGeometry geom, Stream stream)
{
if (geom == null)
{
throw new ArgumentNullException(nameof(geom));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
using (var writer = new BinaryWriter(stream))
{
int byteOrder = (int)ByteOrder;
int ordinates;
switch (HandleOrdinates)
{
case Ordinates.None:
ordinates = 0;
break;
case Ordinates.XY:
ordinates = 1;
break;
case Ordinates.XYZ:
ordinates = 2;
break;
case Ordinates.XYM:
ordinates = 3;
break;
case Ordinates.XYZM:
ordinates = 4;
break;
default:
throw new ArgumentOutOfRangeException("HandleOrdinates");
}
int isEmpty = geom.IsEmpty ? 1 : 0;
byte flags = (byte)(byteOrder + (ordinates << 1) + (isEmpty << 4));
var header = new GeoPackageBinaryHeader
{
Extent = geom.EnvelopeInternal,
Flags = flags,
SrsId = HandleSRID ? geom.SRID : -1
};
GeoPackageBinaryHeader.Write(writer, header);
bool emitZ = (HandleOrdinates & Ordinates.Z) == Ordinates.Z;
bool emitM = (HandleOrdinates & Ordinates.M) == Ordinates.M;
// NOTE: GeoPackage handle SRID in header, so no need to store this also in wkb;
// actually, trying to store srid in wkb resunts in an invalid gpkg blob value...
const bool dontHandleSRID = false;
var wkbWriter = new WKBWriter(ByteOrder, dontHandleSRID, emitZ, emitM);
wkbWriter.Write(geom, stream);
}
}
public static string Geom2WKBhex(IGeometry geometry)
{
// writing WKB (Well Known Binary)
var writer = new NetTopologySuite.IO.WKBWriter(GeoAPI.IO.ByteOrder.BigEndian, true);
var wkbBin = writer.Write(geometry);
// writing hex-coded WKB, used in POSTGIS DB geometery column
string hexString = NetTopologySuite.IO.WKBWriter.ToHex(wkbBin);
return(hexString);
}
public void OracleWKBBigEndianWriteTest()
{
ILinearRing shell = Factory.CreateLinearRing(new Coordinate[] { new Coordinate(100,100),
new Coordinate(200,100),
new Coordinate(200,200),
new Coordinate(100,200),
new Coordinate(100,100), });
ILinearRing hole = Factory.CreateLinearRing(new Coordinate[] { new Coordinate(120,120),
new Coordinate(180,120),
new Coordinate(180,180),
new Coordinate(120,180),
new Coordinate(120,120), });
IPolygon polygon = Factory.CreatePolygon(shell, new ILinearRing[] { hole, });
WKBWriter writer = new WKBWriter(ByteOrder.BigEndian);
byte[] bytes = writer.Write(polygon);
Assert.IsNotNull(bytes);
Assert.IsNotEmpty(bytes);
Debug.WriteLine(bytes.Length);
}
/// <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();
*/
}
void RunGeometry(Geometry g, int dimension, ByteOrder byteOrder, bool toHex, int srid)
{
bool includeSRID = false;
if (srid >= 0)
{
includeSRID = true;
g.SRID = srid;
}
WKBWriter wkbWriter = new WKBWriter(byteOrder, includeSRID, dimension==2 ? false : true);
byte[] wkb = wkbWriter.Write(g);
String wkbHex = null;
if (toHex)
wkbHex = WKBWriter.ToHex(wkb);
if (toHex)
wkb = WKBReader.HexToBytes(wkbHex);
Geometry g2 = (Geometry)_wkbReader.Read(wkb);
CoordinateSequenceComparator comp = (dimension == 2) ? Comp2 : Comp3;
bool isEqual = (g.CompareTo(g2, comp) == 0);
Assert.IsTrue(isEqual);
if (includeSRID)
{
bool isSRIDEqual = g.SRID == g2.SRID;
Assert.IsTrue(isSRIDEqual);
}
}
// Writes shapes in an internal format readable by {@link #readShapeFromBytes(byte[], int, int)}.
public byte[] WriteShapeToBytes(Shape shape)
{
var p = shape as Shapes.Point;
if (p != null)
{
using (var stream = new MemoryStream(1 + (2 * 8)))
using (var bytes = new BinaryWriter(stream))
{
bytes.Write(TYPE_POINT);
bytes.Write(p.GetX());
bytes.Write(p.GetY());
return stream.ToArray();
}
}
var rect = shape as Rectangle;
if (rect != null)
{
using (var stream = new MemoryStream(1 + (4 * 8)))
using (var bytes = new BinaryWriter(stream))
{
bytes.Write(TYPE_BBOX);
bytes.Write(rect.GetMinX());
bytes.Write(rect.GetMaxX());
bytes.Write(rect.GetMinY());
bytes.Write(rect.GetMaxY());
return stream.ToArray();
}
}
var ntsShape = shape as NtsGeometry;
if (ntsShape != null)
{
var writer = new WKBWriter();
byte[] bb = writer.Write(ntsShape.GetGeom());
using (var stream = new MemoryStream(1 + bb.Length))
using (var bytes = new BinaryWriter(stream))
{
bytes.Write(TYPE_GEOM);
bytes.Write(bb);
return stream.ToArray();
}
}
throw new ArgumentException("unsuported shape:" + shape);
}
/// <summary>
/// Returns the Well-known Binary representation of this <c>Geometry</c>.
/// For a definition of the Well-known Binary format, see the OpenGIS Simple
/// Features Specification.
/// </summary>
/// <returns>The Well-known Binary representation of this <c>Geometry</c>.</returns>
public byte[] ToBinary()
{
var writer = new WKBWriter();
return writer.Write(this);
}
