public WellKnownBinaryWriter()
{
_wkbWriter = new WKBWriter(ByteOrder.LittleEndian, true)
{
HandleOrdinates = Ordinates.XYZM
};
}
private static bool TestWktWkb(int number, IGeometryFactory factory, string wkt, string wkb)
{
WKTReader r = new WKTReader(factory);
IGeometry wktGeom = r.Read(wkt);
WKBReader s = new WKBReader(factory);
IGeometry wkbGeom = s.Read(WKBReader.HexToBytes(wkb));
try
{
Assert.AreEqual(wkb, WKBWriter.ToHex(wktGeom.AsBinary()), "wkb's don't match");
Assert.IsTrue(DiscreteHausdorffDistance.Distance(wktGeom, wkbGeom) < 1e-9, number + ": DiscreteHausdorffDistance.Distance(wktGeom, wkbGeom) < 1e-9");
if (!wktGeom.EqualsExact(wkbGeom))
{
Assert.AreEqual(wkt, wktGeom.AsText(), number + ": wkt.Equals(wktGeom.AsText())");
var wktGeom2 = s.Read(wktGeom.AsBinary());
Assert.AreEqual(wkt, wktGeom2.AsText(), number + ": wkt.Equals(wktGeom2.AsText())");
var diff = wkbGeom.Difference(wktGeom);
Assert.IsTrue(false, number + ": wktGeom.EqualsExact(wkbGeom)\n" + diff.AsText());
}
return(false);
}
catch (AssertionException ex)
{
Console.WriteLine(ex.Message);
return(true);
}
}
/// <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();
}
public void linearring_should_be_written_as_wkb()
{
var factory = GeometryFactory.Default;
var expected = factory.CreateLinearRing(new[]
{
new Coordinate(0, 0),
new Coordinate(10, 0),
new Coordinate(10, 10),
new Coordinate(0, 10),
new Coordinate(0, 0)
});
var writer = new WKBWriter();
byte[] bytes = writer.Write(expected);
Assert.That(bytes, Is.Not.Null);
Assert.That(bytes, Is.Not.Empty);
var reader = new WKBReader();
var actual = reader.Read(bytes);
Assert.That(actual, Is.Not.Null);
Assert.That(actual, Is.EqualTo(expected));
Assert.That(actual.OgcGeometryType, Is.EqualTo(expected.OgcGeometryType));
// WKBReader reads "LinearRing" geometries as LineString
Assert.That(expected, Is.InstanceOf <LinearRing>());
Assert.That(actual, Is.InstanceOf <LineString>());
Assert.That(actual.GeometryType, Is.Not.EqualTo(expected.GeometryType));
}
private static byte[] ConvertWKTToWKB(string wkt)
{
var writer = new WKBWriter();
var reader = new WKTReader();
return(writer.Write(reader.Read(wkt)));
}
public static byte[] ConvertWkttoWkb(string wkt)
{
WKBWriter writer = new WKBWriter();
WKTReader reader = new WKTReader();
return(writer.Write(reader.Read(wkt)));
}
/// <summary>
/// 将GeoAPI中的geometry对象转换为arcgis中的geometry对象
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
public static IGeometry ConvertGeoApitoEsri(GeoAPI.Geometries.IGeometry geometry)
{
WKBWriter writer = new WKBWriter();
byte[] bytes = writer.Write(geometry);
return(ConvertWkbToGeometry(bytes));
}
public void TestIssue132Polygons()
{
var pts = new[] { new Coordinate(0, 0), new Coordinate(10, 10), new Coordinate(20, 20) };
var polys = new IPolygon[3];
var pm = GeoAPI.GeometryServiceProvider.Instance.CreatePrecisionModel(10d);
var factory = GeoAPI.GeometryServiceProvider.Instance.CreateGeometryFactory(pm, 4326);
for (var i = 0; i < pts.Length; i++)
{
polys[i] = (IPolygon)factory.CreatePoint(pts[i]).Buffer(4d, 1);
}
var mp = factory.CreateMultiPolygon(polys);
Console.WriteLine(mp);
var gc = factory.CreateGeometryCollection(new IGeometry[] { mp });
Console.WriteLine(gc);
var writer = new GaiaGeoWriter();
var buffer = writer.Write(gc);
Console.WriteLine("Hex: {0}", WKBWriter.ToHex(buffer));
var reader = new GaiaGeoReader(factory.CoordinateSequenceFactory, factory.PrecisionModel);
var gc2 = reader.Read(buffer);
Assert.IsNotNull(gc2);
Assert.IsTrue(gc.EqualsExact(gc2));
}
public void TestIssue132LineStrings()
{
var pts = new[] { new Coordinate(0, 0), new Coordinate(10, 10), new Coordinate(20, 20), new Coordinate(30, 30) };
var lines = new ILineString[2];
var factory = GeoAPI.GeometryServiceProvider.Instance.CreateGeometryFactory(4326);
for (var i = 0; i < pts.Length; i += 2)
{
lines[i / 2] = factory.CreateLineString(new[] { pts[i], pts[i + 1] });
}
var mp = factory.CreateMultiLineString(lines);
Console.WriteLine(mp);
var gc = factory.CreateGeometryCollection(new IGeometry[] { mp });
Console.WriteLine(gc);
var writer = new GaiaGeoWriter();
var buffer = writer.Write(gc);
Console.WriteLine("Hex: {0}", WKBWriter.ToHex(buffer));
var reader = new GaiaGeoReader(factory.CoordinateSequenceFactory, factory.PrecisionModel);
var gc2 = reader.Read(buffer);
Assert.IsNotNull(gc2);
Assert.IsTrue(gc.EqualsExact(gc2));
}
private string GetGeom(long id, long version)
{
using (var conn = GetConnection())
{
conn.Open();
var query = string.Format(
$"SELECT ST_AsBinary(geom) FROM {_geomTable} WHERE id=:id AND version=:version");
var command = new NpgsqlCommand(query, conn);
command.Parameters.Add(new NpgsqlParameter("id", NpgsqlDbType.Bigint)
{
Value = id
});
command.Parameters.Add(new NpgsqlParameter("version", NpgsqlDbType.Bigint)
{
Value = version
});
command.Prepare();
using (var dr = command.ExecuteReader())
{
while (dr.Read())
{
return(WKBWriter.ToHex((byte[])dr[0]));
}
}
}
return(null);
}
public void TestIssue147()
{
var wkt = "POLYGON ((-94.16 42.25, -94.15 42.26, -94.14 42.25, -94.16 42.25))";
var geom = new WKTReader().Read(wkt);
Assert.AreEqual(
"0x010300000001000000040000000AD7A3703D8A57C000000000002045409A999999998957C0E17A14AE47214540295C8FC2F58857C000000000002045400AD7A3703D8A57C00000000000204540",
"0x" + WKBWriter.ToHex(geom.AsBinary()));
}
private IEnumerable <trout_stream_section> CreateSection(trout_streams_minnesota asdf, StreamRoute route)
{
var routeMultilineString = route.OriginalGeometry as IMultiLineString;
var troutStreamSection = (asdf.OriginalGeometry as IMultiLineString);
var desiredTroutStreamSection = (asdf.Geometry_4326 as IMultiLineString);
var TroutStreamSection4236 = (asdf.Geometry_4326 as IMultiLineString);
var numberOfGeometries = troutStreamSection.Geometries.Count();
for (var i = 0; i < numberOfGeometries; i++)
{
var s = troutStreamSection.Geometries[i] as ILineString;
var desiredGeometry = desiredTroutStreamSection.Geometries[i] as ILineString;
desiredGeometry.SRID = 44326;
var asdf4236 = TroutStreamSection4236.Geometries[i];
var trout_section = new trout_stream_section();
var centroid = asdf4236.Centroid;
trout_section.centroid_latitude = Convert.ToDecimal(centroid.X);
trout_section.centroid_longitude = Convert.ToDecimal(centroid.Y);
trout_section.length_mi = Convert.ToDecimal(s.Length) / METERS_IN_MILE;
trout_section.public_length = 0;
trout_section.section_name = asdf.kittle_nam ?? "Unnamed Stream";
trout_section.source_id = asdf.kittle_nbr;
var multilineString = new MultiLineString(new[] { s });
var t = new LinearReference();
var wktWriter = new WKTWriter();
wktWriter.EmitSRID = true;
wktWriter.HandleSRID = true;
var desiredMultilineString = new MultiLineString(new[] { desiredGeometry });
desiredMultilineString.SRID = 4326;
var text = wktWriter.Write(desiredMultilineString);
// var superResultLol =
var writer = new WKBWriter();
// writer.HandleSRID = true;
// writer.EmitSRID = true;
var binResult = writer.Write(desiredMultilineString);
var bin2 = desiredMultilineString.ToBinary();
var stringResult = System.Text.Encoding.UTF7.GetString(binResult);
trout_section.Geom = asdf.Geom_4326;
var result = t.GetIntersectionOfLine(routeMultilineString.Geometries.First() as ILineString, s).ToList();
trout_section.start = (decimal)result[0] / METERS_IN_MILE;
trout_section.stop = (decimal)result[1] / METERS_IN_MILE;
yield return(trout_section);
}
}
// 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);
}
public RouteNode Create(Point point)
{
var wkbWriter = new WKBWriter();
var node = new RouteNode
(
Guid.NewGuid(),
wkbWriter.Write(point),
Guid.Empty,
_applicationSettings.ApplicationName,
_applicationSettings.ApplicationName
);
return(node);
}
/// <summary>
/// Creates an instance of this class using the provided decorator strings
/// </summary>
/// <param name="entityDecoratorFormat">The format string to decorate database entities</param>
/// <param name="literalDecoratorFormat">The format string to decorate literals (strings)</param>
/// <param name="parameterDecoratorFormat">The format string to decorate parameters</param>
/// <param name="reader"> </param>
/// <param name="writer"> </param>
public SpatialDbUtility(string entityDecoratorFormat, string literalDecoratorFormat, string parameterDecoratorFormat,
WKBReader reader, WKBWriter writer)
{
EntityDecoratorFormat = entityDecoratorFormat;
LiteralDecoratorFormat = literalDecoratorFormat;
ParameterDecoratorFormat = parameterDecoratorFormat;
//This won't do anything to the geometry
ToEnvelopeDecoratorFormat = "{0}";
ToGeometryDecoratorFormat = "{0}";
SetSridDecoratorFormat = "{0}";
TransformDecoratorFormat = "{0}";
Reader = reader;
Writer = writer;
}
public void TestNumber()
{
const string theNumberString = "6232756.00054126";
const double theNumber = 6232756.00054126; //6232756.0005412595;
var theBytes = BitConverter.GetBytes(theNumber);
Console.WriteLine("{0:R} -> 0x{1}", theNumber, WKBWriter.ToHex(theBytes));
var theWkbedNumber = BitConverter.ToDouble(theBytes, 0);
Console.WriteLine("0x{1} -> {0:R}", theWkbedNumber, WKBWriter.ToHex(theBytes));
//The result of JTS
theBytes[0] = (byte)(theBytes[0] + 1);
theWkbedNumber = BitConverter.ToDouble(theBytes, 0);
Console.WriteLine("0x{1} -> {0:R}", theWkbedNumber, WKBWriter.ToHex(theBytes));
Assert.AreEqual(theNumber, theWkbedNumber);
}
public void TestSRID()
{
var gf = new GeometryFactory();
var p1 = gf.CreatePoint(new Coordinate(1, 2));
p1.SRID = 1234;
//first write out without srid set
var w = new WKBWriter(ByteOrder.BigEndian);
byte[] wkb = w.Write(p1);
//check the 3rd bit of the second byte, should be unset
byte b = (byte)(wkb[1] & 0x20);
Assert.AreEqual(0, b);
//read geometry back in
var r = new WKBReader();
var p2 = (Point)r.Read(wkb);
Assert.IsTrue(p1.EqualsExact(p2));
//NOTE: this differs from JTS-WKBReader, where SRID = 0 when handleSRID = false;
Assert.AreEqual(-1, p2.SRID);
//not write out with srid set
w = new WKBWriter(ByteOrder.BigEndian, true);
wkb = w.Write(p1);
//check the 3rd bit of the second byte, should be set
b = (byte)(wkb[1] & 0x20);
Assert.AreEqual(0x20, b);
int srid = ((int)(wkb[5] & 0xff) << 24) | ((int)(wkb[6] & 0xff) << 16) |
((int)(wkb[7] & 0xff) << 8) | ((int)(wkb[8] & 0xff));
Assert.AreEqual(1234, srid);
r = new WKBReader();
p2 = (Point)r.Read(wkb);
//read the geometry back in
Assert.IsTrue(p1.EqualsExact(p2));
Assert.AreEqual(1234, p2.SRID);
}
public void TestWritingEmptyLineString()
{
var wkbWriter = new WKBWriter();
var memoryStream = new MemoryStream();
var linestring = new LineString(new ICoordinate[0]);
Assert.IsNull(linestring.Coordinate);
try
{
wkbWriter.Write(linestring, memoryStream);
}
finally
{
memoryStream.Close();
memoryStream.Dispose();
}
}
private static ExtendedWkbGeometry CreateEWkb(byte[] wkb)
{
if (wkb == null)
{
return(null);
}
var geometry = WKBReaderFactory.Create()
.Read(wkb);
geometry.SRID = SpatialReferenceSystemId.Lambert72;
var wkbWriter = new WKBWriter {
Strict = false, HandleSRID = true
};
return(new ExtendedWkbGeometry(wkbWriter.Write(geometry)));
}
public void OracleWKBBigEndianWriteTest()
{
var 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), });
var 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), });
var polygon = Factory.CreatePolygon(shell, new LinearRing[] { hole, });
var writer = new WKBWriter(ByteOrder.BigEndian);
byte[] bytes = writer.Write(polygon);
Assert.IsNotNull(bytes);
Assert.IsNotEmpty(bytes);
Debug.WriteLine(bytes.Length);
}
private static ExtendedWkbGeometry CreateEWkb(byte[] wkb)
{
if (wkb == null)
{
return(null);
}
var geometry = new WKBReader(
new NtsGeometryServices(
new DotSpatialAffineCoordinateSequenceFactory(Ordinates.XY),
new PrecisionModel(PrecisionModels.Floating),
SpatialReferenceSystemId.Lambert72)).Read(wkb);
geometry.SRID = SpatialReferenceSystemId.Lambert72;
var wkbWriter = new WKBWriter {
Strict = false, HandleSRID = true
};
return(new ExtendedWkbGeometry(wkbWriter.Write(geometry)));
}
/// <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();
*/
}
public void TestIssue132Points()
{
var pts = new[] { new Coordinate(0, 0), new Coordinate(10, 10), new Coordinate(20, 20) };
var factory = GeoAPI.GeometryServiceProvider.Instance.CreateGeometryFactory(4326);
var mp = factory.CreateMultiPoint(pts);
Console.WriteLine(mp);
var gc = factory.CreateGeometryCollection(new IGeometry[] { mp });
Console.WriteLine(gc);
var writer = new GaiaGeoWriter();
var buffer = writer.Write(gc);
Console.WriteLine("Hex: {0}", WKBWriter.ToHex(buffer));
var reader = new GaiaGeoReader(factory.CoordinateSequenceFactory, factory.PrecisionModel);
var gc2 = reader.Read(buffer);
Assert.IsNotNull(gc2);
Assert.IsTrue(gc.EqualsExact(gc2));
}
void CheckWKB(string wkt, ByteOrder byteOrder, bool emitZ, int srid, string expectedWKBHex)
{
var geom = Read(wkt);
// set SRID if not -1
bool includeSRID = false;
if (srid > 0)
{
includeSRID = true;
geom.SRID = srid;
}
var wkbWriter = new WKBWriter(byteOrder, includeSRID, emitZ)
{
Strict = false
};
byte[] wkb = wkbWriter.Write(geom);
string wkbHex = WKBWriter.ToHex(wkb);
Assert.AreEqual(expectedWKBHex, wkbHex);
}
public void BuildGraphBinary()
{
string path = "strade" + shp;
Assert.IsTrue(File.Exists(path));
ShapefileReader reader = new ShapefileReader(path, factory);
IGeometryCollection coll = reader.ReadAll();
Assert.IsNotNull(coll);
Assert.IsNotEmpty(coll.Geometries);
IGeometry result = coll.Geometries[0];
for (int i = 1; i < coll.NumGeometries; i++)
{
Debug.WriteLine(String.Format("Union of {0}'th geometry", i));
result = result.Union(coll.Geometries[i]);
}
Assert.IsNotNull(result);
Assert.IsInstanceOfType(typeof(MultiLineString), result);
WKBWriter wkbwriter = new WKBWriter();
byte[] rawdata = wkbwriter.Write(result);
Assert.IsNotEmpty(rawdata);
path = "graph";
if (File.Exists(path))
{
File.Delete(path);
}
Assert.IsFalse(File.Exists(path));
using (FileStream stream = new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.None))
stream.Write(rawdata, 0, rawdata.Length);
Assert.IsTrue(File.Exists(path));
}
void RunGeometry(Geometry g, int dimension, ByteOrder byteOrder, bool toHex, int srid)
{
bool includeSRID = false;
if (srid >= 0)
{
includeSRID = true;
g.SRID = srid;
}
var 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);
}
var g2 = (Geometry)_wkbReader.Read(wkb);
var 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);
}
}
public static string GetValueEscaped(object val, PropertyInfo prop = null)
{
if (val == null)
{
return("null");
}
Type t;
if (prop == null)
{
t = val.GetType();
}
else
{
t = prop.PropertyType;
}
if (t == typeof(double) || t == typeof(double?))
{
return(CheapEscape(((double)val).ToString(CultureInfo.InvariantCulture)));
}
else if (t == typeof(int) || t == typeof(int?))
{
return(val.ToString());
}
else if (t == typeof(bool) || t == typeof(bool?))
{
if ((bool)val)
{
return("1");
}
else
{
return("0");
}
}
else if (t == typeof(byte[]))
{
//No se puede insertar byte array porque rompe el max_allowed_packet, además
//duplica el tamaño porque hay que mandarlo como hexa.
throw new Exception("Invalid type.");
}
else if (t == typeof(Geometry))
{
WKBWriter writer = new WKBWriter();
var bytes = writer.Write((Geometry)val);
return("0x00000000" + BitConverter.ToString(bytes).Replace("-", ""));
}
else if (t == typeof(Point))
{
WKBWriter writer = new WKBWriter();
var bytes = writer.Write((Point)val);
return("0x00000000" + BitConverter.ToString(bytes).Replace("-", ""));
}
else if (t == typeof(MultiPolygon))
{
WKBWriter writer = new WKBWriter();
var bytes = writer.Write((MultiPolygon)val);
return("0x00000000" + BitConverter.ToString(bytes).Replace("-", ""));
}
else if (t == typeof(LineString))
{
WKBWriter writer = new WKBWriter();
var bytes = writer.Write((LineString)val);
return("0x00000000" + BitConverter.ToString(bytes).Replace("-", ""));
}
else if (t == typeof(MultiLineString))
{
WKBWriter writer = new WKBWriter();
var bytes = writer.Write((MultiLineString)val);
return("0x00000000" + BitConverter.ToString(bytes).Replace("-", ""));
}
else if (t == typeof(Polygon))
{
WKBWriter writer = new WKBWriter();
var bytes = writer.Write((Polygon)val);
return("0x00000000" + BitConverter.ToString(bytes).Replace("-", ""));
}
else if (typeof(IIdentifiable).IsAssignableFrom(t))
{
return(((IIdentifiable)val).Id.ToString());
}
else
{
return(CheapEscape(val.ToString()));
}
}
