private static void generateLines(IGeometryFactory geometryFactory, ICollection <IGeometry> geometry, Random rndGen) { ICoordinateSequenceFactory coordinateSequenceFactory = geometryFactory.CoordinateSequenceFactory; ICoordinateFactory coordinateFactory = geometryFactory.CoordinateFactory; ICoordinateSequence coords = coordinateSequenceFactory.Create(CoordinateDimensions.Two); Int32 lineCount = rndGen.Next(10, 100); for (Int32 lineIndex = 0; lineIndex < lineCount; lineIndex++) { Int32 vertexCount = rndGen.Next(4, 15); ICoordinate coordinate = coordinateFactory.Create(rndGen.NextDouble() * 1000, rndGen.NextDouble() * 1000); coords.Add(coordinate); for (Int32 vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) { ICoordinate next = coordinateFactory.Create(coordinate[Ordinates.X] + rndGen.Next(-50, 50), coordinate[Ordinates.Y] + rndGen.Next(-50, 50)); coords.Add(next); coordinate = next; } ILineString line = geometryFactory.CreateLineString(coords); geometry.Add(line); } }
/// <summary> /// Constructs a GeometryFactory that generates Geometries having the given /// PrecisionModel, spatial-reference ID, and CoordinateSequence implementation. /// </summary> /// <param name="precisionModel"></param> /// <param name="srid"></param> /// <param name="coordinateSequenceFactory"></param> public GeometryFactory(PrecisionModel precisionModel, int srid, ICoordinateSequenceFactory coordinateSequenceFactory) { _precisionModel = precisionModel; _coordinateSequenceFactory = coordinateSequenceFactory; _srid = srid; }
/// <summary> /// Ensures that a CoordinateSequence forms a valid ring, /// returning a new closed sequence of the correct length if required. /// If the input sequence is already a valid ring, it is returned /// without modification. /// If the input sequence is too short or is not closed, /// it is extended with one or more copies of the start point. /// </summary> /// <param name="fact">The CoordinateSequenceFactory to use to create the new sequence</param> /// <param name="seq">The sequence to test</param> /// <returns>The original sequence, if it was a valid ring, or a new sequence which is valid.</returns> public static ICoordinateSequence EnsureValidRing(ICoordinateSequenceFactory fact, ICoordinateSequence seq) { int n = seq.Count; // empty sequence is valid if (n == 0) { return(seq); } // too short - make a new one if (n <= 3) { return(CreateClosedRing(fact, seq, 4)); } bool isClosed = seq.GetOrdinate(0, Ordinate.X) == seq.GetOrdinate(n - 1, Ordinate.X) && seq.GetOrdinate(0, Ordinate.Y) == seq.GetOrdinate(n - 1, Ordinate.Y); if (isClosed) { return(seq); } // make a new closed ring return(CreateClosedRing(fact, seq, n + 1)); }
/// <summary> /// Initialize reader with the given <c>GeometryFactory</c>. /// </summary> /// <param name="coordinateSequenceFactory"></param> /// <param name="precisionModel"> </param> /// <param name="handleOrdinates">The ordinates to handle</param> public PostGisReader(ICoordinateSequenceFactory coordinateSequenceFactory, IPrecisionModel precisionModel, Ordinates handleOrdinates) { _coordinateSequenceFactory = coordinateSequenceFactory; _precisionModel = precisionModel; HandleOrdinates = handleOrdinates; }
/// <summary> /// Constructs a GeometryFactory that generates Geometries having the given /// PrecisionModel, spatial-reference ID, and CoordinateSequence implementation. /// </summary> /// <param name="precisionModel"></param> /// <param name="SRID"></param> /// <param name="coordinateSequenceFactory"></param> public GeometryFactory(IPrecisionModel precisionModel, int SRID, ICoordinateSequenceFactory coordinateSequenceFactory) { this.precisionModel = precisionModel; this.coordinateSequenceFactory = coordinateSequenceFactory; this.srid = SRID; }
private static void DoTestCopy(ICoordinateSequenceFactory factory, int dimension) { // arrange var sequence = CreateSequenceFromOrdinates(factory, dimension); if (sequence.Count <= 7) { Console.WriteLine("sequence has a size of " + sequence.Count + ". Execution of this test needs a sequence " + "with more than 6 coordinates."); return; } var fullCopy = factory.Create(sequence.Count, dimension); var partialCopy = factory.Create(sequence.Count - 5, dimension); // act CoordinateSequences.Copy(sequence, 0, fullCopy, 0, sequence.Count); CoordinateSequences.Copy(sequence, 2, partialCopy, 0, partialCopy.Count); // assert for (int i = 0; i < fullCopy.Count; i++) { CheckCoordinateAt(sequence, i, fullCopy, i, dimension); } for (int i = 0; i < partialCopy.Count; i++) { CheckCoordinateAt(sequence, 2 + i, partialCopy, i, dimension); } // ToDo test if dimensions don't match }
private static ICoordinateSequence CreateCircularString(ICoordinateSequenceFactory factory, int dimension, Coordinate center, double radius, double startAngle, int numPoints) { const int numSegmentsCircle = 48; const double angleCircle = 2 * Math.PI; const double angleStep = angleCircle / numSegmentsCircle; var sequence = factory.Create(numPoints, dimension); var pm = new PrecisionModel(100); double angle = startAngle; for (int i = 0; i < numPoints; i++) { double dx = Math.Cos(angle) * radius; sequence.SetOrdinate(i, Ordinate.X, pm.MakePrecise(center.X + dx)); double dy = Math.Sin(angle) * radius; sequence.SetOrdinate(i, Ordinate.Y, pm.MakePrecise(center.Y + dy)); // set other ordinate values to predictable values for (int j = 2; j < dimension; j++) { sequence.SetOrdinate(i, (Ordinate)j, Math.Pow(10, j - 1) * i); } angle += angleStep; angle %= angleCircle; } return(sequence); }
protected static ICoordinateSequence AddCoordinateToSequence(ICoordinateSequence sequence, ICoordinateSequenceFactory factory, double x, double y, double?z, double?m) { // Create a new sequence var newSequence = factory.Create(sequence.Count + 1, sequence.Ordinates); // Copy old values var ordinates = OrdinatesUtility.ToOrdinateArray(sequence.Ordinates); for (var i = 0; i < sequence.Count; i++) { foreach (var ordinate in ordinates) { newSequence.SetOrdinate(i, ordinate, sequence.GetOrdinate(i, ordinate)); } } // new coordinate newSequence.SetOrdinate(sequence.Count, Ordinate.X, x); newSequence.SetOrdinate(sequence.Count, Ordinate.Y, y); if (z.HasValue) { newSequence.SetOrdinate(sequence.Count, Ordinate.Z, z.Value); } if (m.HasValue) { newSequence.SetOrdinate(sequence.Count, Ordinate.M, m.Value); } return(newSequence); }
///** Convience method for STRUCT construction. */ //private STRUCT toSTRUCT( Datum attributes[], String dataType ) // throws SQLException //{ // if( dataType.startsWith("*.")){ // dataType = "DRA."+dataType.substring(2);//TODO here // } // StructDescriptor descriptor = // StructDescriptor.createDescriptor( dataType, connection ); // return new STRUCT( descriptor, connection, attributes ); //} ///** // * Convience method for ARRAY construction. // * <p> // * Compare and contrast with toORDINATE - which treats <code>Double.NaN</code> // * as<code>NULL</code></p> // */ //private ARRAY toARRAY( double doubles[], String dataType ) // throws SQLException //{ // ArrayDescriptor descriptor = // ArrayDescriptor.createDescriptor( dataType, connection ); // return new ARRAY( descriptor, connection, doubles ); //} ///** // * Convience method for ARRAY construction. // */ //private ARRAY toARRAY( int ints[], String dataType ) // throws SQLException //{ // ArrayDescriptor descriptor = // ArrayDescriptor.createDescriptor( dataType, connection ); // return new ARRAY( descriptor, connection, ints ); //} ///** // * Convience method for NUMBER construction. // * <p> // * Double.NaN is represented as <code>NULL</code> to agree // * with JTS use.</p> // */ //private NUMBER toNUMBER( double number ) throws SQLException{ // if( Double.isNaN( number )){ // return null; // } // return new NUMBER( number ); //} /** * reverses the coordinate order * * @param factory * @param sequence * * @return CoordinateSequence reversed sequence */ private ICoordinateSequence reverse(ICoordinateSequenceFactory factory, ICoordinateSequence sequence) { var list = new CoordinateList(sequence.ToCoordinateArray()); list.Reverse(); return(factory.Create(list.ToCoordinateArray())); }
private static void generatePolygons(IGeometryFactory geometryFactory, ICollection <IGeometry> geometry, Random rndGen) { ICoordinateSequenceFactory coordinateSequenceFactory = geometryFactory.CoordinateSequenceFactory; ICoordinateFactory coordinateFactory = geometryFactory.CoordinateFactory; ICoordinateSequence coords = coordinateSequenceFactory.Create(CoordinateDimensions.Two); Int32 polyCount = rndGen.Next(10, 100); for (Int32 polyIndex = 0; polyIndex < polyCount; polyIndex++) { ICoordinate upperLeft = coordinateFactory.Create(rndGen.NextDouble() * 1000, rndGen.NextDouble() * 1000); Double sideLength = rndGen.NextDouble() * 50; // Make a square coords.Add(upperLeft); coords.Add(coordinateFactory.Create(upperLeft[Ordinates.X] + sideLength, upperLeft[Ordinates.Y])); coords.Add(coordinateFactory.Create(upperLeft[Ordinates.X] + sideLength, upperLeft[Ordinates.Y] - sideLength)); coords.Add(coordinateFactory.Create(upperLeft[Ordinates.X], upperLeft[Ordinates.Y] - sideLength)); IPolygon polygon = geometryFactory.CreatePolygon(coords); geometry.Add(polygon); } }
/// <summary> /// Constructs a GeometryFactory that generates Geometries having the given /// PrecisionModel, spatial-reference ID, and CoordinateSequence implementation. /// </summary> /// <param name="precisionModel"></param> /// <param name="srid"></param> /// <param name="coordinateSequenceFactory"></param> public GeometryFactory(PrecisionModel precisionModel, int srid, ICoordinateSequenceFactory coordinateSequenceFactory) { _precisionModel = precisionModel; _coordinateSequenceFactory = coordinateSequenceFactory; _srid = srid; }
/// <summary> /// Creates an instance of this class, using the provided <see cref="ICoordinateSequenceFactory"/>, <see cref="IPrecisionModel"/> and spatial reference Id (<paramref name="srid"/>. /// </summary> /// <param name="coordinateSequenceFactory">The coordinate sequence factory to use.</param> /// <param name="precisionModel">The precision model.</param> /// <param name="srid">The default spatial reference ID</param> public NtsGeometryServices(ICoordinateSequenceFactory coordinateSequenceFactory, IPrecisionModel precisionModel, int srid) { DefaultCoordinateSequenceFactory = coordinateSequenceFactory; DefaultPrecisionModel = precisionModel; DefaultSRID = srid; }
private static void TestToSequenceMethod(ICoordinateSequenceFactory factory) { var rnd = new Random(8894); var buffer = new CoordinateBuffer(NumCoordinates); for (var i = 0; i < NumCoordinates; i++) { buffer.AddCoordinate(rnd.NextDouble(), rnd.NextDouble()); } System.Diagnostics.Trace.WriteLine( string.Format("\nConversion using {0} factory", (factory ?? GeoAPI.GeometryServiceProvider.Instance.DefaultCoordinateSequenceFactory).GetType().Name)); var sw = new System.Diagnostics.Stopwatch(); sw.Start(); var seqCold = buffer.ToSequence(factory); sw.Stop(); System.Diagnostics.Trace.WriteLine( string.Format(" Cold converting sequence of {0} coordinates in {1}ms.", NumCoordinates, sw.ElapsedMilliseconds)); long total = 0; foreach (var rndBuffer in (_randomCoordinateBuffers ?? (_randomCoordinateBuffers = RandomCoordinateBuffers(NumTests)))) { sw.Stop(); sw.Start(); var seqWarm = rndBuffer.ToSequence(factory); sw.Stop(); Assert.AreEqual(rndBuffer.Count, seqWarm.Count); total += sw.ElapsedTicks; } System.Diagnostics.Trace.WriteLine( string.Format(" Warm converting {0} random coordinate buffers in {1}ticks.", NumTests, total)); }
/// <summary> /// Constructs a GeometryFactory that generates Geometries having the given /// PrecisionModel, spatial-reference ID, and CoordinateSequence implementation. /// </summary> /// <param name="precisionModel"></param> /// <param name="SRID"></param> /// <param name="coordinateSequenceFactory"></param> public GeometryFactory(IPrecisionModel precisionModel, int SRID, ICoordinateSequenceFactory coordinateSequenceFactory) { this.precisionModel = precisionModel; this.coordinateSequenceFactory = coordinateSequenceFactory; this.srid = SRID; }
/// <summary> /// Converts the contents of this <see cref="CoordinateBuffer"/> to a coordinate sequence. /// </summary> /// <returns>A coordinate sequence</returns> public ICoordinateSequence ToSequence(ICoordinateSequenceFactory factory = null) { // Set the coordinate sequence factory, if not assigned if (factory == null) { factory = _factory ?? (_factory = GeometryServiceProvider.Instance.DefaultCoordinateSequenceFactory); } // determine ordinates to apply var useOrdinates = _definedOrdinates & factory.Ordinates; // create the sequence var sequence = factory.Create(_coordinates.Count, useOrdinates); var i = 0; foreach (var coordinate in _coordinates) { sequence.SetOrdinate(i, Ordinate.X, coordinate[0]); sequence.SetOrdinate(i, Ordinate.Y, coordinate[1]); if ((useOrdinates & Ordinates.Z) == Ordinates.Z) { sequence.SetOrdinate(i, Ordinate.Z, coordinate[2]); } if ((useOrdinates & Ordinates.M) == Ordinates.M) { sequence.SetOrdinate(i, Ordinate.M, coordinate[3]); } i++; } return(sequence); }
/// <summary> /// Use NetTopologySuite to access SQL Server spatial data. /// </summary> /// <returns> /// The options builder so that further configuration can be chained. /// </returns> public static NpgsqlDbContextOptionsBuilder UseNetTopologySuite( [NotNull] this NpgsqlDbContextOptionsBuilder optionsBuilder, ICoordinateSequenceFactory coordinateSequenceFactory = null, IPrecisionModel precisionModel = null, Ordinates handleOrdinates = Ordinates.None, bool geographyAsDefault = false) { Check.NotNull(optionsBuilder, nameof(optionsBuilder)); // TODO: Global-only setup at the ADO.NET level for now, optionally allow per-connection? NpgsqlConnection.GlobalTypeMapper.UseNetTopologySuite(coordinateSequenceFactory, precisionModel, handleOrdinates, geographyAsDefault); var coreOptionsBuilder = ((IRelationalDbContextOptionsBuilderInfrastructure)optionsBuilder).OptionsBuilder; var extension = coreOptionsBuilder.Options.FindExtension <NpgsqlNetTopologySuiteOptionsExtension>() ?? new NpgsqlNetTopologySuiteOptionsExtension(); if (geographyAsDefault) { extension = extension.WithGeographyDefault(); } ((IDbContextOptionsBuilderInfrastructure)coreOptionsBuilder).AddOrUpdateExtension(extension); return(optionsBuilder); }
private static void DoTestIsRing(ICoordinateSequenceFactory factory, int dimension) { // arrange var ring = CreateCircle(factory, dimension, new Coordinate(), 5); var noRing = CreateCircularString(factory, dimension, new Coordinate(), 5, 0.1, 22); var empty = CreateAlmostRing(factory, dimension, 0); var incomplete1 = CreateAlmostRing(factory, dimension, 1); var incomplete2 = CreateAlmostRing(factory, dimension, 2); var incomplete3 = CreateAlmostRing(factory, dimension, 3); var incomplete4a = CreateAlmostRing(factory, dimension, 4); var incomplete4b = CoordinateSequences.EnsureValidRing(factory, incomplete4a); // act bool isRingRing = CoordinateSequences.IsRing(ring); bool isRingNoRing = CoordinateSequences.IsRing(noRing); bool isRingEmpty = CoordinateSequences.IsRing(empty); bool isRingIncomplete1 = CoordinateSequences.IsRing(incomplete1); bool isRingIncomplete2 = CoordinateSequences.IsRing(incomplete2); bool isRingIncomplete3 = CoordinateSequences.IsRing(incomplete3); bool isRingIncomplete4a = CoordinateSequences.IsRing(incomplete4a); bool isRingIncomplete4b = CoordinateSequences.IsRing(incomplete4b); // assert Assert.IsTrue(isRingRing); Assert.IsTrue(!isRingNoRing); Assert.IsTrue(isRingEmpty); Assert.IsTrue(!isRingIncomplete1); Assert.IsTrue(!isRingIncomplete2); Assert.IsTrue(!isRingIncomplete3); Assert.IsTrue(!isRingIncomplete4a); Assert.IsTrue(isRingIncomplete4b); }
/// <summary> /// Ensures that a CoordinateSequence forms a valid ring, /// returning a new closed sequence of the correct length if required. /// If the input sequence is already a valid ring, it is returned /// without modification. /// If the input sequence is too short or is not closed, /// it is extended with one or more copies of the start point. /// </summary> /// <param name="fact">The CoordinateSequenceFactory to use to create the new sequence</param> /// <param name="seq">The sequence to test</param> /// <returns>The original sequence, if it was a valid ring, or a new sequence which is valid.</returns> public static ICoordinateSequence EnsureValidRing(ICoordinateSequenceFactory fact, ICoordinateSequence seq) { var n = seq.Count; // empty sequence is valid if (n == 0) { return(seq); } // too short - make a new one if (n <= 3) { return(CreateClosedRing(fact, seq, 4)); } var isClosed = Math.Abs(seq.GetOrdinate(0, Ordinate.X) - seq.GetOrdinate(n - 1, Ordinate.X)) < double.Epsilon && Math.Abs(seq.GetOrdinate(0, Ordinate.Y) - seq.GetOrdinate(n - 1, Ordinate.Y)) < double.Epsilon; if (isClosed) { return(seq); } // make a new closed ring return(CreateClosedRing(fact, seq, n + 1)); }
private static ICoordinateSequence CreateTestSequence(ICoordinateSequenceFactory csFactory, int size, int dim) { ICoordinateSequence cs = csFactory.Create(size, dim); // initialize with a data signature where coords look like [1, 10, 100, ...] for (int i = 0; i < size; i++) for (int d = 0; d < dim; d++) cs.SetOrdinate(i, (Ordinate) d, i*Math.Pow(10, d)); return cs; }
private static ICoordinateSequence CreateClosedRing(ICoordinateSequenceFactory fact, ICoordinateSequence seq, int size) { var newseq = fact.Create(size, seq.Dimension); int n = seq.Count; Copy(seq, 0, newseq, 0, n); // fill remaining coordinates with start point for (int i = n; i < size; i++) Copy(seq, 0, newseq, i, 1); return newseq; }
public WKBReader(IGeometryServices services) { services = services ?? GeometryServiceProvider.Instance; _geometryServices = services; _precisionModel = services.DefaultPrecisionModel; _sequenceFactory = services.DefaultCoordinateSequenceFactory; HandleSRID = true; HandleOrdinates = AllowedOrdinates; }
public WKBReader(IGeometryServices services) { services = services ?? GeometryServiceProvider.Instance; _geometryServices = services; _precisionModel = services.DefaultPrecisionModel; _sequenceFactory = services.DefaultCoordinateSequenceFactory; HandleSRID = true; HandleOrdinates = AllowedOrdinates; }
public WKBReader(IGeometryFactory factory) { _geometryServices = GeometryServiceProvider.Instance; _factory = factory; _sequenceFactory = factory.CoordinateSequenceFactory; _precisionModel = factory.PrecisionModel; HandleSRID = true; HandleOrdinates = AllowedOrdinates; }
public WKBReader(IGeometryFactory factory) { _geometryServices = GeometryServiceProvider.Instance; _factory = factory; _sequenceFactory = factory.CoordinateSequenceFactory; _precisionModel = factory.PrecisionModel; HandleSRID = true; HandleOrdinates = AllowedOrdinates; }
private static ICoordinateSequence CreateSequenceFromOrdinates(ICoordinateSequenceFactory csFactory, int dim) { var sequence = csFactory.Create(ordinateValues.Length, dim); for (int i = 0; i < ordinateValues.Length; i++) { sequence.SetOrdinate(i, Ordinate.X, ordinateValues[i][0]); sequence.SetOrdinate(i, Ordinate.Y, ordinateValues[i][1]); } return(FillNonPlanarDimensions(sequence)); }
public GeometryFactory(ICoordinateFactory coordFactory, ICoordinateSequenceFactory sequenceFactory, Int32? srid, ICoordinateSystem spatialReference) { _coordFactory = coordFactory; _sequenceFactory = sequenceFactory; _srid = srid; _spatialReference = spatialReference; _spatialOps = new BoundingBoxSpatialOperations(this); _wktEncoder = new WktWriter(); _wktDecoder = new WktReader(this, null); _wkbEncoder = new WkbWriter(); _wkbDecoder = new WkbReader(this); }
public GeometryFactory(ICoordinateFactory coordFactory, ICoordinateSequenceFactory sequenceFactory, Int32?srid, ICoordinateSystem spatialReference) { _coordFactory = coordFactory; _sequenceFactory = sequenceFactory; _srid = srid; _spatialReference = spatialReference; _spatialOps = new BoundingBoxSpatialOperations(this); _wktEncoder = new WktWriter(); _wktDecoder = new WktReader(this, null); _wkbEncoder = new WkbWriter(); _wkbDecoder = new WkbReader(this); }
/// <summary> /// Converts the contents of this <see cref="CoordinateBuffer"/> to a coordinate sequence. /// </summary> /// <returns>A coordinate sequence</returns> public ICoordinateSequence[] ToSequences(ICoordinateSequenceFactory factory = null) { // Set the coordinate sequence factory, if not assigned if (factory == null) { factory = _factory ?? (_factory = GeometryServiceProvider.Instance.DefaultCoordinateSequenceFactory); } // Copy the markers, append if neccessary var markers = new List <int>(_markers); if (markers.Count == 0 || markers[markers.Count - 1] < _coordinates.Count) { markers.Add(_coordinates.Count); } // determine ordinates to apply var useOrdinates = _definedOrdinates & factory.Ordinates; var res = new ICoordinateSequence[markers.Count]; var offset = 0; //Iterate over all sections for (var s = 0; s < markers.Count; s++) { // compute the length of the current sequence var length = markers[s] - offset; // create a sequence of the apropriate size var sequence = res[s] = factory.Create(length, useOrdinates); var i = 0; // fill the sequence foreach (var coordinate in _coordinates.GetRange(offset, length)) { sequence.SetOrdinate(i, Ordinate.X, coordinate[0]); sequence.SetOrdinate(i, Ordinate.Y, coordinate[1]); if ((useOrdinates & Ordinates.Z) == Ordinates.Z) { sequence.SetOrdinate(i, Ordinate.Z, coordinate[2]); } if ((useOrdinates & Ordinates.M) == Ordinates.M) { sequence.SetOrdinate(i, Ordinate.M, coordinate[3]); } i++; } //Move the offset offset = offset + length; } return(res); }
private static void DoTestIndexOf(ICoordinateSequenceFactory factory, int dimension) { // arrange var sequence = CreateSequenceFromOrdinates(factory, dimension); // act & assert var coordinates = sequence.ToCoordinateArray(); for (int i = 0; i < sequence.Count; i++) { Assert.AreEqual(i, CoordinateSequences.IndexOf(coordinates[i], sequence)); } }
private static ICoordinateSequence CreateRandomTestSequence(ICoordinateSequenceFactory csFactory, int size, int dim, Random rnd, Envelope range, PrecisionModel pm) { var cs = csFactory.Create(size, dim); for (int i = 0; i < size; i++) { cs.SetOrdinate(i, Ordinate.X, pm.MakePrecise(range.Width * rnd.NextDouble() + range.MinX)); cs.SetOrdinate(i, Ordinate.Y, pm.MakePrecise(range.Height * rnd.NextDouble() + range.MinY)); } return(FillNonPlanarDimensions(cs)); }
private static ICoordinateSequence CreateClosedRing(ICoordinateSequenceFactory fact, ICoordinateSequence seq, int size) { var newseq = fact.Create(size, seq.Dimension); int n = seq.Count; Copy(seq, 0, newseq, 0, n); // fill remaining coordinates with start point for (int i = n; i < size; i++) { Copy(seq, 0, newseq, i, 1); } return(newseq); }
private static ICoordinateSequence CreateCircle(ICoordinateSequenceFactory factory, int dimension, Coordinate center, double radius) { // Get a complete circular string var res = CreateCircularString(factory, dimension, center, radius, 0d, 49); // ensure it is closed for (int i = 0; i < dimension; i++) { res.SetOrdinate(48, (Ordinate)i, res.GetOrdinate(0, (Ordinate)i)); } return(res); }
private static ICoordinateSequence CreateTestSequence(ICoordinateSequenceFactory csFactory, int size, int dim) { var cs = csFactory.Create(size, dim); // initialize with a data signature where coords look like [1, 10, 100, ...] for (int i = 0; i < size; i++) { for (int d = 0; d < dim; d++) { cs.SetOrdinate(i, (Ordinate)d, i * Math.Pow(10, d)); } } return(cs); }
/// <summary> /// Ensures that a CoordinateSequence forms a valid ring, /// returning a new closed sequence of the correct length if required. /// If the input sequence is already a valid ring, it is returned /// without modification. /// If the input sequence is too short or is not closed, /// it is extended with one or more copies of the start point. /// </summary> /// <param name="fact">The CoordinateSequenceFactory to use to create the new sequence</param> /// <param name="seq">The sequence to test</param> /// <returns>The original sequence, if it was a valid ring, or a new sequence which is valid.</returns> public static ICoordinateSequence EnsureValidRing(ICoordinateSequenceFactory fact, ICoordinateSequence seq) { var n = seq.Count; // empty sequence is valid if (n == 0) return seq; // too short - make a new one if (n <= 3) return CreateClosedRing(fact, seq, 4); var isClosed = Math.Abs(seq.GetOrdinate(0, Ordinate.X) - seq.GetOrdinate(n - 1, Ordinate.X)) < double.Epsilon && Math.Abs(seq.GetOrdinate(0, Ordinate.Y) - seq.GetOrdinate(n - 1, Ordinate.Y)) < double.Epsilon; if (isClosed) return seq; // make a new closed ring return CreateClosedRing(fact, seq, n + 1); }
private static void DoTestReverse(ICoordinateSequenceFactory factory, int dimension) { // arrange var sequence = CreateSequenceFromOrdinates(factory, dimension); var reversed = sequence.Copy(); // act CoordinateSequences.Reverse(reversed); // assert for (int i = 0; i < sequence.Count; i++) { CheckCoordinateAt(sequence, i, reversed, sequence.Count - i - 1, dimension); } }
public static ICoordinateSequence Extend(ICoordinateSequenceFactory fact, ICoordinateSequence seq, int size) { var newseq = fact.Create(size, seq.Ordinates); int n = seq.Count; Copy(seq, 0, newseq, 0, n); // fill remaining coordinates with end point, if it exists if (n > 0) { for (int i = n; i < size; i++) { Copy(seq, n - 1, newseq, i, 1); } } return(newseq); }
/// <summary> /// Sets up NetTopologySuite mappings for the PostGIS types. /// </summary> /// <param name="mapper">The type mapper to set up (global or connection-specific).</param> /// <param name="coordinateSequenceFactory">The factory which knows how to build a particular implementation of ICoordinateSequence from an array of Coordinates.</param> /// <param name="precisionModel">Specifies the grid of allowable points.</param> /// <param name="handleOrdinates">Specifies the ordinates which will be handled. Not specified ordinates will be ignored. /// If <see cref="F:GeoAPI.Geometries.Ordiantes.None" /> is specified, an actual value will be taken from /// the <see cref="P:GeoAPI.Geometries.ICoordinateSequenceFactory.Ordinates"/> property of <paramref name="coordinateSequenceFactory"/>.</param> /// <param name="geographyAsDefault">Specifies that the geography type is used for mapping by default.</param> public static INpgsqlTypeMapper UseNetTopologySuite( this INpgsqlTypeMapper mapper, ICoordinateSequenceFactory coordinateSequenceFactory = null, IPrecisionModel precisionModel = null, Ordinates handleOrdinates = Ordinates.None, bool geographyAsDefault = false) { if (coordinateSequenceFactory == null) { coordinateSequenceFactory = GeometryServiceProvider.Instance.DefaultCoordinateSequenceFactory; } if (precisionModel == null) { precisionModel = GeometryServiceProvider.Instance.DefaultPrecisionModel; } if (handleOrdinates == Ordinates.None) { handleOrdinates = coordinateSequenceFactory.Ordinates; } NetTopologySuiteBootstrapper.Bootstrap(); var typeHandlerFactory = new NetTopologySuiteHandlerFactory( new PostGisReader(coordinateSequenceFactory, precisionModel, handleOrdinates), new PostGisWriter() { HandleOrdinates = handleOrdinates }); return(mapper .AddMapping(new NpgsqlTypeMappingBuilder { PgTypeName = "geometry", NpgsqlDbType = NpgsqlDbType.Geometry, ClrTypes = geographyAsDefault ? Type.EmptyTypes : ClrTypes, InferredDbType = DbType.Object, TypeHandlerFactory = typeHandlerFactory }.Build()) .AddMapping(new NpgsqlTypeMappingBuilder { PgTypeName = "geography", NpgsqlDbType = NpgsqlDbType.Geography, ClrTypes = geographyAsDefault ? ClrTypes : Type.EmptyTypes, InferredDbType = DbType.Object, TypeHandlerFactory = typeHandlerFactory }.Build())); }
/// <summary> /// Function to return a coordinate sequence that is ensured to be closed. /// </summary> /// <param name="sequence">The base sequence</param> /// <param name="factory">The factory to use in case we need to create a new sequence</param> /// <returns>A closed coordinate sequence</returns> private static ICoordinateSequence EnsureClosedSequence(ICoordinateSequence sequence, ICoordinateSequenceFactory factory) { //This sequence won't serve a valid linear ring if (sequence.Count < 3) { return(null); } //The sequence is closed var start = sequence.GetCoordinate(0); var lastIndex = sequence.Count - 1; var end = sequence.GetCoordinate(lastIndex); if (start.Equals2D(end)) { return(sequence); } // The sequence is not closed // 1. Test for a little offset, in that case simply correct x- and y- ordinate values const double eps = 1E-7; if (start.Distance(end) < eps) { sequence.SetOrdinate(lastIndex, Ordinate.X, start.X); sequence.SetOrdinate(lastIndex, Ordinate.Y, start.Y); return(sequence); } // 2. Close the sequence by adding a new point, this is heavier var newSequence = factory.Create(sequence.Count + 1, sequence.Ordinates); var ordinates = OrdinatesUtility.ToOrdinateArray(sequence.Ordinates); for (var i = 0; i < sequence.Count; i++) { foreach (var ordinate in ordinates) { newSequence.SetOrdinate(i, ordinate, sequence.GetOrdinate(i, ordinate)); } } foreach (var ordinate in ordinates) { newSequence.SetOrdinate(sequence.Count, ordinate, sequence.GetOrdinate(0, ordinate)); } return(newSequence); }
public GeometryFactory(ICoordinateFactory coordFactory, ICoordinateSequenceFactory sequenceFactory) : this(coordFactory, sequenceFactory, null, null) { }
private static ICoordinateSequence SetDimension(ICoordinateSequenceFactory fact, ICoordinateSequence seq, int dimension) { if (seq.Dimension == dimension) return seq; var res = fact.Create(seq.Count, dimension); dimension = Math.Min(dimension, seq.Dimension); for (var i = 0; i < seq.Count; i++) { for (var j = 0; j < dimension; j++) res.SetOrdinate(i, (Ordinate)j, seq.GetOrdinate(i, (Ordinate)j)); } return res; }
public GeometryFactory(ICoordinateFactory coordFactory, ICoordinateSequenceFactory sequenceFactory, Int32? srid) : this(coordFactory, sequenceFactory, srid, null) { }
/// <summary> /// Constructs a GeometryFactory that generates Geometries having the given /// CoordinateSequence implementation, a double-precision floating PrecisionModel and a /// spatial-reference ID of 0. /// </summary> /// <param name="coordinateSequenceFactory"></param> public GeometryFactory(ICoordinateSequenceFactory coordinateSequenceFactory) : this(new PrecisionModel(), 0, coordinateSequenceFactory) { }
private static ICoordinateSequence ReadCompressedXY(byte[] buffer, ref int offset, int number, GaiaImport import, ICoordinateSequenceFactory factory, IPrecisionModel precisionModel) { var startOrdinateValues = import.GetDoubles(buffer, ref offset, 2); var ret = factory.Create(number, import.HandleOrdinates); var x = startOrdinateValues[0]; var y = startOrdinateValues[1]; ret.SetOrdinate(0, Ordinate.X, precisionModel.MakePrecise(x)); ret.SetOrdinate(0, Ordinate.Y, precisionModel.MakePrecise(y)); if (number == 1) return ret; var ordinateValues = import.GetSingles(buffer, ref offset, (number - 2) * 2); var j = 0; int i; for (i = 1; i < number - 1; i++) { x = x + ordinateValues[j++]; y = y + ordinateValues[j++]; ret.SetOrdinate(i, Ordinate.X, precisionModel.MakePrecise(x)); ret.SetOrdinate(i, Ordinate.Y, precisionModel.MakePrecise(y)); } startOrdinateValues = import.GetDoubles(buffer, ref offset, 2); ret.SetOrdinate(i, Ordinate.X, precisionModel.MakePrecise(startOrdinateValues[0])); ret.SetOrdinate(i, Ordinate.Y, precisionModel.MakePrecise(startOrdinateValues[1])); return ret; }
protected static ICoordinateSequence AddCoordinateToSequence(ICoordinateSequence sequence, ICoordinateSequenceFactory factory, double x, double y, double? z, double? m) { // Create a new sequence var newSequence = factory.Create(sequence.Count + 1, sequence.Ordinates); // Copy old values var ordinates = OrdinatesUtility.ToOrdinateArray(sequence.Ordinates); for (var i = 0; i < sequence.Count; i++) { foreach (var ordinate in ordinates) newSequence.SetOrdinate(i, ordinate, sequence.GetOrdinate(i, ordinate)); } // new coordinate newSequence.SetOrdinate(sequence.Count, Ordinate.X, x); newSequence.SetOrdinate(sequence.Count, Ordinate.Y, y); if (z.HasValue) newSequence.SetOrdinate(sequence.Count, Ordinate.Z, z.Value); if (m.HasValue) newSequence.SetOrdinate(sequence.Count, Ordinate.M, m.Value); return newSequence; }
/// <summary> /// Constructs a GeometryFactory pertaining to a specific _coordinateSequenceFactory /// using any valid IGeometryFactory and ICoordinateSequenceFactory interface /// </summary> /// <param name="gf">An IGeometryFactory Interface</param> /// <param name="coordinateSequenceFactory">An ICoordianteSequenceFactory interface</param> public GeometryFactory(IGeometryFactory gf, ICoordinateSequenceFactory coordinateSequenceFactory) { _precisionModel = new PrecisionModel(gf.PrecisionModel); _coordinateSequenceFactory = coordinateSequenceFactory; _srid = gf.Srid; }
/// <summary> /// Constructs a GeometryFactory object from any valid IGeometryFactory interface /// </summary> /// <param name="gf"></param> public GeometryFactory(IGeometryFactory gf) { _precisionModel = new PrecisionModel(gf.PrecisionModel); _coordinateSequenceFactory = GetDefaultCoordinateSequenceFactory(); _srid = gf.Srid; }
internal InternalFactoryService() { _coordinateFactory = new CoordinateFactory(); _coordinateSequenceFactory = new CoordinateSequenceFactory((CoordinateFactory)_coordinateFactory); _geometryFactory = new GeometryFactory<Coordinate>( (CoordinateSequenceFactory)_coordinateSequenceFactory); _coordinateSystemFactory = new CoordinateSystemFactory<Coordinate>((CoordinateFactory)_coordinateFactory, (GeometryFactory<Coordinate>) _geometryFactory); _coordinateTransformationFactory = new CoordinateTransformationFactory<Coordinate>( (CoordinateFactory)_coordinateFactory, (GeometryFactory<Coordinate>)_geometryFactory, new LinearFactory<DoubleComponent>()); }
private static ICoordinateSequence TransformSequence(ICoordinateSequence sequence, ProjectionInfo from, ProjectionInfo to, ICoordinateSequenceFactory factory) { var res = factory.Create(sequence.Count, sequence.Ordinates); double[] z; double[] ordinates; if (sequence is NetTopologySuite.Geometries.Implementation.DotSpatialAffineCoordinateSequence) { var dss = (NetTopologySuite.Geometries.Implementation.DotSpatialAffineCoordinateSequence) sequence; z = (double[])dss.Z.Clone(); ordinates = (double[])dss.XY.Clone(); } else { ordinates = ToDoubleArray(sequence, out z); } Reproject.ReprojectPoints(ordinates, z, from, to, 0, sequence.Count); if (res is NetTopologySuite.Geometries.Implementation.DotSpatialAffineCoordinateSequence) { var dss = (NetTopologySuite.Geometries.Implementation.DotSpatialAffineCoordinateSequence) res; Array.Copy(ordinates, dss.XY, ordinates.Length); if (z != null) Array.Copy(z, dss.Z, z.Length); } else { var j = 0; for (var i = 0; i < sequence.Count; i++) { res.SetOrdinate(i, Ordinate.X, ordinates[j++]); res.SetOrdinate(i, Ordinate.Y, ordinates[j++]); if (z != null) res.SetOrdinate(i, Ordinate.Z, z[i]); } } return res; }
private static ICoordinateSequence ReadCompressedXYZM(byte[] buffer, ref int offset, int number, GaiaImport import, ICoordinateSequenceFactory factory, IPrecisionModel precisionModel) { var startOrdinateValues = import.GetDoubles(buffer, ref offset, 4); var ret = factory.Create(number, Ordinates.XYM); var handleZ = (ret.Ordinates & Ordinates.Z) == Ordinates.Z; var handleM = (ret.Ordinates & Ordinates.M) == Ordinates.M; var x = startOrdinateValues[0]; ret.SetOrdinate(0, Ordinate.X, precisionModel.MakePrecise(x)); var y = startOrdinateValues[1]; ret.SetOrdinate(0, Ordinate.Y, precisionModel.MakePrecise(y)); var z = handleZ ? startOrdinateValues[2] : Coordinate.NullOrdinate; ret.SetOrdinate(0, Ordinate.Z, z); var m = handleM ? startOrdinateValues[3] : Coordinate.NullOrdinate; ret.SetOrdinate(0, Ordinate.M, m); if (number == 1) return ret; var ordinateValues = import.GetSingles(buffer, ref offset, (number - 2) * 4); var j = 0; int i; for (i = 1; i < number - 1; i++) { x += ordinateValues[j++]; ret.SetOrdinate(i, Ordinate.X, precisionModel.MakePrecise(x)); y += ordinateValues[j++]; ret.SetOrdinate(i, Ordinate.Y, precisionModel.MakePrecise(y)); if (handleZ) z += ordinateValues[j++]; ret.SetOrdinate(i, Ordinate.Z, z); if (handleM) m += ordinateValues[j++]; ret.SetOrdinate(i, Ordinate.M, m); } startOrdinateValues = import.GetDoubles(buffer, ref offset, 4); ret.SetOrdinate(i, Ordinate.X, precisionModel.MakePrecise(startOrdinateValues[0])); ret.SetOrdinate(i, Ordinate.Y, precisionModel.MakePrecise(startOrdinateValues[1])); z = handleZ ? startOrdinateValues[2] : Coordinate.NullOrdinate; ret.SetOrdinate(i, Ordinate.Z, z); m = handleM ? startOrdinateValues[3] : Coordinate.NullOrdinate; ret.SetOrdinate(i, Ordinate.M, m); return ret; }
/// <summary> /// Creates a <c>WKTReader</c> that creates objects using the given /// <c>GeometryFactory</c>. /// </summary> /// <param name="geometryFactory">The factory used to create <c>Geometry</c>s.</param> public WKTReader(IGeometryFactory geometryFactory) { _coordinateSequencefactory = geometryFactory.CoordinateSequenceFactory; _precisionModel = geometryFactory.PrecisionModel; DefaultSRID = geometryFactory.SRID; }
/// <summary> /// Creates an instance of this class using the default /// values for <see cref="GeometryFactory.SRID"/>, /// <see cref="GeometryFactory.PrecisionModel"/>, /// but the specified <paramref name="factory"/>. /// </summary> public OgcCompliantGeometryFactory(ICoordinateSequenceFactory factory) : base(factory) { }
public OgcCompliantGeometryFactory(IPrecisionModel pm, int srid, ICoordinateSequenceFactory factory) : base(pm, srid, factory) { }
public GaiaGeoReader(ICoordinateSequenceFactory coordinateSequenceFactory, IPrecisionModel precisionModel, Ordinates handleOrdinates) { _coordinateSequenceFactory = coordinateSequenceFactory; _precisionModel = precisionModel; _handleOrdinates = handleOrdinates; }
public static ICoordinateSequence Extend(ICoordinateSequenceFactory fact, ICoordinateSequence seq, int size) { var newseq = fact.Create(size, seq.Ordinates); var n = seq.Count; Copy(seq, 0, newseq, 0, n); // fill remaining coordinates with end point, if it exists if (n > 0) { for (var i = n; i < size; i++) Copy(seq, n - 1, newseq, i, 1); } return newseq; }
public GaiaGeoReader(ICoordinateSequenceFactory coordinateSequenceFactory, IPrecisionModel precisionModel) : this(coordinateSequenceFactory, precisionModel, Ordinates.XYZM) { }
private static void TestToSequenceMethod(ICoordinateSequenceFactory factory) { var rnd = new Random(8894); var buffer = new CoordinateBuffer(NumCoordinates); for (var i = 0; i < NumCoordinates; i++) buffer.AddCoordinate(rnd.NextDouble(), rnd.NextDouble()); System.Diagnostics.Trace.WriteLine( string.Format("\nConversion using {0} factory", (factory ?? GeoAPI.GeometryServiceProvider.Instance.DefaultCoordinateSequenceFactory).GetType().Name)); var sw = new System.Diagnostics.Stopwatch(); sw.Start(); var seqCold = buffer.ToSequence(factory); sw.Stop(); System.Diagnostics.Trace.WriteLine( string.Format(" Cold converting sequence of {0} coordinates in {1}ms.", NumCoordinates, sw.ElapsedMilliseconds)); long total = 0; foreach (var rndBuffer in (_randomCoordinateBuffers ?? (_randomCoordinateBuffers = RandomCoordinateBuffers(NumTests)))) { sw.Stop(); sw.Start(); var seqWarm = rndBuffer.ToSequence(factory); sw.Stop(); Assert.AreEqual(rndBuffer.Count, seqWarm.Count); total += sw.ElapsedTicks; } System.Diagnostics.Trace.WriteLine( string.Format(" Warm converting {0} random coordinate buffers in {1}ticks.", NumTests, total)); }
private static ICoordinateSequence ToGeoAPI(ICoordinateSequenceFactory factory, double[] xy, double[] z, double[] m) { var ordinates = Ordinates.XY; if (z != null) ordinates |= Ordinates.Z; if (m != null) ordinates |= Ordinates.M; var res = factory.Create(xy.Length / 2, ordinates); var j = 0; for (var i = 0; i < res.Count; i++) { res.SetOrdinate(i, Ordinate.X, xy[j++]); res.SetOrdinate(i, Ordinate.Y, xy[j++]); } if (z != null && HasOrdinate(res, Ordinate.Z)) { for (var i = 0; i < res.Count; i++) { res.SetOrdinate(i, Ordinate.Z, z[i]); } } if (m != null && HasOrdinate(res, Ordinate.M)) { for (var i = 0; i < res.Count; i++) { res.SetOrdinate(i, Ordinate.Z, m[i]); } } return res; }
private static ICoordinateSequence ReadXYZM(byte[] buffer, ref int offset, int number, GaiaImport import, ICoordinateSequenceFactory factory, IPrecisionModel precisionModel) { var ordinateValues = import.GetDoubles(buffer, ref offset, number * 4); var ret = factory.Create(number, import.HandleOrdinates); var handleZ = (ret.Ordinates & Ordinates.Z) == Ordinates.Z; var handleM = (ret.Ordinates & Ordinates.M) == Ordinates.M; var j = 0; for (var i = 0; i < number; i++) { ret.SetOrdinate(i, Ordinate.X, precisionModel.MakePrecise(ordinateValues[j++])); ret.SetOrdinate(i, Ordinate.Y, precisionModel.MakePrecise(ordinateValues[j++])); if (handleZ) ret.SetOrdinate(i, Ordinate.Z, precisionModel.MakePrecise(ordinateValues[j])); j++; if (handleM) ret.SetOrdinate(i, Ordinate.M, precisionModel.MakePrecise(ordinateValues[j])); j++; } return ret; }
/// <summary> /// Function to return a coordinate sequence that is ensured to be closed. /// </summary> /// <param name="sequence">The base sequence</param> /// <param name="factory">The factory to use in case we need to create a new sequence</param> /// <returns>A closed coordinate sequence</returns> private static ICoordinateSequence EnsureClosedSequence(ICoordinateSequence sequence, ICoordinateSequenceFactory factory) { //This sequence won't serve a valid linear ring if (sequence.Count < 3) return null; //The sequence is closed var start = sequence.GetCoordinate(0); var lastIndex = sequence.Count - 1; var end = sequence.GetCoordinate(lastIndex); if (start.Equals2D(end)) return sequence; // The sequence is not closed // 1. Test for a little offset, in that case simply correct x- and y- ordinate values const double eps = 1E-7; if (start.Distance(end) < eps) { sequence.SetOrdinate(lastIndex, Ordinate.X, start.X); sequence.SetOrdinate(lastIndex, Ordinate.Y, start.Y); return sequence; } // 2. Close the sequence by adding a new point, this is heavier var newSequence = factory.Create(sequence.Count + 1, sequence.Ordinates); var ordinates = OrdinatesUtility.ToOrdinateArray(sequence.Ordinates); for (var i = 0; i < sequence.Count; i++) { foreach (var ordinate in ordinates) newSequence.SetOrdinate(i, ordinate, sequence.GetOrdinate(i, ordinate)); } foreach (var ordinate in ordinates) newSequence.SetOrdinate(sequence.Count, ordinate, sequence.GetOrdinate(0, ordinate)); return newSequence; }
///** Convience method for STRUCT construction. */ //private STRUCT toSTRUCT( Datum attributes[], String dataType ) // throws SQLException //{ // if( dataType.startsWith("*.")){ // dataType = "DRA."+dataType.substring(2);//TODO here // } // StructDescriptor descriptor = // StructDescriptor.createDescriptor( dataType, connection ); // return new STRUCT( descriptor, connection, attributes ); //} ///** // * Convience method for ARRAY construction. // * <p> // * Compare and contrast with toORDINATE - which treats <code>Double.NaN</code> // * as<code>NULL</code></p> // */ //private ARRAY toARRAY( double doubles[], String dataType ) // throws SQLException //{ // ArrayDescriptor descriptor = // ArrayDescriptor.createDescriptor( dataType, connection ); // return new ARRAY( descriptor, connection, doubles ); //} ///** // * Convience method for ARRAY construction. // */ //private ARRAY toARRAY( int ints[], String dataType ) // throws SQLException //{ // ArrayDescriptor descriptor = // ArrayDescriptor.createDescriptor( dataType, connection ); // return new ARRAY( descriptor, connection, ints ); //} ///** // * Convience method for NUMBER construction. // * <p> // * Double.NaN is represented as <code>NULL</code> to agree // * with JTS use.</p> // */ //private NUMBER toNUMBER( double number ) throws SQLException{ // if( Double.isNaN( number )){ // return null; // } // return new NUMBER( number ); //} /** * reverses the coordinate order * * @param factory * @param sequence * * @return CoordinateSequence reversed sequence */ private ICoordinateSequence reverse(ICoordinateSequenceFactory factory, ICoordinateSequence sequence) { var list = new CoordinateList(sequence.ToCoordinateArray()); list.Reverse(); return factory.Create(list.ToCoordinateArray()); }