public void TestRoundTrip(string filename) { // // can't round trip since I added the ToExternal/ ToInternal to the shapefile readers and writers. // PrecisionModel pm = new PrecisionModel(); GeometryFactory geometryFactory = new GeometryFactory(pm,-1); int differenceCount=0; string testName=""; string srcShpFilename= Global.GetUnitTestRootDirectory()+@"\IO\Shapefile\Testfiles\"+filename; string destShpFilename = Global.GetUnitTestRootDirectory()+@"\IO\Shapefile\Testfiles\testroundtrip"+filename; // do the round trip ShapefileReader shpReader = new ShapefileReader(srcShpFilename+".shp", geometryFactory); GeometryCollection shapes = shpReader.ReadAll(); ShapefileWriter.Write(destShpFilename,shapes, geometryFactory); // perfom binary compare on the .shp testName = String.Format("Test round trip .shp - {0}",filename); differenceCount = Compare.BinaryCompare(srcShpFilename+".shp", destShpFilename+".shp"); Assertion.AssertEquals(testName,0,differenceCount); // perfom binary compare on the .shx file testName = String.Format("Test round trip .shx - {0}",filename); differenceCount = Compare.BinaryCompare(srcShpFilename+".shx", destShpFilename+".shx"); Assertion.AssertEquals(testName,0,differenceCount); }
public static bool TestHelper(string wkt) { PrecisionModel pm = new PrecisionModel(1, 0, 0); GeometryFactory fact = new GeometryFactory(pm, 0); //read wkt Geometry a = (Geometry)fact.CreateFromWKT(wkt); //write wkb FileStream fs = new FileStream("TestFile.wkb", FileMode.Create); BinaryWriter bw = new BinaryWriter(fs); GeometryWKBWriter bWriter = new GeometryWKBWriter(fact); bWriter.Write(a, bw, (byte)1); bw.Close(); fs.Close(); //read wkb fs = new FileStream("TestFile.wkb", FileMode.Open); byte[] bytes = new byte[fs.Length]; for(int i = 0; i < fs.Length; i++) { bytes[i] = (byte)fs.ReadByte(); } GeometryWKBReader bReader = new GeometryWKBReader(fact); Geometry geom = bReader.Create(bytes); fs.Close(); //write to wkt & compare with original text. bool results = ( Compare.WktStrings(wkt,a.ToText())); return results; }
public abstract int GetLength(Geometry geometry); //length in 16bit words public static Envelope GetEnvelopeExternal(PrecisionModel precisionModel, Envelope envelope) { // get envelopse in external coordinates Coordinate min = new Coordinate(envelope.MinX, envelope.MinY); Coordinate max = new Coordinate(envelope.MaxX, envelope.MaxY); min = precisionModel.ToExternal(min); max = precisionModel.ToExternal(max); Envelope bounds = new Envelope(min.X, max.X, min.Y, max.Y); return bounds; }
/// <summary> /// Initializes a GeometryCollection. /// </summary> /// <param name="geometries"> /// The Geometries for this GeometryCollection, or null or an /// empty array to create the empty geometry. Elements may be empty /// Geometries, but not nulls. /// </param> /// <param name="precisionModel"> /// The specification of the grid of allowable points for this GeometryCollection. /// </param> /// <param name="SRID"> /// The ID of the Spatial Reference System used by this GeometryCollection. /// </param> public GeometryCollection(Geometry[] geometries, PrecisionModel precisionModel, int SRID) : base(precisionModel,SRID) { if(geometries == null) { geometries = new Geometry[]{}; } if(HasNullElements(geometries)) { throw new ArgumentException("Geometries must not contain null elements."); } this._geometries = geometries; }
/// <summary> /// Initializes a new instance of the MultiPolygon class. /// </summary> /// <param name="polygons"> /// The Polygons for this MultiPolygon, or null or an empty array to create /// the empty geometry. Elements may be empty Polygons, but not nulls. The /// polygons must conform to the assertions specified in the /// OpenGIS Simple Features Specification. /// </param> /// <param name="precisionModel">The specification of the grid of allowable /// points for this MultiPolygon.</param> /// <param name="SRID"> /// The ID of the Spatial Reference System used by this MultiPolygon. /// </param> internal MultiPolygon(Polygon[] polygons, PrecisionModel precisionModel, int SRID) : base(polygons, precisionModel, SRID) { if(polygons == null) { polygons = new Polygon[]{}; } if (HasNullElements(polygons)) { throw new ArgumentNullException("Polygon array must not contain null elements."); } _geometries = polygons; }
/// <summary> /// Initializes a new instance of the MultiLineString class. /// </summary> /// <param name="lineStrings"> /// The LineStrings for this MultiLineString, or null or an /// empty array to create the empty MultiLineString. Elements may be empty /// LineStrings, but not nulls. /// </param> /// <param name="precisionModel"> /// The specification of the grid of allowable points for this MultiLineString. /// </param> /// <param name="SRID"> /// The ID of the Spatial Reference System used by this MultiLineString. /// </param> internal MultiLineString(LineString[] lineStrings, PrecisionModel precisionModel, int SRID) : base(lineStrings, precisionModel, SRID) { if(lineStrings == null) { lineStrings = new LineString[]{}; } if(HasNullElements(lineStrings)) { throw new ArgumentException("MultiLineStrings cannot have nulls."); } _geometries = lineStrings; }
/// <summary> /// Initializes a new instance LinearRing with the given points. /// </summary> /// <param name="points"> /// Points forming a closed and simple linestring, or null or an empty array /// to create the empty geometry. This array must not contain null elements. /// Consecutive points may not be equal. /// </param> /// <param name="precisionModel"> /// The specification of the grid of allowable points for this LinearRing. /// </param> /// <param name="SRID"> /// The ID of the Spatial Reference System used by this LinearRing. /// </param> internal LinearRing(Coordinates points, PrecisionModel precisionModel, int SRID) : base(points,precisionModel,SRID) { if (!IsEmpty() && !base.IsClosed()) { // uses base.IsClosed() since this.IsClosed() always returns true. throw new ArgumentException("Points must form a closed linestring."); } if ((points != null) && (points.Count >= 1 && points.Count <= 3)) { throw new ArgumentException("Points must contain 0 or >3 elements."); } }
/// <summary> /// Constructs a LineString with the given points. /// </summary> /// <param name="points"> /// The points of the linestring, or null to create the empty geometry. This array must not contain null /// elements. Consecutive points may not be equal. /// </param> /// <param name="precisionModel">The specification of the grid of allowable points for this LineString.</param> /// <param name="SRID"> The ID of the Spatial Reference System used by this LineString.</param> internal LineString(Coordinates points, PrecisionModel precisionModel, int SRID) : base( precisionModel, SRID) { if (points == null) { points = new Coordinates(); } if (HasNullElements(points)) { throw new ArgumentNullException("point array must not contain null elements"); } if (points.Count == 1) { throw new ArgumentException("point array must contain 0 or >1 elements"); } this._points = points; }
/// <summary> /// Writes three geometries to an svg file /// </summary> /// <param name="filename">The path of the svg file.</param> /// <param name="a">The A geometry</param> /// <param name="b">The B geometry</param> /// <param name="c">The C geometry</param> public void DisplayTest(string filename, Geometry a, Geometry b, Geometry c) { Geotools.Geometries.PrecisionModel pm = new Geotools.Geometries.PrecisionModel(1, 0, 0); GeometryFactory fact = new GeometryFactory(pm, 0); GeometrySVGWriter svgWriter = new GeometrySVGWriter(fact.PrecisionModel); StreamWriter sw = new StreamWriter(filename); GeometryCollection geomCollection= fact.CreateGeometryCollection(new Geometry[]{a,b,c}); double minx, miny, maxx, maxy; geomCollection.Extent2D(out minx, out miny, out maxx, out maxy); sw.WriteLine(String.Format("<svg viewBox=\"{0} {1} {2} {3}\">",minx,miny,maxx,maxy*1.2)); svgWriter.Write(a,sw,"fill-rule:evenodd;","fill:none;stroke:blue;stroke-width:1;fill-opacity:0.2"); svgWriter.Write(b,sw,"fill-rule:evenodd;","fill:none;stroke:red;stroke-width:1;fill-opacity:0.2"); svgWriter.Write(c,sw,"fill-rule:evenodd;","fill:yellow;stroke:green;stroke-width:2;fill-opacity:0.5;stroke-dasharray:2,2"); sw.WriteLine("</svg>"); sw.Close(); }
/// <summary> /// Creates the DecimalFormat used to write doubles /// with a sufficient number of decimal places. /// </summary> /// <param name="precisionModel">The precision model used to determine the number of /// decimal places to write.</param> /// <returns>Returns a DecimalFormat object that writes doubles without scientific notation.</returns> private static string CreateFormatter(PrecisionModel precisionModel) { return "r"; /* // the default number of decimal places is 16, which is sufficient // to accomodate the maximum precision of a double. int decimalPlaces = 16; if (! precisionModel.isFloating()) { decimalPlaces = 1 + (int) Math.ceil(Math.log(precisionModel.GetScale()) / Math.log(10)); } return new DecimalFormat("#" + (decimalPlaces > 0 ? "." : "") + stringOfChar('#', decimalPlaces)); return null;*/ }
/// <summary> /// Test getting and setting the properties /// </summary> public void Test_MultipleRead() { PrecisionModel pm = new PrecisionModel(1,0,0); GeometryFactory geometryFactory = new GeometryFactory(pm,-1); string filename= Global.GetUnitTestRootDirectory()+@"\IO\Shapefile\Testfiles\statepop.shp"; // tests two readers reading the file as the same time. Geotools.IO.ShapefileReader shpFile = new Geotools.IO.ShapefileReader(filename, geometryFactory); Geotools.IO.ShapefileReader shpFile2 = new Geotools.IO.ShapefileReader(filename, geometryFactory); foreach(object row in shpFile) { Assertion.AssertNotNull(row); foreach(object row2 in shpFile2) { Assertion.AssertNotNull(row2); } } }
public void Test_CreateDataTable() { PrecisionModel pm = new PrecisionModel(100,0,0); GeometryFactory geometryFactory = new GeometryFactory(pm,-1); string filename= Global.GetUnitTestRootDirectory()+@"\IO\Shapefile\Testfiles\statepop"; DataTable table = Geotools.IO.Shapefile.CreateDataTable(filename, "State", geometryFactory); DataSet ds = new DataSet(); ds.Tables.Add(table); // make sure the datagrid gets the column headings. DataGrid grid = new DataGrid(); grid.DataSource = ds; grid.DataMember="State"; grid.DataBind(); TextWriter tempWriter = new StringWriter(); grid.RenderControl(new HtmlTextWriter(tempWriter)); string html = tempWriter.ToString(); bool same = Compare.CompareAgainstString(Global.GetUnitTestRootDirectory()+@"\IO\Shapefile\Testfiles\ExpectedDataGridDataReader.txt",html); Assertion.AssertEquals("Datagrid properties",true,same); }
/// <summary> /// Initializes a Polygon with the given exterior boundary. The shell and holes /// must conform to the assertions specified in the OpenGIS Simple Features /// Specification for SQL. /// </summary> /// <param name="shell"> /// The outer boundary of the new Polygon, or null or an empty LinearRing if the empty /// geometry is to be created. Must be oriented clockwise. /// </param> /// <param name="holes"> /// The inner boundaries of the new Polygon, or null or empty LinearRings if the empty /// geometry is to be created. Each must be oriented counterclockwise. /// </param> /// <param name="precisionModel"> /// The specification of the grid of allowable points for this Polygon. /// </param> /// <param name="SRID"> /// The ID of the Spatial Reference System used by this Polygon. /// </param> internal Polygon(LinearRing shell, LinearRing[] holes, PrecisionModel precisionModel, int SRID) : base(precisionModel, SRID) { if (shell == null) { shell = _geometryFactory.CreateLinearRing(null); } if (holes == null) { holes = new LinearRing[]{}; } //OPTIMIZE: - if fully optimzed, don't bother doing this test. if (HasNullElements(holes)) { throw new ArgumentNullException("holes must not contain null elements"); } if (shell.IsEmpty() && HasNonEmptyElements(holes)) { throw new ArgumentException("shell is empty but holes are not"); } _shell = shell; _holes = holes; }
public void Test_TestRead() { PrecisionModel pm = new PrecisionModel(100000,0,0); GeometryFactory geometryFactory = new GeometryFactory(pm,-1); //DataSets can be enumerated thru, or you can use Read(). This one tests the read; string filename= Global.GetUnitTestRootDirectory()+@"\IO\Shapefile\Testfiles\statepop"; ShapefileDataReader shpDataReader = Geotools.IO.Shapefile.CreateDataReader(filename, geometryFactory); int i=0; while (shpDataReader.Read()) { i++; } Assertion.AssertEquals("Read using Read()",49,i); }
public void Test_TestGets() { PrecisionModel pm = new PrecisionModel(1,0,0); GeometryFactory geometryFactory = new GeometryFactory(pm,-1); string filename= Global.GetUnitTestRootDirectory()+@"\IO\Shapefile\Testfiles\statepop"; ShapefileDataReader shpDataReader = Geotools.IO.Shapefile.CreateDataReader(filename, geometryFactory); // note alaska and hawaii are missing - hence 48 states not 50. // tests GetValues(). object[] values = new object[shpDataReader.FieldCount]; foreach(object columnValues in shpDataReader) { if (columnValues==null) { Assertion.Fail("columnValues should have data."); } // get values using GetValue() for(int i = 0; i < shpDataReader.FieldCount; i++) { values[i] = shpDataReader.GetValue(i); } // get values using GetValues() object[] values2=new object[shpDataReader.FieldCount]; shpDataReader.GetValues(values2); // ensure they are both the same. for(int i = 0; i < shpDataReader.FieldCount; i++) { Assertion.AssertEquals("Values "+i, values[i], values2[i]); } } }
public GeometrySVGWriter(PrecisionModel precisionModel, string xmlNamespace, int decimalPlaces) { _formatterString = CreateFormatter(decimalPlaces); _namespace = xmlNamespace; _precisionModel = precisionModel; }
/// <summary> /// Initializes a new instance of the GeometrySVGWriter class. /// </summary> public GeometrySVGWriter(PrecisionModel precisionModel): this(precisionModel,"",5) { }
/// <summary> /// Converts a Coordinate to <Point> format, then Appends /// it to the writer. /// </summary> /// <param name="coordinate">The Coordinate to process.</param> /// <param name="writer">The output writer to Append to.</param> /// <param name="precisionModel">The PrecisionModel to use to convert /// from a precise coordinate to an external coordinate</param> protected void AppendCoordinate(Coordinate coordinate, TextWriter writer, PrecisionModel precisionModel) { //throw new NotFiniteNumberException(); Coordinate externalCoordinate = new Coordinate(); precisionModel.ToExternal(coordinate, externalCoordinate); writer.Write(" " + WriteNumber(externalCoordinate.X) + " " + WriteNumber(externalCoordinate.Y)); //writer.Write(WriteNumber(coordinate.X) + " " + WriteNumber(coordinate.Y)); }
/// <summary> /// Converts a Coordinate to <Point Tagged Text> format, /// then Appends it to the writer. /// </summary> /// <param name="coordinate">the <code>Coordinate</code> to process</param> /// <param name="writer">the output writer to Append to</param> /// <param name="precisionModel">the PrecisionModel to use to convert /// from a precise coordinate to an external coordinate</param> protected void AppendPointTaggedText(Coordinate coordinate, TextWriter writer, PrecisionModel precisionModel) { Coordinate externalCoordinate = new Coordinate(); precisionModel.ToExternal(coordinate, externalCoordinate); if (this._cssClass!="") { writer.WriteLine(String.Format("<{5}circle class=\"{0}\" style=\"{1}\" cx=\"{2}\" cy=\"{3}\" r=\"{4}\"/>",_cssClass,_style,WriteNumber(externalCoordinate.X),WriteNumber(externalCoordinate.Y),_radius,_namespace)); } else { writer.WriteLine(String.Format("<{4}circle style=\"{0}\" cx=\"{1}\" cy=\"{2}\" r=\"{3}\"/>",_style,WriteNumber(externalCoordinate.X),WriteNumber(externalCoordinate.Y),_radius,_namespace)); } }
/// <summary> /// Converts a Coordinate to <Point Tagged Text> format, /// then Appends it to the writer. /// </summary> /// <param name="coordinate">the <code>Coordinate</code> to process</param> /// <param name="level"></param> /// <param name="writer">the output writer to Append to</param> /// <param name="precisionModel">the PrecisionModel to use to convert /// from a precise coordinate to an external coordinate</param> protected void AppendPointTaggedText(Coordinate coordinate, int level, StringWriter writer, PrecisionModel precisionModel) { writer.Write("POINT "); AppendPointText(coordinate, level, writer, precisionModel); }
public void Test2() { IDbConnection connection = Global.GetEPSGDatabaseConnection(); PrecisionModel pm = new PrecisionModel(100.0, 0.0, 0.0); CoordinateTransformationEPSGFactory CTfactory = new CoordinateTransformationEPSGFactory(connection); ICoordinateTransformation UKNationalGrid1 = CTfactory.CreateFromTransformationCode("1681"); GeometryFactory geometryFactory = new GeometryFactory(pm,4326); string wkt = "POINT ( -1 50 )"; Assertion.AssertEquals("Point 1",true,Compare2(wkt,"POINT (471659.59 11644.49)", geometryFactory, UKNationalGrid1)); }
/// <summary> /// Creates a GeometryFactory that creates Geometrys using the given precisionModel and SRID. /// </summary> /// <param name="precisionModel">the specification of the grid of allowable points for Geometrys created by this GeometryFactory.</param> /// <param name="SRID">The ID of the Spatial Reference System used by Geometry created by this GeometryFactory.</param> public GeometryFactory(PrecisionModel precisionModel, int SRID) { _precisionModel = precisionModel; _SRID = SRID; }
public void test_Coords() { PrecisionModel precisionModel = new PrecisionModel(); //Set the coord to be empty Coordinate coord = new Coordinate(); coord = null; //create a new point GeometryFactory gf = new GeometryFactory(_precMod, _sRID); Point point = gf.CreatePoint(coord); //test that true is returned because the coordinates are empty. Assertion.AssertEquals("Coords - true: ", true, point.IsEmpty()); //Put something into the coordinates Coordinate coordinate = new Coordinate(1.0,2.0); //create a new point point = gf.CreatePoint(coordinate); //test that false is returned because the coordinates are not empty. Assertion.AssertEquals("Coords - false: ", false, point.IsEmpty()); }
/// <summary> /// Copy constructor to create a new PrecisionModel from an existing one. /// </summary> /// <param name="pm">The existing precisionmodel to use to create the new one.</param> public PrecisionModel(PrecisionModel pm) { _modelType = pm.ModelType; _scale = pm.Scale; _offsetX = pm.OffsetX; _offsetY = pm.OffsetY; }
/// <summary> /// Initializes a new instance of the GeometryGraph class. /// </summary> public GeometryGraph( int argIndex, Geometry parentGeometry ) { _argIndex = argIndex; _parentGeometry = parentGeometry; if ( parentGeometry != null ) { _precisionModel = parentGeometry.PrecisionModel; _SRID = parentGeometry.GetSRID(); Add( parentGeometry ); } }
/// <summary> /// Converts a Coordinate to Point Text format then Appends it to the writer. /// </summary> /// <param name="coordinate">The Coordinate to process.</param> /// <param name="level"></param> /// <param name="writer">The output stream writer to Append to.</param> /// <param name="precisionModel">The PrecisionModel to use to convert from a precise /// coordinate to an external coordinate.</param> protected void AppendPointText( Coordinate coordinate, int level, StringWriter writer, PrecisionModel precisionModel) { if (coordinate == null) { writer.Write("EMPTY"); } else { writer.Write("("); AppendCoordinate(coordinate, writer, precisionModel); writer.Write(")"); } }
public void Test_TestConstructor() { PrecisionModel pm = new PrecisionModel(100000,0,0); GeometryFactory geometryFactory = new GeometryFactory(pm,-1); string filename= Global.GetUnitTestRootDirectory()+@"\IO\Shapefile\Testfiles\statepop"; ShapefileDataReader shpDataReader = Geotools.IO.Shapefile.CreateDataReader(filename, geometryFactory); int i=0; //for( i=0;i<shpDataReader.FieldCount;i++) //{ // Console.WriteLine(i+" "+shpDataReader.GetName(i) +" " +shpDataReader.GetFieldType(i)); //} Assertion.AssertEquals("Dbase header: Num records", 49, shpDataReader.RecordCount); Assertion.AssertEquals("Dbase header: Num fields", 253, shpDataReader.FieldCount); Assertion.AssertEquals("Field 1: name", "STATE_NAME", shpDataReader.GetName(1)); Assertion.AssertEquals("Field 1: name", typeof(string), shpDataReader.GetFieldType(1)); Assertion.AssertEquals("Field 252: name", "SAMP_POP", shpDataReader.GetName(252)); Assertion.AssertEquals("Field 252: name", typeof(double), shpDataReader.GetFieldType(252)); // note alaska and hawaii are missing - hence 48 states not 50. i=0; foreach(object columnValues in shpDataReader) { if (columnValues==null) { Assertion.Fail("columnValues should not be null."); } if (i==0) { Assertion.AssertEquals("Row1: STATE_NAME:","Illinois", shpDataReader.GetString(1)); Assertion.AssertEquals("Row1: STATE_FIPS:","17", shpDataReader.GetValue(2)); Assertion.AssertEquals("Row1: SAMP_POP", 1747776.0, shpDataReader.GetDouble(252)); } if (i==48) { Assertion.AssertEquals("Row1: STATE_NAME:","Washington", shpDataReader.GetString(1)); Assertion.AssertEquals("Row1: STATE_FIPS:","53", shpDataReader.GetValue(2)); Assertion.AssertEquals("Row1: SAMP_POP", 736744.0, shpDataReader.GetDouble(252)); } i++; } Assertion.AssertEquals("49 Records",49,i); // try opening the file again, to make sure file is not locked from previous reader. ShapefileDataReader shpDataReader2 = Geotools.IO.Shapefile.CreateDataReader(filename, geometryFactory); i=0; while (shpDataReader2.Read()) { if (i==0) { Assertion.AssertEquals("Row1: STATE_NAME:","Illinois", shpDataReader2.GetString(1)); Assertion.AssertEquals("Row1: STATE_FIPS:","17", shpDataReader2.GetValue(2)); Assertion.AssertEquals("Row1: SAMP_POP", 1747776.0, shpDataReader2.GetDouble(252)); } if (i==48) { Assertion.AssertEquals("Row1: STATE_NAME:","Washington", shpDataReader2.GetString(1)); Assertion.AssertEquals("Row1: STATE_FIPS:","53", shpDataReader2.GetValue(2)); Assertion.AssertEquals("Row1: SAMP_POP", 736744.0, shpDataReader2.GetDouble(252)); } i++; } Assertion.AssertEquals("49 Records",49,i); }
private void PerformSystemTest(string filename) { //Geometries.PrecisionModel pm = new Geometries.PrecisionModel(); Run run = GetTestRun(filename); int testCount=0; int failCount=0; int opCount=0; int resultCount=0; foreach(TestRunner.TestCase testcase in run) { foreach(TestRunner.Test test in testcase) { Geotools.Geometries.PrecisionModel pm; if (run.PrecisionModel.Type=="FLOATING") { pm = new Geotools.Geometries.PrecisionModel(); } else { pm = new Geotools.Geometries.PrecisionModel(double.Parse(run.PrecisionModel.Scale), double.Parse(run.PrecisionModel.OffSetX), double.Parse(run.PrecisionModel.OffSetY)); } testCount++; Geometry a = null; Geometry b = null; if (testcase.A.Trim()!="") { a= (Geometry)testcase.CreateAGeometry(pm); } if (testcase.B.Trim()!="") { b= (Geometry)testcase.CreateBGeometry(pm); } test.Run(a, b, true); if(test.Passed == false) { Console.WriteLine(test.Operation.Name + " failed."+filename); failCount++; } else { //Console.WriteLine(t.Operation.Name + " passed."); //passedTests++; } } } //Console.WriteLine(filename); //Console.WriteLine("tests: "+testCount); //Console.WriteLine("failed "+failCount); //Console.WriteLine("Ops "+opCount); //Console.WriteLine("Creates "+resultCount); //Console.WriteLine("-----------------------------"); if (failCount>0) { Assertion.Fail(String.Format("{0} had {1} fails.",filename, failCount)); } }
/// <summary> /// Converts a Coordinate to <Point> format, then Appends /// it to the writer. /// </summary> /// <param name="coordinate">The Coordinate to process.</param> /// <param name="writer">The output writer to Append to.</param> /// <param name="precisionModel">The PrecisionModel to use to convert /// from a precise coordinate to an external coordinate</param> protected void AppendCoordinate(Coordinate coordinate, StringWriter writer, PrecisionModel precisionModel) { Coordinate externalCoordinate = new Coordinate(); precisionModel.ToExternal(coordinate, externalCoordinate); writer.Write(WriteNumber(externalCoordinate.X) + " " + WriteNumber(externalCoordinate.Y)); }
/// <summary> /// This constructor is used by clients that wish to add Edges explicitly, rather than adding a Geometry. (An example is BufferOp). /// </summary> /// <param name="argIndex"></param> /// <param name="precisionModel"></param> /// <param name="SRID"></param> public GeometryGraph(int argIndex, PrecisionModel precisionModel, int SRID) : this(argIndex, null) { _precisionModel = precisionModel; _SRID = SRID; }