public XmlTestFactory(PrecisionModel pm, IGeometryOperation geometryOperation, IResultMatcher resultMatcher) { ObjGeometryFactory = new GeometryFactory(pm); _geometryOperation = geometryOperation; _resultMatcher = resultMatcher; _objReader = new WKTOrWKBReader(ObjGeometryFactory); }
public void TestMakePrecise() { var pm10 = new PrecisionModel(0.1); PreciseCoordinateTester(pm10, 1200.4, 1240.4, 1200, 1240); PreciseCoordinateTester(pm10, 1209.4, 1240.4, 1210, 1240); }
public static IGeometry ReducePrecisionPointwise(IGeometry geom, double scaleFactor) { var pm = new PrecisionModel(scaleFactor); var reducedGeom = GeometryPrecisionReducer.Reduce(geom, pm); return reducedGeom; }
/// <summary>Reduces precision pointwise, then snap-rounds. /// <para/> /// Note that output set may not contain non-unique linework /// (and thus cannot be used as input to Polygonizer directly). /// <c>UnaryUnion</c> is one way to make the linework unique. /// </summary> /// <param name="geom">A Geometry containing linework to node</param> /// <param name="scaleFactor">The precision model scale factor to use</param> /// <returns>The noded, snap-rounded linework</returns> public static IGeometry SnapRoundLines( IGeometry geom, double scaleFactor) { var pm = new PrecisionModel(scaleFactor); var gsr = new GeometrySnapRounder(pm); gsr.LineworkOnly =true; var snapped = gsr.Execute(geom); return snapped; }
public void TestMakePreciseNegative() { var pm1 = new PrecisionModel(1); PreciseCoordinateTester(pm1, -10, -10, -10, -10); PreciseCoordinateTester(pm1, -9.9, -9.9, -10, -10); //We use "Asymmetric Arithmetic Rounding", that's is why this is true: PreciseCoordinateTester(pm1, -9.5, -9.5, -9, -9); }
public static IGeometry MCIndexNodingWithPrecision(IGeometry geom, double scaleFactor) { IPrecisionModel fixedPM = new PrecisionModel(scaleFactor); LineIntersector li = new RobustLineIntersector(); li.PrecisionModel = fixedPM; INoder noder = new MCIndexNoder(new IntersectionAdder(li)); noder.ComputeNodes(SegmentStringUtil.ExtractNodedSegmentStrings(geom)); return SegmentStringUtil.ToGeometry(noder.GetNodedSubstrings(), geom.Factory); }
public void large_decimals_are_formatted_properly() { const string expected = "123456789012345680"; const decimal m = 123456789012345680; IPrecisionModel precisionModel = new PrecisionModel(1E9); NumberFormatInfo formatter = CreateFormatter(precisionModel); string format = "0." + StringOfChar('#', formatter.NumberDecimalDigits); string actual = m.ToString(format, formatter); Assert.That(actual, Is.EqualTo(expected)); }
public GeometryPrecisionReducerTest() { pmFloat = new PrecisionModel(); pmFixed1 = new PrecisionModel(1); reducer = new GeometryPrecisionReducer(pmFixed1); reducerKeepCollapse = new GeometryPrecisionReducer(pmFixed1); gfFloat = new GeometryFactory(pmFloat, 0); reader = new WKTReader(gfFloat); reducerKeepCollapse.RemoveCollapsedComponents = false; }
public virtual void Intersection(string wktA, string wktB, PrecisionModel pm) { Console.WriteLine("Running example using Precision Model = " + pm); GeometryFactory fact = new GeometryFactory(pm); WKTReader wktRdr = new WKTReader(fact); IGeometry A = wktRdr.Read(wktA); IGeometry B = wktRdr.Read(wktB); IGeometry C = A.Intersection(B); Console.WriteLine("A intersection B = " + C); }
public static IGeometry NodeWithPointwisePrecision(IGeometry geom, double scaleFactor) { var pm = new PrecisionModel(scaleFactor); var roundedGeom = GeometryPrecisionReducer.Reduce(geom, pm); var geomList = new List<IGeometry>(); geomList.Add(roundedGeom); var noder = new GeometryNoder(pm); var lines = noder.Node(geomList); return Utility.FunctionsUtil.getFactoryOrDefault(geom).BuildGeometry(CollectionUtil.Cast<IGeometry>((ICollection)lines)); }
public void large_doubles_arent_formatted_properly() { /* * http://stackoverflow.com/questions/2105096/why-is-tostring-rounding-my-double-value * * By default, the return value only contains 15 digits of precision although a maximum of 17 digits is maintained internally. */ const string expected = "123456789012345680"; const double d = 123456789012345680; IPrecisionModel precisionModel = new PrecisionModel(1E9); NumberFormatInfo formatter = CreateFormatter(precisionModel); string format = "0." + StringOfChar('#', formatter.NumberDecimalDigits); string actual = d.ToString(format, formatter); Assert.That(actual, Is.Not.EqualTo(expected)); }
/// <summary> /// Imports a shapefile into a database table. /// </summary> /// <remarks> /// This method assumes a table has already been crated in the database. /// Calling this method does not close the connection that is passed in. /// </remarks> /// <param name="filename"></param> /// <param name="connectionstring"></param> /// <param name="tableName"></param> /// <returns></returns> public static int ImportShapefile(string filename, string connectionstring, string tableName) { using (SqlConnection connection = new SqlConnection(connectionstring)) { int rowsAdded = -1; PrecisionModel pm = new PrecisionModel(); GeometryFactory geometryFactory = new GeometryFactory(pm, -1); DataTable shpDataTable = CreateDataTable(filename, tableName, geometryFactory); string createTableSql = CreateDbTable(shpDataTable, true); SqlCommand createTableCommand = new SqlCommand(createTableSql, connection); connection.Open(); createTableCommand.ExecuteNonQuery(); string sqlSelect = String.Format("select * from {0}", tableName); SqlDataAdapter selectCommand = new SqlDataAdapter(sqlSelect, connection); // use a data adaptor - saves donig the inserts ourselves SqlDataAdapter dataAdapter = new SqlDataAdapter(); dataAdapter.SelectCommand = new SqlCommand(sqlSelect, connection); SqlCommandBuilder custCB = new SqlCommandBuilder(dataAdapter); DataSet ds = new DataSet(); // fill dataset dataAdapter.Fill(ds, shpDataTable.TableName); // copy rows from our datatable to the empty table in the DataSet int i = 0; foreach (DataRow row in shpDataTable.Rows) { DataRow newRow = ds.Tables[0].NewRow(); newRow.ItemArray = row.ItemArray; //gotcha! - new row still needs to be added to the table. //NewRow() just creates a new row with the same schema as the table. It does //not add it to the table. ds.Tables[0].Rows.Add(newRow); i++; } // update all the rows in batch rowsAdded = dataAdapter.Update(ds, shpDataTable.TableName); int iRows = shpDataTable.Rows.Count; Debug.Assert(rowsAdded != iRows, String.Format("{0} of {1] rows were added to the database.", rowsAdded, shpDataTable.Rows.Count)); return rowsAdded; } }
public static IGeometry SnapRound( IGeometry geomA, IGeometry geomB, double scaleFactor) { var pm = new PrecisionModel(scaleFactor); var geom = geomA; if (geomB != null) { geom = geomA.Factory.CreateGeometryCollection(new IGeometry[] { geomA, geomB }); } GeometrySnapRounder gsr = new GeometrySnapRounder(pm); var snapped = gsr.Execute(geom); return snapped; }
public void TestWriteLargeNumbers3() { IPrecisionModel precisionModel = new PrecisionModel(1E9); IGeometryFactory geometryFactory = new GeometryFactory(precisionModel, 0); IPoint point1 = geometryFactory.CreatePoint(new Coordinate(123456789012345678000000E9d, 10E9)); Assert.AreEqual(123456789012345690000000000000000d, point1.X); Assert.AreEqual(10000000000d, point1.Y); Assert.AreNotEqual("POINT (123456789012345690000000000000000 10000000000)", point1.AsText()); Assert.AreEqual("POINT (123456789012346000000000000000000 10000000000)", point1.AsText()); }
public void TestParameterlessConstructor() { var p = new PrecisionModel(); //Implicit precision model has scale 0 Assert.AreEqual(0, p.Scale, 1E-10); }
/// <summary> /// Copy constructor to create a new <c>PrecisionModel</c> /// from an existing one. /// </summary> /// <param name="pm"></param> public PrecisionModel(PrecisionModel pm) { _modelType = pm._modelType; _scale = pm._scale; }
/// <summary> /// Initializes a new instance of the <see cref="NtsProvider"/> class /// from another <see cref="IFeatureProvider" />. /// </summary> /// <param name="provider"> /// The base <see cref="IFeatureProvider"/> /// from witch initialize the <see cref="NtsProvider"/> instance. /// </param> /// <param name="operation"> /// The <see cref="GeometryOperationDelegate"/> to apply /// to all geometry elements in the <paramref name="provider"/>. /// </param> /// <param name="precisionModel"> /// The <see cref="NetTopologySuite.Geometries.PrecisionModel"/> /// to use for define the precision of the geometry operations. /// </param> /// <seealso cref="PrecisionModels"/> /// <seealso cref="NetTopologySuite.Geometries.GeometryFactory"/> public NtsProvider(IFeatureProvider provider, GeometryOperationDelegate operation, NetTopologySuite.Geometries.PrecisionModel precisionModel) : this(provider, precisionModel) { operation(features); }
/// <summary> /// Constructs a GeometryFactory that generates Geometries having the given /// <c>PrecisionModel</c> and spatial-reference ID, and the default CoordinateSequence /// implementation. /// </summary> /// <param name="precisionModel">The PrecisionModel to use.</param> /// <param name="srid">The SRID to use.</param> public GeometryFactory(PrecisionModel precisionModel, int srid) : this(precisionModel, srid, GetDefaultCoordinateSequenceFactory()) { }
public void TestWriteLargeNumbers2() { IPrecisionModel precisionModel = new PrecisionModel(1E9); IGeometryFactory geometryFactory = new GeometryFactory(precisionModel, 0); IPoint point1 = geometryFactory.CreatePoint(new Coordinate(1234d, 10E9)); Assert.AreEqual("POINT (1234 10000000000)", point1.AsText()); }
///<summary> /// Convenience method for doing precision reduction on a single geometry, /// with collapses removed and keeping the geometry precision model the same. ///</summary> /// <returns>The reduced geometry</returns> public static IGeometry Reduce(IGeometry g, PrecisionModel precModel) { var reducer = new SimpleGeometryPrecisionReducer(precModel); return reducer.Reduce(g); }
public NtsPrecisionModel(PrecisionModelType modelType, int scale) { WrappedPrecisionModel = new PrecisionModel(scale); }
public void TestML() { { const double scale = 2.0E10; IPrecisionModel precisionModel = new PrecisionModel(scale); IGeometryFactory geometryFactory = new GeometryFactory(precisionModel); var reader = new WKTReader(geometryFactory); var lineStringA = (ILineString) reader.Read("LINESTRING (-93.40178610435 -235.5437531975, -401.24229900825 403.69365857925)"); var lineStringB = (ILineString) reader.Read("LINESTRING (-50.0134121926 -145.44686640725, -357.8539250965 493.7905453695)"); var lineStringC = (ILineString) reader.Read("LINESTRING (-193.8964147753 -30.64653554935, -186.68866383205 -34.1176054623)"); var middlePoint = (IPoint) reader.Read("POINT (-203.93366864454998 174.171839481125)"); var lineStrings = new List<ILineString>(); lineStrings.Add(lineStringA); lineStrings.Add(lineStringB); lineStrings.Add(lineStringC); var noder = new GeometryNoder(geometryFactory.PrecisionModel); var nodedLineStrings = noder.Node(lineStrings.ToArray()); var shortestDistanceToPointBeforeNoding = double.MaxValue; foreach (var lineString in lineStrings) { shortestDistanceToPointBeforeNoding = Math.Min(lineString.Distance(middlePoint), shortestDistanceToPointBeforeNoding); } var shortestDistanceToPointAfterNoding = Double.MaxValue; foreach (var lineString in nodedLineStrings) { shortestDistanceToPointAfterNoding = Math.Min(lineString.Distance(middlePoint), shortestDistanceToPointAfterNoding); } var difference = Math.Abs(shortestDistanceToPointAfterNoding - shortestDistanceToPointBeforeNoding); Console.WriteLine("Scale: {0}", scale); Console.WriteLine("Distance to point before noding: {0}", shortestDistanceToPointBeforeNoding); Console.WriteLine("Distance to point after noding: {0}", shortestDistanceToPointAfterNoding); Console.WriteLine("Difference is {0} and should be lesser than {1}", difference, 1.0/scale); const double roughTolerance = 10.0; Assert.IsTrue(difference < roughTolerance, "this difference should should be lesser than " + 1.0/scale); } }
public bool LoadFile(string fileName) { if (!File.Exists(fileName)) { throw new ArgumentException(fileName, "The file does not exits or the 'fileName' is not valid."); } try { XmlDocument xmldoc = new XmlDocument(); xmldoc.Load(fileName); XmlElement root = xmldoc.DocumentElement; // Retrieve the "desc" tag, if any. XmlNode desc = root["desc"]; string strTestDescription = String.Empty; if (desc != null && desc.InnerText.Length > 0) { strTestDescription = desc.InnerText; } else { strTestDescription = Path.GetFileNameWithoutExtension(fileName); } // Retrieve the "workspace", if any. XmlNode workspace = root["workspace"]; if (workspace != null) { XmlAttributeCollection workspaceAttributes = workspace.Attributes; if (workspaceAttributes != null && workspaceAttributes.Count > 0) { m_strTestWorkspace = workspaceAttributes["dir"].InnerText; } } // Retrieve the "tolerance" attribute, if any. XmlNode tolerance = root["tolerance"]; double dTolerance = 0.0; if (tolerance != null) { string strTolerance = tolerance.InnerText; try { dTolerance = Double.Parse(strTolerance, GetNumberFormatInfo()); } catch (Exception ex) { XmlTestExceptionManager.Publish(ex); } } // Retrieve the precisionName" tag, if any. PrecisionModel pm = null; XmlNode precision = root["precisionModel"]; if (precision != null) { XmlAttributeCollection precisionAttributes = precision.Attributes; if (precisionAttributes != null && precisionAttributes.Count > 0) { XmlAttribute attribute = precisionAttributes["type"]; if (attribute != null) { string strPrecision = attribute.InnerText; if (strPrecision == "FIXED" && precisionAttributes.Count == 4) { try { double scale = Double.Parse(precisionAttributes["scale"].InnerText, GetNumberFormatInfo()); double offsetx = Double.Parse(precisionAttributes["offsetx"].InnerText, GetNumberFormatInfo()); double offsety = Double.Parse(precisionAttributes["offsety"].InnerText, GetNumberFormatInfo()); pm = new PrecisionModel(scale); } catch (Exception ex) { XmlTestExceptionManager.Publish(ex); } } else { pm = new PrecisionModel(); } } else { if (precisionAttributes.Count == 3) { double scale = Double.Parse(precisionAttributes["scale"].InnerText, GetNumberFormatInfo()); double offsetx = Double.Parse(precisionAttributes["offsetx"].InnerText, GetNumberFormatInfo()); double offsety = Double.Parse(precisionAttributes["offsety"].InnerText, GetNumberFormatInfo()); pm = new PrecisionModel(scale); } } } } if (pm == null) { pm = new PrecisionModel(); } IGeometryOperation geometryOperation = null; XmlNode go = root["geometryOperation"]; if (go != null) { go = go.FirstChild; switch (go.Value) { case "com.vividsolutions.jtstest.geomop.PreparedGeometryOperation": geometryOperation = new PreparedGeometryOperation(); break; case "com.vividsolutions.jtstest.geomop.BufferValidatedGeometryOperation": geometryOperation = new BufferValidatedGeometryOperation(); break; case "com.vividsolutions.jtstest.geomop.OverlayValidatedGeometryOperation": geometryOperation = new OverlayValidatedGeometryOperation(); break; default: Console.WriteLine(string.Format("\n *** {0} *** \n", go.Value)); Console.ReadKey(true); geometryOperation = new GeometryMethodOperation(); break; } } IResultMatcher resultMatcher = null; XmlNode rm = root["resultMatcher"]; if (rm != null) { rm = rm.FirstChild; if (rm.Value.EndsWith("BufferResultMatcher", StringComparison.InvariantCultureIgnoreCase)) resultMatcher = new BufferResultMatcher(); else { throw new NotSupportedException(); } } m_objFactory = new XmlTestFactory(pm, geometryOperation, resultMatcher); m_listCurTests = new XmlTestCollection(); m_listCurTests.Name = strTestDescription; // Now, handle the "case" nodes XmlNodeList elemList = xmldoc.GetElementsByTagName("case"); for (int i = 0; i < elemList.Count; i++) { ParseCaseNode(elemList[i], dTolerance); } m_listarrTests.Add(m_listCurTests); return true; } catch (Exception ex) { XmlTestExceptionManager.Publish(ex); return false; } }
public ConvexHullTest() { IPrecisionModel precisionModel = new PrecisionModel(1000); _geometryFactory = new GeometryFactory(precisionModel, 0); _reader = new WKTReader(_geometryFactory); }
public void TestReadLargeNumbers() { var precisionModel = new PrecisionModel(1E9); var geometryFactory = new GeometryFactory(precisionModel, 0); var reader = new WKTReader(geometryFactory); var point1 = reader.Read("POINT (123456789.01234567890 10)"); var point2 = geometryFactory.CreatePoint(new Coordinate(123456789.01234567890, 10)); Assert.AreEqual(point1.Coordinate.X, point2.Coordinate.X, 1E-7); Assert.AreEqual(point1.Coordinate.Y, point2.Coordinate.Y, 1E-7); }
/// <summary> /// Initializes a new instance of the <see cref="NtsProvider"/> class /// using the given <paramref name="precisionModel"/>. /// </summary> /// <param name="precisionModel"> /// The <see cref="NetTopologySuite.Geometries.PrecisionModel"/> /// to use for define the precision of the geometry operations. /// </param> /// <seealso cref="PrecisionModels"/> /// <seealso cref="NetTopologySuite.Geometries.GeometryFactory"/> protected internal NtsProvider(NetTopologySuite.Geometries.PrecisionModel precisionModel) { geometryFactory = new NetTopologySuite.Geometries.GeometryFactory(precisionModel); }
private static void DoPerformancesTest(int times) { const double d = 123456789; Stopwatch w = Stopwatch.StartNew(); for (int i = 0; i < times; i++) { string s = DoubleConverter.ToExactString(d + i); Assert.IsNotNull(s); } w.Stop(); TimeSpan usingDc = w.Elapsed; IPrecisionModel precisionModel = new PrecisionModel(1E9); NumberFormatInfo formatter = CreateFormatter(precisionModel); string format = "0." + StringOfChar('#', formatter.NumberDecimalDigits); w = Stopwatch.StartNew(); for (int i = 0; i < times; i++) { string s = d.ToString(format, formatter); Assert.IsNotNull(s); } w.Stop(); TimeSpan usingDef = w.Elapsed; if (usingDc <= usingDef) return; TimeSpan diff = usingDc - usingDef; Console.WriteLine("slower for {0}: {1} seconds", times, diff.TotalSeconds); }
/// <summary> /// Initializes a new instance of the <see cref="SimpleSnapRounder"/> class. /// </summary> /// <param name="pm">The <see cref="PrecisionModel" /> to use.</param> public SimpleSnapRounder(PrecisionModel pm) { _li = new RobustLineIntersector { PrecisionModel = pm }; _scaleFactor = pm.Scale; }
public OgcCompliantGeometryFactory(PrecisionModel pm, int srid) : base(pm, srid) { }
/// <summary> /// /// </summary> /// <param name="pm"></param> public SimpleGeometryPrecisionReducer(PrecisionModel pm) { _newPrecisionModel = pm; }
public OgcCompliantGeometryFactory(PrecisionModel pm, int srid, CoordinateSequenceFactory factory) : base(pm, srid, factory) { }
private void BufferReducedPrecision(int precisionDigits) { double sizeBasedScaleFactor = PrecisionScaleFactor(_argGeom, _distance, precisionDigits); // System.out.println("recomputing with precision scale factor = " + sizeBasedScaleFactor); var fixedPrecModel = new PrecisionModel(sizeBasedScaleFactor); BufferFixedPrecision(fixedPrecModel); }
/// <summary> /// Runs a ScaledNoder on input. /// Input vertices should be rounded to precision model. /// </summary> /// <param name="geom"></param> /// <param name="scaleFactor"></param> /// <returns>The noded geometry</returns> public static IGeometry ScaledNoding(IGeometry geom, double scaleFactor) { var segs = CreateSegmentStrings(geom); var fixedPM = new PrecisionModel(scaleFactor); var noder = new ScaledNoder(new MCIndexSnapRounder(new PrecisionModel(1.0)), fixedPM.Scale); noder.ComputeNodes(segs); var nodedSegStrings = noder.GetNodedSubstrings(); return SegmentStringUtil.ToGeometry(nodedSegStrings, geom.Factory); }
/// <summary> /// Constructs a GeometryFactory that generates Geometries having the given /// PrecisionModel, spatial-reference ID, and CoordinateSequence implementation. /// </summary> public GeometryFactory(PrecisionModel precisionModel, int srid, CoordinateSequenceFactory coordinateSequenceFactory) { _precisionModel = precisionModel; _coordinateSequenceFactory = coordinateSequenceFactory; _srid = srid; }
/// <summary> /// Initializes a new instance of the <see cref="NtsProvider"/> class /// from another <see cref="IFeatureProvider" />. /// </summary> /// <param name="provider"> /// The base <see cref="IFeatureProvider"/> /// from witch initialize the <see cref="NtsProvider"/> instance. /// </param> /// <param name="precisionModel"> /// The <see cref="NetTopologySuite.Geometries.PrecisionModel"/> /// to use for define the precision of the geometry operations. /// </param> /// <seealso cref="PrecisionModels"/> /// <seealso cref="NetTopologySuite.Geometries.GeometryFactory"/> public NtsProvider(IFeatureProvider provider, NetTopologySuite.Geometries.PrecisionModel precisionModel) : this(precisionModel) { BuildFromProvider(provider); }
/// Creates an instance of this class using the default /// values for <see cref="GeometryFactory.SRID"/>, /// <see cref="GeometryFactory.CoordinateSequenceFactory"/> but the /// specified <paramref name="pm"/>. public OgcCompliantGeometryFactory(PrecisionModel pm) : base(pm) { }
void RunRounding(string[] wkt) { var geoms = FromWKT(wkt); PrecisionModel pm = new PrecisionModel(SnapTolerance); GeometryNoder noder = new GeometryNoder(pm); noder.IsValidityChecked = true; var nodedLines = noder.Node(geoms); foreach ( var ls in nodedLines) Console.WriteLine(ls); Assert.IsTrue(IsSnapped(nodedLines, SnapTolerance)); }
public DistanceTest() { _precisionModel = new PrecisionModel(1); _geometryFactory = new GeometryFactory(_precisionModel, 0); _reader = new WKTReader(_geometryFactory); }