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())); } }