public void SimpleGeometryInsertQueryTest()
{
CreateSchema(System.Reflection.MethodBase.GetCurrentMethod().Name);
var routeNetwork = new RouteNetworkHelper(_config["ConnectionString"], _schemaName);
// Insert a node somewhere on the Endelave island
var pntToInsert = new Point(579886, 6179972);
routeNetwork.InsertNode(pntToInsert);
// Try query it
using var conn = new NpgsqlConnection(_config["ConnectionString"]);
conn.Open();
using (var cmd = new NpgsqlCommand("SELECT ST_AsBinary(coord) from " + _schemaName + ".route_node", conn))
using (var reader = cmd.ExecuteReader())
{
// read first row
reader.Read();
var pntRead = new WKBReader().Read((byte[])reader[0]);
Assert.Equal(pntToInsert, pntRead);
}
}
public WKTOrWKBReader(GeometryFactory geomFactory)
{
_wktReader = new WKTReader(geomFactory);
#pragma warning disable 612
_wkbReader = new WKBReader();
#pragma warning restore 612
}
public void linearring_should_be_written_as_wkb()
{
IGeometryFactory factory = GeometryFactory.Default;
ILinearRing expected = factory.CreateLinearRing(new[]
{
new Coordinate(0, 0),
new Coordinate(10, 0),
new Coordinate(10, 10),
new Coordinate(0, 10),
new Coordinate(0, 0)
});
WKBWriter writer = new WKBWriter();
byte[] bytes = writer.Write(expected);
Assert.That(bytes, Is.Not.Null);
Assert.That(bytes, Is.Not.Empty);
WKBReader reader = new WKBReader();
IGeometry 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 "ILinearRing" geometries as ILineString
Assert.That(expected, Is.InstanceOf <ILinearRing>());
Assert.That(actual, Is.InstanceOf <ILineString>());
Assert.That(actual.GeometryType, Is.Not.EqualTo(expected.GeometryType));
}
public static GeoAPI.Geometries.IGeometry ConvertESRIToGeoAPI(IGeometry geometry)
{
byte[] wkb = ConvertGeometryToWKB(geometry);
WKBReader reader = new WKBReader();
return(reader.Read(wkb));
}
public static string ConvertWKBToWKT(byte[] wkb)
{
WKTWriter writer = new WKTWriter();
WKBReader reader = new WKBReader();
return(writer.Write(reader.Read(wkb)));
}
private static bool TestWktWkb(int number, IGeometryFactory factory, string wkt, string wkb)
{
var r = new WKTReader(factory);
var wktGeom = r.Read(wkt);
var s = new WKBReader(factory);
var 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 virtual LineString GetLineString()
{
var wkbReader = new WKBReader();
var geometry = wkbReader.Read(Coord);
var lineString = (LineString)geometry;
return(lineString);
}
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);
}
private static string ConvertWKBToWKT(byte[] wkbBytes)
{
WKBReader reader = new WKBReader();
WKTWriter writer = new WKTWriter();
var wktText = writer.Write(reader.Read(wkbBytes));
return(wktText);
}
private static void TestBase64TextFile(Stream file)
{
byte[] wkb = ConvertBase64(file);
var wkbReader = new WKBReader();
Geometry geom = null;
Assert.DoesNotThrow(() => geom = wkbReader.Read(wkb));
}
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 WellKnownBinaryReader()
{
_wkbReader = new WKBReader(new NtsGeometryServices(
GeometryConfiguration.GeometryFactory.CoordinateSequenceFactory,
GeometryConfiguration.GeometryFactory.PrecisionModel,
GeometryConfiguration.GeometryFactory.SRID
)
);
}
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());
}
/// <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>
/// Method to read
/// </summary>
/// <param name="reader"></param>
/// <param name="wkbReader"></param>
/// <returns></returns>
public static GpkgStandardBinary Read(BinaryReader reader, WKBReader wkbReader)
{
return(new GpkgStandardBinary
{
Header = GpkgBinaryHeader.Read(reader),
WellKnownBytes = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position)),
_wkbReader = wkbReader
});
}
/// <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 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 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));
}
/// <summary>
///
/// </summary>
public void Start()
{
try
{
Write(multiPoint.Area);
Write(multiPoint.Boundary);
Write(multiPoint.BoundaryDimension);
Write(multiPoint.Centroid);
Write(multiPoint.Coordinate);
Write(multiPoint.Coordinates);
Write(multiPoint.Dimension);
Write(multiPoint.Envelope);
Write(multiPoint.EnvelopeInternal);
Write(multiPoint.Geometries.Length);
Write(multiPoint.InteriorPoint);
Write(multiPoint.IsEmpty);
Write(multiPoint.IsSimple);
Write(multiPoint.IsValid);
Write(multiPoint.Length);
Write(multiPoint.NumGeometries);
Write(multiPoint.NumPoints);
Write(multiPoint.Buffer(10));
Write(multiPoint.Buffer(10, new BufferParameters {
EndCapStyle = EndCapStyle.Flat
}));
Write(multiPoint.Buffer(10, new BufferParameters {
EndCapStyle = EndCapStyle.Square
}));
Write(multiPoint.Buffer(10, 20));
Write(multiPoint.Buffer(10, new BufferParameters(20)
{
EndCapStyle = EndCapStyle.Flat
}));
Write(multiPoint.Buffer(10, new BufferParameters(20)
{
EndCapStyle = EndCapStyle.Square
}));
Write(multiPoint.ConvexHull());
byte[] bytes = multiPoint.AsBinary();
var test1 = new WKBReader().Read(bytes);
Write(test1.ToString());
bytes = new GDBWriter().Write(multiPoint);
test1 = new GDBReader().Read(bytes);
Write(test1.ToString());
}
catch (Exception ex)
{
throw ex;
}
}
static void Main(string[] args)
{
Geodatabase geo = Geodatabase.Open("");
List <Table> tables = new List <Table>();
List <string> featureClasses = geo.GetChildDatasets("\\", "Feature Class").ToList();
foreach (string featureClassName in featureClasses)
{
tables.Add(geo.OpenTable(featureClassName));
}
string createTableSqlCommand = CreateTableColumns(tables[0].FieldInformation);
FieldInfo fieldInfo = tables[0].FieldInformation;
var fields = new List <string>();
for (int i = 0; i < fieldInfo.Count; i++)
{
fields.Add(fieldInfo.GetFieldName(i));
}
var countStatements = $"SELECT * FROM VAULTSCOT_AUTH_POINT_OCT18";
RowCollection rows = geo.ExecuteSQL(countStatements);
WKBReader reader = new WKBReader();
foreach (Row row in rows)
{
MultiPointShapeBuffer geometry = row.GetGeometry();
var point = geometry.Points;
//MULTIPOINT (295512,712727,0) throwing format exception - Resolved in upcoming commit.
var geometryWKT = processMultiPointBuffer(geometry);
}
var countEnumerator = rows.GetEnumerator();
List <object> fieldValues = new List <object>();
if (rows != null)
{
countEnumerator.MoveNext();
var shape = countEnumerator.Current["Shape"];
for (int i = 0; i < fieldInfo.Count - 1; i++)
{
var count = countEnumerator.Current[fields[i]];
fieldValues.Add(count);
}
}
InsertTableValues(fieldValues, fieldInfo);
}
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);
}
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 void TestBase64TextFile(string file)
{
if (!File.Exists(file))
{
Assert.Ignore("File not present ({0})", file);
return;
}
byte[] wkb = ConvertBase64(file);
WKBReader wkbReader = new WKBReader();
IGeometry geom = null;
Assert.DoesNotThrow(() => geom = wkbReader.Read(wkb));
}
/// <summary>
/// Returns the geometry corresponding to the Object ID
/// </summary>
/// <param name="oid">Object ID</param>
/// <returns>geometry</returns>
public override Geometry GetGeometryByID(uint oid)
{
using (var ogrLayer = GetLayer(_layerIndex))
using (var ogrFeature = ogrLayer.GetFeature((int)oid))
{
using (var gr = ogrFeature.GetGeometryRef())
{
var reader = new WKBReader(Factory);
//var g = ParseOgrGeometry(gr, Factory);
var g = new OgrGeometryReader(Factory).Read(gr);
return(g);
}
}
}
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));
};
}
/// <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;
}
/// <summary>
/// Creates a <see cref="NetTopologySuite.Geometries.Geometry"/> based on the Well-known binary representation.
/// </summary>
/// <param name="reader">A <see cref="System.IO.BinaryReader">BinaryReader</see> used to read the Well-known binary representation.</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>A <see cref="NetTopologySuite.Geometries.Geometry"/> based on the Well-known binary representation.</returns>
public static Geometry Parse(BinaryReader reader, GeometryFactory factory)
{
WKBReader wkb = new WKBReader();
return(wkb.Read(reader.BaseStream));
/*
* // Get the first Byte in the array. This specifies if the WKB is in
* // XDR (big-endian) format of NDR (little-endian) format.
* var byteOrder = reader.ReadByte();
*
* // Get the type of this geometry.
* var type = ReadUInt32(reader, (WkbByteOrder) byteOrder);
*
* switch ((WKBGeometryType) type)
* {
* case WKBGeometryType.wkbPoint:
* return CreateWKBPoint(reader, (WkbByteOrder) byteOrder, factory);
*
* case WKBGeometryType.wkbLineString:
* return CreateWKBLineString(reader, (WkbByteOrder)byteOrder, factory);
*
* case WKBGeometryType.wkbPolygon:
* return CreateWKBPolygon(reader, (WkbByteOrder)byteOrder, factory);
*
* case WKBGeometryType.wkbMultiPoint:
* return CreateWKBMultiPoint(reader, (WkbByteOrder)byteOrder, factory);
*
* case WKBGeometryType.wkbMultiLineString:
* return CreateWKBMultiLineString(reader, (WkbByteOrder)byteOrder, factory);
*
* case WKBGeometryType.wkbMultiPolygon:
* return CreateWKBMultiPolygon(reader, (WkbByteOrder)byteOrder, factory);
*
* case WKBGeometryType.wkbGeometryCollection:
* return CreateWKBGeometryCollection(reader, (WkbByteOrder)byteOrder, factory);
*
* default:
* if (!Enum.IsDefined(typeof (WKBGeometryType), type))
* throw new ArgumentException("Geometry type not recognized");
* else
* throw new NotSupportedException("Geometry type '" + type + "' not supported");
* }
*/
}
