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