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;
}
private static ICoordinateSequence ReadXY(byte[] buffer, ref int offset, int number, GaiaImport import, ICoordinateSequenceFactory factory, IPrecisionModel precisionModel)
{
var ordinateValues = import.GetDoubles(buffer, ref offset, number * 2);
var ret = factory.Create(number, Ordinates.XY);
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++]));
}
return(ret);
}
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 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);
}
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);
}
private static ICoordinateSequence ReadCompressedXYM(byte[] buffer, ref int offset, int number, GaiaImport import, ICoordinateSequenceFactory factory, IPrecisionModel precisionModel)
{
var startOrdinateValues = import.GetDoubles(buffer, ref offset, 3);
var ret = factory.Create(number, Ordinates.XYM);
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 m = handleM ? startOrdinateValues[2] : Coordinate.NullOrdinate;
ret.SetOrdinate(0, Ordinate.M, m);
if (number == 1)
{
return(ret);
}
var ordinateValues = import.GetSingles(buffer, ref offset, (number - 2) * 3);
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 (handleM)
{
m += ordinateValues[j++];
}
ret.SetOrdinate(i, Ordinate.M, m);
}
startOrdinateValues = import.GetDoubles(buffer, ref offset, 3);
ret.SetOrdinate(i, Ordinate.X, precisionModel.MakePrecise(startOrdinateValues[0]));
ret.SetOrdinate(i, Ordinate.Y, precisionModel.MakePrecise(startOrdinateValues[1]));
m = handleM ? startOrdinateValues[2] : Coordinate.NullOrdinate;
ret.SetOrdinate(i, Ordinate.M, m);
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);
}
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 ReadXYM(byte[] buffer, ref int offset, int number, GaiaImport import, ICoordinateSequenceFactory factory, IPrecisionModel precisionModel)
{
var ordinateValues = import.GetDoubles(buffer, ref offset, number * 3);
var ret = factory.Create(number, import.HandleOrdinates);
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 (handleM)
{
ret.SetOrdinate(i, Ordinate.M, precisionModel.MakePrecise(ordinateValues[j]));
}
j++;
}
return(ret);
}
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 (int i = 0; i < seq.Count; i++)
{
for (int j = 0; j < dimension; j++)
{
res.SetOrdinate(i, (Ordinate)j, seq.GetOrdinate(i, (Ordinate)j));
}
}
return(res);
}
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 ICoordinateSequence ToSequence(SpatialLite.Core.API.ICoordinateList list, Ordinates kind)
{
var res = _factory.Create(list.Count, kind);
kind = res.Ordinates;
for (var i = 0; i < list.Count; i++)
{
var c = list[i];
res.SetOrdinate(i, Ordinate.X, c.X);
res.SetOrdinate(i, Ordinate.Y, c.Y);
if ((kind & Ordinates.Z) == Ordinates.Z)
{
res.SetOrdinate(i, Ordinate.Z, c.Z);
}
if ((kind & Ordinates.M) == Ordinates.M)
{
res.SetOrdinate(i, Ordinate.M, c.M);
}
}
return(res);
}
private static ICoordinateSequence CreateAlmostRing(ICoordinateSequenceFactory factory, int dimension, int num)
{
if (num > 4)
{
num = 4;
}
var sequence = factory.Create(num, dimension);
if (num == 0)
{
return(FillNonPlanarDimensions(sequence));
}
sequence.SetOrdinate(0, Ordinate.X, 10);
sequence.SetOrdinate(0, Ordinate.Y, 10);
if (num == 1)
{
return(FillNonPlanarDimensions(sequence));
}
sequence.SetOrdinate(1, Ordinate.X, 20);
sequence.SetOrdinate(1, Ordinate.Y, 10);
if (num == 2)
{
return(FillNonPlanarDimensions(sequence));
}
sequence.SetOrdinate(2, Ordinate.X, 20);
sequence.SetOrdinate(2, Ordinate.Y, 20);
if (num == 3)
{
return(FillNonPlanarDimensions(sequence));
}
sequence.SetOrdinate(3, Ordinate.X, 10.00001);
sequence.SetOrdinate(3, Ordinate.Y, 9.99999);
return(FillNonPlanarDimensions(sequence));
}
/// <summary>
/// Reads a <see cref="ICoordinateSequence"/> from the stream
/// </summary>
/// <param name="reader">The binary reader</param>
/// <param name="factory">The geometry factory to use for geometry creation.</param>
/// <param name="precisionModel">The precision model used to make x- and y-ordinates precise.</param>
/// <param name="numPoints">The number of points in the coordinate sequence.</param>
/// <param name="ordinates">The ordinates to read. <see cref="Ordinates.XY"/> are always read.</param>
/// <returns>The coordinate sequence</returns>
protected ICoordinateSequence ReadCoordinateSequence(BinaryReader reader, ICoordinateSequenceFactory factory, IPrecisionModel precisionModel, int numPoints, Ordinates ordinates)
{
var sequence = factory.Create(numPoints, HandleOrdinates);
var ordinateZ = Coordinate.NullOrdinate;
var ordinateM = Coordinate.NullOrdinate;
var getZ = (ordinates & Ordinates.Z) == Ordinates.Z;
var getM = (ordinates & Ordinates.M) == Ordinates.M;
var handleZ = (HandleOrdinates & Ordinates.Z) == Ordinates.Z;
var handleM = (HandleOrdinates & Ordinates.M) == Ordinates.M;
for (var i = 0; i < numPoints; i++)
{
sequence.SetOrdinate(i, Ordinate.X, precisionModel.MakePrecise(reader.ReadDouble()));
sequence.SetOrdinate(i, Ordinate.Y, precisionModel.MakePrecise(reader.ReadDouble()));
if (getZ)
{
ordinateZ = reader.ReadDouble();
}
if (handleZ)
{
sequence.SetOrdinate(i, Ordinate.Z, ordinateZ);
}
if (getM)
{
ordinateM = reader.ReadDouble();
}
if (handleM)
{
sequence.SetOrdinate(i, Ordinate.M, ordinateM);
}
}
return(sequence);
}
///** 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 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;
}
/// <summary>
/// Function to read a coordinate sequence.
/// </summary>
/// <param name="reader">The reader</param>
/// <param name="size">The number of ordinates</param>
/// <param name="cs">The coordinate system</param>
/// <returns>The read coordinate sequence.</returns>
protected ICoordinateSequence ReadCoordinateSequence(BinaryReader reader, int size, CoordinateSystem cs)
{
var sequence = _sequenceFactory.Create(size, ToOrdinates(cs));
for (int i = 0; i < size; i++)
{
double x = reader.ReadDouble();
double y = reader.ReadDouble();
if (_precisionModel != null)
{
x = _precisionModel.MakePrecise(x);
}
if (_precisionModel != null)
{
y = _precisionModel.MakePrecise(y);
}
sequence.SetOrdinate(i, Ordinate.X, x);
sequence.SetOrdinate(i, Ordinate.Y, y);
switch (cs)
{
case CoordinateSystem.XY:
continue;
case CoordinateSystem.XYZ:
double z = reader.ReadDouble();
if (HandleOrdinate(Ordinate.Z))
{
sequence.SetOrdinate(i, Ordinate.Z, z);
}
break;
case CoordinateSystem.XYM:
double m = reader.ReadDouble();
if (HandleOrdinate(Ordinate.M))
{
sequence.SetOrdinate(i, Ordinate.M, m);
}
break;
case CoordinateSystem.XYZM:
z = reader.ReadDouble();
if (HandleOrdinate(Ordinate.Z))
{
sequence.SetOrdinate(i, Ordinate.Z, z);
}
m = reader.ReadDouble();
if (HandleOrdinate(Ordinate.M))
{
sequence.SetOrdinate(i, Ordinate.M, m);
}
break;
default:
throw new ArgumentException(string.Format("Coordinate system not supported: {0}", cs));
}
}
return(sequence);
}
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;
}
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;
}
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;
}
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;
}
/// <summary>
/// Creates a deep copy of the input <see cref="IGeometry"/>.
/// The <see cref="ICoordinateSequenceFactory"/> defined for this factory
/// is used to copy the <see cref="ICoordinateSequence"/>s
/// of the input geometry.
/// <para/>
/// This is a convenient way to change the <tt>CoordinateSequence</tt>
/// used to represent a geometry, or to change the
/// factory used for a geometry.
/// <para/>
/// <see cref="IGeometry.Clone()"/> can also be used to make a deep copy,
/// but it does not allow changing the CoordinateSequence type.
/// </summary>
/// <param name="g">The geometry</param>
/// <returns>A deep copy of the input geometry, using the CoordinateSequence type of this factory</returns>
/// <seealso cref="IGeometry.Clone"/>
public IGeometry CreateGeometry(IGeometry g)
{
// NOTE: don't move lambda to a separate variable!
// make a variable and you've broke WinPhone build.
var operation = new GeometryEditor.CoordinateSequenceOperation((x, y) => _coordinateSequenceFactory.Create(x));
GeometryEditor editor = new GeometryEditor(this);
return(editor.Edit(g, operation));
}
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;
}
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 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;
}
/// <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;
}
private static ICoordinateSequence ReadXY(byte[] buffer, ref int offset, int number, GaiaImport import, ICoordinateSequenceFactory factory, IPrecisionModel precisionModel)
{
var ordinateValues = import.GetDoubles(buffer, ref offset, number * 2);
var ret = factory.Create(number, Ordinates.XY);
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++]));
}
return ret;
}