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);
}
}
public void Setup()
{
wkbreader = new WKBReader(factory);
geometry0 = wkbreader.Read(test00_Geom0_WkbByteArray);
Debug.WriteLine(geometry0.ToString());
geometry1 = wkbreader.Read(test00_Geom1_WkbByteArray);
Debug.WriteLine(geometry1.ToString());
}
private static object ConvertToJson(byte[] geometry)
{
var geom = Reader.Read(geometry);
if (!geom.IsValid)
{
throw new Exception();
}
//return JsonConvert.DeserializeObject(Writer.Write(geom));
for (var i = 0; i < geom.NumGeometries; i++)
{
TransformRing(((Polygon)geom.GetGeometryN(i)).Boundary);
}
if (geom.IsValid)
{
return(JsonConvert.DeserializeObject(Writer.Write(geom)));
}
throw new Exception("Something went wrong when reprojecting");
}
public IGeometry GetGeom(string table, long id, long version)
{
using (var conn = GetConnection())
{
conn.Open();
var query = string.Format(
$"SELECT ST_AsBinary(geom) FROM {table} 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(_wkbReader.Read((byte[])dr[0]));
}
}
}
return(null);
}
private static IGeometry ReadGeometryFromWkbHexString(string wkbHexFile, IGeometryFactory geomFact)
{
var reader = new WKBReader();
string wkbHex = CleanHex(wkbHexFile);
return(reader.Read(WKBReader.HexToBytes(wkbHex)));
}
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 Geometry ReadGeometryFromWkbHexString(string wkbHexFile, NtsGeometryServices geomServ)
{
var reader = new WKBReader(geomServ);
string wkbHex = CleanHex(wkbHexFile);
return(reader.Read(WKBReader.HexToBytes(wkbHex)));
}
public virtual Point GetPoint()
{
var wkbReader = new WKBReader();
var geometry = wkbReader.Read(Coord);
return((Point)geometry);
}
/// <summary>
/// 将arcgis中的geometry对象转换为GeoAPI中的IGeometry对象
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
public static GeoAPI.Geometries.IGeometry ConvertEsriToGeoApi(IGeometry geometry)
{
byte[] wkb = ConvertGeometryToWkb(geometry);
WKBReader reader = new WKBReader();
return(reader.Read(wkb));
}
private Dictionary <int, Geometry> GetGeometries <T>(string sql)
where T : ActiveBaseEntity <T>, IIdentifiable
{
var ds = SqlActions.ExecuteDataSet(sql, true);
var geometries = new Dictionary <int, Geometry>();
WKBReader reader = new WKBReader();
foreach (DataRow dr in ds.Tables[0].Rows)
{
var bytes = dr[1] as byte[];
var trimmed = new byte[bytes.Length - 4];
Array.Copy(bytes, 4, trimmed, 0, trimmed.Length);
geometries.Add((int)dr[0], (Geometry)reader.Read(trimmed));
}
return(geometries);
/*
* using (var rows = SqlActions.ExecuteReader(sql, true))
* {
* var geometries = new Dictionary<int, Geometry>();
*
* WKBReader reader = new WKBReader();
* while (rows.Read())
* {
* var bytes = rows.GetValue(1) as byte[];
* var trimmed = new byte[bytes.Length - 4];
* Array.Copy(bytes, 4, trimmed, 0, trimmed.Length);
*
* geometries.Add(rows.GetInt32(0), (Geometry)reader.Read(trimmed));
* }
* return geometries;
* }*/
}
/// <summary>
/// 将Wkb转换成Wkt
/// </summary>
/// <param name="wkb"></param>
/// <returns></returns>
public static string ConvertWkbtoWkt(byte[] wkb)
{
WKTWriter writer = new WKTWriter();
WKBReader reader = new WKBReader();
return(writer.Write(reader.Read(wkb)));
}
private static bool TryParse(byte[] bytes, out SqlGeometry geometry, out Exception error)
{
if (bytes == null)
{
geometry = Null;
error = new ArgumentNullException("bytes");
return(false);
}
IGeometry g;
try {
var reader = new WKBReader(DefaultGeometryServices);
using (var stream = new MemoryStream(bytes)) {
g = reader.Read(stream);
}
geometry = new SqlGeometry(g);
error = null;
return(true);
} catch (Exception ex) {
error = ex;
geometry = Null;
return(false);
}
}
public static ExtendedWkbGeometry CreateEwkbFrom(WkbGeometry wkbGeometry)
{
var reader = new WKBReader();
var geometry = reader.Read(wkbGeometry);
geometry.SRID = SpatialReferenceSystemId.Lambert72;
return(new ExtendedWkbGeometry(WkbWriter.Write(geometry)));
}
public virtual LineString GetLineString()
{
var wkbReader = new WKBReader();
var geometry = wkbReader.Read(Coord);
var lineString = (LineString)geometry;
return(lineString);
}
internal IGeometry GetGeometry()
{
var geom = _wkbReader.Read(WellKnownBytes);
geom.SRID = Header.SrsId;
GeoAPIEx.SetExtent(geom as NetTopologySuite.Geometries.Geometry, Header.Extent);
return(geom);
}
private static void TestBase64TextFile(Stream file)
{
byte[] wkb = ConvertBase64(file);
var wkbReader = new WKBReader();
Geometry geom = null;
Assert.DoesNotThrow(() => geom = wkbReader.Read(wkb));
}
private static string ConvertWKBToWKT(byte[] wkbBytes)
{
WKBReader reader = new WKBReader();
WKTWriter writer = new WKTWriter();
var wktText = writer.Write(reader.Read(wkbBytes));
return(wktText);
}
private void ConvertWKBToGeometry_Click(object sender, RoutedEventArgs e)
{
//这里需要读取wkb
byte[] wkbBytes = new byte[1024];
WKBReader reader = new WKBReader();
NetTopologySuite.Geometries.Geometry geom = reader.Read(wkbBytes);
}
public void TestMaximimPrecisionDigitsFormatting()
{
IGeometryFactory factory = GeometryFactory.Default;
WKBReader wkbreader = new WKBReader(factory);
IGeometry wkb1 = wkbreader.Read(test00_Geom0_WkbByteArray);
Assert.IsNotNull(wkb1);
Assert.IsTrue(wkb1.IsValid);
IGeometry wkb2 = wkbreader.Read(test00_Geom1_WkbByteArray);
Assert.IsNotNull(wkb2);
Assert.IsTrue(wkb2.IsValid);
Exception ex = TryOverlay(wkb1, wkb2);
Assert.IsNotNull(ex);
Assert.IsTrue(ex.GetType() == typeof(TopologyException));
string tos1 = writer.Write(wkb1);
Assert.IsNotNull(tos1);
string tos2 = writer.Write(wkb2);
Assert.IsNotNull(tos2);
WKTReader reader = new WKTReader(factory);
IGeometry wkt1 = reader.Read(tos1);
Assert.IsNotNull(wkt1);
Assert.IsTrue(wkt1.IsValid);
IGeometry wkt2 = reader.Read(tos2);
Assert.IsNotNull(wkt2);
Assert.IsTrue(wkt2.IsValid);
Assert.IsTrue(wkb1.EqualsExact(wkt1), "First geometry pair must be equal!");
Assert.IsTrue(wkb2.EqualsExact(wkt2), "Second geometry pair must be equal!");
ex = TryOverlay(wkt1, wkt2);
Assert.IsNotNull(ex, "Operation must fail!");
Assert.IsTrue(ex.GetType() == typeof(TopologyException));
}
/// <summary>
/// Opens the specified file
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public IFeatureSet Open(string fileName)
{
IFeatureSet fs = new FeatureSet();
fs.Name = Path.GetFileNameWithoutExtension(fileName);
fs.Filename = fileName;
using (var reader = new OgrDataReader(fileName))
{
// skip the geometry column which is always column 0
for (int i = 1; i < reader.FieldCount; i++)
{
string sFieldName = reader.GetName(i);
Type type = reader.GetFieldType(i);
int uniqueNumber = 1;
string uniqueName = sFieldName;
while (fs.DataTable.Columns.Contains(uniqueName))
{
uniqueName = sFieldName + uniqueNumber;
uniqueNumber++;
}
fs.DataTable.Columns.Add(new DataColumn(uniqueName, type));
}
var wkbReader = new WKBReader();
while (reader.Read())
{
var wkbGeometry = (byte[])reader["Geometry"];
var geometry = wkbReader.Read(wkbGeometry);
IFeature feature = new Feature(geometry);
feature.DataRow = fs.DataTable.NewRow();
for (int i = 1; i < reader.FieldCount; i++)
{
object value = reader[i];
if (value == null)
{
value = DBNull.Value;
}
feature.DataRow[i - 1] = value;
}
fs.Features.Add(feature);
}
try
{
fs.Projection = reader.GetProj4ProjectionInfo();
}
catch (Exception ex)
{
Trace.WriteLine(ex);
}
}
return(fs);
}
/// <summary>
///
/// </summary>
/// <param name="geomStr"></param>
/// <returns></returns>
/// <exception cref="ParseException"></exception>
public IGeometry Read(String geomStr)
{
String trimStr = geomStr.Trim();
if (IsHex(trimStr, MaxCharsToCheck))
{
return(_wkbReader.Read(WKBReader.HexToBytes(trimStr)));
}
return(_wktReader.Read(trimStr));
}
/// <summary>
/// 将Geometry转换成Wkt
/// </summary>
/// <param name="geometry">ArcGIS的IGeometry对象</param>
/// <returns></returns>
public static string ConvertGeometryToWkt(IGeometry geometry)
{
byte[] b = ConvertGeometryToWkb(geometry);
WKBReader reader = new WKBReader();
GeoAPI.Geometries.IGeometry g = reader.Read(b);
WKTWriter writer = new WKTWriter();
return(writer.Write(g));
}
public static IGeometry ToGeometry(this DbGeography self)
{
if (self == null)
{
return(null);
}
var reader = new WKBReader(NetTopologySuite.NtsGeometryServices.Instance);
return(reader.Read(self.AsBinary()));
}
public IGeometry Read(byte[] data)
{
var geometry = _wkbReader.Read(data);
if (geometry is Point point)
{
return(new PointM(point.X, point.Y, point.Z, point.M));
}
return(geometry);
}
private static void CheckWkbGeometry(byte[] wkb, String expectedWKT)
{
WKBReader wkbReader = new WKBReader();
IGeometry g2 = wkbReader.Read(wkb);
WKTReader reader = new WKTReader();
IGeometry expected = reader.Read(expectedWKT);
bool isEqual = (expected.CompareTo(g2 /*, Comp2*/) == 0);
Assert.IsTrue(isEqual);
}
//returns geoJSON of boundaries from DB filters by type
public string GetGeoJsonCollectionFromBoundaryCollection(ICollection <Boundary> collectionOfBoundaries, BoundaryType boundaryType)
{
//create GeoJSON writer
GeoJsonWriter geoJsonWriter = new GeoJsonWriter();
//create WKT Binary reader
WKBReader wKBReader = new WKBReader();
//create empty feature collection
FeatureCollection features = new FeatureCollection();
//setup return boundary flag
bool returnBoundary = false;
//iterate through collection
foreach (Boundary boundary in collectionOfBoundaries)
{
returnBoundary = false;
switch (boundaryType)
{
case BoundaryType.ALL:
returnBoundary = true;
break;
case BoundaryType.COVERAGE:
if (boundary.isCoverageArea)
{
returnBoundary = true;
}
break;
case BoundaryType.DISPLAY:
if (boundary.displayOnMap)
{
returnBoundary = true;
}
break;
}
if (returnBoundary)
{
//set up feature attributes table
AttributesTable attributesTable = new AttributesTable();
//add attributes to table from boundary
attributesTable.AddAttribute("id", boundary.BoundaryId);
attributesTable.AddAttribute("Name", boundary.Name);
//convert DbGeometry to GeoApi.IGeometry
IGeometry iGeom = wKBReader.Read(boundary.Area.AsBinary());
//create feature from geom and attributes
Feature feature = new Feature(iGeom, attributesTable);
//add feature to feature collection
features.Add(feature);
}
}
return(geoJsonWriter.Write(features));
}
public void OracleWKBBigEndianReadTest()
{
Geometry result = null;
using (Stream stream = new FileStream(blobFile, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var wkbreader = new WKBReader();
result = wkbreader.Read(stream);
}
Debug.WriteLine(result.ToString());
Assert.IsNotNull(result);
}
private static Geometry FromWkb(string wkb, Geometry clip = null)
{
var reader = new WKBReader();
byte[] bytes = WKBReader.HexToBytes(wkb);
var geom = reader.Read(bytes);
if (clip != null)
{
geom = geom.Intersection(clip);
}
return(geom);
}
private static IGeometry FromWkb(string wkb, IGeometry clip = null)
{
WKBReader reader = new WKBReader(GeometryFactory.Default);
byte[] bytes = WKBReader.HexToBytes(wkb);
IGeometry geom = reader.Read(bytes);
if (clip != null)
{
geom = geom.Intersection(clip);
}
return(geom);
}
public virtual string GetGeoJsonCoordinate()
{
var wkbReader = new WKBReader();
var geometry = wkbReader.Read(Coord);
var point = (Point)geometry;
var serializer = GeoJsonSerializer.Create();
using (var stringWriter = new StringWriter())
{
serializer.Serialize(stringWriter, point);
var geoJson = stringWriter.ToString();
return(JObject.Parse(geoJson)["coordinates"].ToString(Formatting.None));
};
}