/// <summary>
/// 构造函数
/// </summary>
/// <param name="name"></param>
/// <param name="Orientation"></param>
/// <param name="ordinate"></param>
/// <param name="Unit"></param>
public Axis(string name, Orientation Orientation, Ordinate ordinate = Ordinate.Other, Unit Unit = null)
{
this.Name = name;
this.Orientation = Orientation;
this.Ordinate = ordinate;
this.Unit = Unit;
}
///<summary>
/// Copies a coordinate of a <see cref="ICoordinateSequence"/> to another <see cref="ICoordinateSequence"/>.
/// The sequences must have the same dimension.
///</summary>
/// <param name="src">The sequence to copy coordinate from</param>
/// <param name="srcPos">The index of the coordinate to copy</param>
/// <param name="dest">The sequence to which the coordinate should be copied to</param>
/// <param name="destPos">The index of the coordinate in <see paramref="dest"/></param>
public static void CopyCoord(ICoordinateSequence src, int srcPos, ICoordinateSequence dest, int destPos)
{
for (Ordinate dim = 0; (int)dim < src.Dimension; dim++)
{
dest.SetOrdinate(destPos, dim, src.GetOrdinate(srcPos, dim));
}
}
/// <summary>
/// Gets an array of <see cref="double"/> ordinate values
/// </summary>
/// <param name="ordinate">The ordinate index</param>
/// <returns>An array of ordinate values</returns>
public override double[] GetOrdinates(Ordinate ordinate)
{
if (IsEmpty)
{
return(new double[0]);
}
var ordinateFlag = (Ordinates)(1 << (int)ordinate);
if ((_shell.CoordinateSequence.Ordinates & ordinateFlag) != ordinateFlag)
{
return(CreateArray(NumPoints, Coordinate.NullOrdinate));
}
double[] result = new double[NumPoints];
double[] ordinates = _shell.GetOrdinates(ordinate);
Array.Copy(ordinates, 0, result, 0, ordinates.Length);
int offset = ordinates.Length;
foreach (var linearRing in _holes)
{
ordinates = linearRing.GetOrdinates(ordinate);
Array.Copy(ordinates, 0, result, offset, ordinates.Length);
offset += ordinates.Length;
}
return(result);
}
/// <summary>
/// Sets the value for a given ordinate of a coordinate in this sequence.
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate value to set.</param>
/// <param name="value">The new ordinate value.</param>
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
if (TryGetOrdinateIndex(ordinate, out int ordinateIndex))
{
SetOrdinate(index, ordinateIndex, value);
}
}
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
switch (ordinate)
{
case Ordinate.X:
_xy[index * 2] = value;
break;
case Ordinate.Y:
_xy[index * 2 + 1] = value;
break;
case Ordinate.Z:
if (_z != null)
{
_z[index] = value;
}
break;
case Ordinate.M:
if (_m != null)
{
_m[index] = value;
}
break;
default:
throw new NotSupportedException();
}
_coordinateArrayRef = null;
}
/// <summary>
/// Tests whether two <see cref="ICoordinateSequence"/>s are equal.
/// To be equal, the sequences must be the same length.
/// They do not need to be of the same dimension,
/// but the ordinate values for the smallest dimension of the two
/// must be equal.
/// Two <c>NaN</c> ordinates values are considered to be equal.
/// </summary>
/// <param name="cs1">a CoordinateSequence</param>
/// <param name="cs2">a CoordinateSequence</param>
/// <returns><c>true</c> if the sequences are equal in the common dimensions</returns>
public static bool IsEqual(ICoordinateSequence cs1, ICoordinateSequence cs2)
{
int cs1Size = cs1.Count;
int cs2Size = cs2.Count;
if (cs1Size != cs2Size)
{
return(false);
}
int dim = Math.Min(cs1.Dimension, cs2.Dimension);
for (int i = 0; i < cs1Size; i++)
{
for (int d = 0; d < dim; d++)
{
Ordinate ordinate = (Ordinate)d;
double v1 = cs1.GetOrdinate(i, ordinate);
double v2 = cs2.GetOrdinate(i, ordinate);
if (cs1.GetOrdinate(i, ordinate) == cs2.GetOrdinate(i, ordinate))
{
continue;
}
// special check for NaNs
if (Double.IsNaN(v1) && Double.IsNaN(v2))
{
continue;
}
return(false);
}
}
return(true);
}
public double GetOrdinate(int index, Ordinate ordinate)
{
if (index >= _points.Length)
{
return(double.NaN);
}
switch (ordinate)
{
case Ordinate.X:
return(_points[index].X);
case Ordinate.Y:
return(_points[index].Y);
case Ordinate.Z:
return(_points[index].Z);
case Ordinate.M:
return(_points[index].M);
default:
return(double.NaN);
}
}
public double GetOrdinate(int index, Ordinate ordinateIndex)
{
// Z ord is always 0
if (ordinateIndex > Ordinate.Y)
{
return(0);
}
return(_seq.GetOrdinate(index, _indexMap[(int)ordinateIndex]));
}
private static double GetOrdinate(ICoordinateSequence sequence, Ordinate ordinate, int index)
{
var val = sequence.GetOrdinate(index, ordinate);
if (ordinate == Ordinate.M && double.IsNaN(val))
{
val = ShapeFileConstants.NoDataValue;
}
return(val);
}
protected void WriteInterval(ICoordinateSequence sequence, Ordinate ordinate, BinaryWriter writer)
{
var val = GetOrdinate(sequence, ordinate, 0);
var interval = Interval.Create(val);
for (var i = 1; i < sequence.Count; i++)
interval = interval.ExpandedByValue(GetOrdinate(sequence, ordinate, i));
writer.Write(interval.Min);
writer.Write(interval.Max);
}
///<summary>
/// Copies a coordinate of a <see cref="ICoordinateSequence"/> to another <see cref="ICoordinateSequence"/>.
/// The sequences may have different dimensions;
/// in this case only the common dimensions are copied.
///</summary>
/// <param name="src">The sequence to copy coordinate from</param>
/// <param name="srcPos">The index of the coordinate to copy</param>
/// <param name="dest">The sequence to which the coordinate should be copied to</param>
/// <param name="destPos">The index of the coordinate in <see paramref="dest"/></param>
public static void CopyCoord(ICoordinateSequence src, int srcPos, ICoordinateSequence dest, int destPos)
{
int minDim = Math.Min(src.Dimension, dest.Dimension);
for (int dim = 0; dim < minDim; dim++)
{
Ordinate ordinate = (Ordinate)dim;
double value = src.GetOrdinate(srcPos, ordinate);
dest.SetOrdinate(destPos, ordinate, value);
}
}
public static bool ContainsOrdinate(this ICoordinate self, Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
case Ordinate.Y:
return true;
default:
throw new NotImplementedException();
}
}
public override double[] GetOrdinates(Ordinate ordinate)
{
if (IsEmpty)
return new double[0];
var ordinateFlag = OrdinatesUtility.ToOrdinatesFlag(ordinate);
if ((_points.Ordinates & ordinateFlag) != ordinateFlag)
return CreateArray(_points.Count, Coordinate.NullOrdinate);
return CreateArray(_points, ordinate);
}
public override double[] GetOrdinates(Ordinate ordinate)
{
if (IsEmpty)
return new double[0];
var ordinateFlag = OrdinatesUtility.ToOrdinatesFlag(ordinate);
if ((_coordinates.Ordinates & ordinateFlag) != ordinateFlag)
return new[] {Coordinate.NullOrdinate};
return new [] { _coordinates.GetOrdinate(0, ordinate)};
}
public static bool ContainsOrdinate(this ICoordinate self, Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
case Ordinate.Y:
return(true);
default:
throw new NotImplementedException();
}
}
public static double GetMin(this IEnvelope self, Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
return self.MinX;
case Ordinate.Y:
return self.MinY;
default:
throw new NotImplementedException();
}
}
protected void WriteInterval(ICoordinateSequence sequence, Ordinate ordinate, BinaryWriter writer)
{
var val = GetOrdinate(sequence, ordinate, 0);
var interval = Interval.Create(val);
for (var i = 1; i < sequence.Count; i++)
{
interval = interval.ExpandedByValue(GetOrdinate(sequence, ordinate, i));
}
writer.Write(interval.Min);
writer.Write(interval.Max);
}
private static double[] GetRange(this IGeometry self, Ordinate ordinate, double[] minmax)
{
foreach (var sequence in self.GetSequences())
{
for (var i = 0; i < sequence.Count; i++)
{
var ordinateValue = sequence.GetOrdinate(i, ordinate);
minmax[0] = minmax[0] < ordinateValue ? minmax[0] : ordinateValue;
minmax[1] = minmax[1] > ordinateValue ? minmax[1] : ordinateValue;
}
}
return(minmax);
}
/// <summary>
/// Returns the ordinate of a coordinate in this sequence.
/// Ordinate indices 0 and 1 are assumed to be X and Y.
/// Ordinates indices greater than 1 have user-defined semantics
/// (for instance, they may contain other dimensions or measure values).
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param>
/// <returns></returns>
public virtual double GetOrdinate(int index, Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X: return(_coordinates[index].X);
case Ordinate.Y: return(_coordinates[index].Y);
case Ordinate.Z: return(_coordinates[index].Z);
default:
return(Double.NaN);
}
}
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
if (index >= _points.Length)
{
return;
}
_points[index] = new PointM(
ordinate == Ordinate.X ? value : _points[index].X,
ordinate == Ordinate.Y ? value : _points[index].Y,
ordinate == Ordinate.Z ? value : _points[index].Z,
ordinate == Ordinate.M ? value : _points[index].M
);
}
/// <summary>
/// Sets a specific X, Y or Z value depending on the index specified and the ordinate specified
/// </summary>
/// <param name="index"></param>
/// <param name="ordinate"></param>
/// <param name="value"></param>
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
switch (ordinate)
{
case Ordinate.X: _internalList[index].X = value; break;
case Ordinate.Y: _internalList[index].Y = value; break;
case Ordinate.Z: _internalList[index].Z = value; break;
case Ordinate.M: _internalList[index].M = value; break;
}
IncrementVersion();
}
public static double GetOrdinate(this ICoordinate self, Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
return self.X;
case Ordinate.Y:
return self.Y;
case Ordinate.Z:
return self.Z;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Function to create a random ordinates. For x-ordinates the values are limited to <see cref="MinX"/> and <see cref="MaxX"/>. For y-Ordinates the bounds are <see cref="MinY"/> and <see cref="MaxY"/>. z- and m-ordinates are limited to the range [0; 1000[.
/// </summary>
/// <param name="ordinate">The ordinate to obtain</param>
/// <returns>A random value that should represent an ordinate value.</returns>
private double RandomOrdinate(Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
return(MinX + RND.NextDouble() * (MaxX - MinX));
case Ordinate.Y:
return(MinY + RND.NextDouble() * (MaxY - MinY));
default:
return(RND.NextDouble() * 1000);
}
}
public static double GetMin(this IEnvelope self, Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
return(self.MinX);
case Ordinate.Y:
return(self.MinY);
default:
throw new NotImplementedException();
}
}
private static Ordinate[] ToOrdinateArray(Ordinates ordinates)
{
var result = new Ordinate[OrdinatesUtility.OrdinatesToDimension(ordinates)];
int nextIndex = 0;
for (int i = 0; i < 32; i++)
{
if (ordinates.HasFlag((Ordinates)(1 << i)))
{
result[nextIndex++] = (Ordinate)i;
}
}
return(result);
}
public override double[] GetOrdinates(Ordinate ordinate)
{
if (IsEmpty)
{
return(new double[0]);
}
var ordinateFlag = (Ordinates)(1 << (int)ordinate);
if ((_points.Ordinates & ordinateFlag) != ordinateFlag)
{
return(CreateArray(_points.Count, Coordinate.NullOrdinate));
}
return(CreateArray(_points, ordinate));
}
/// <summary>
/// Sets the value for a given ordinate of a coordinate in this sequence.
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param>
/// <param name="value">The new ordinate value.</param>
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
switch (ordinate)
{
case Ordinate.X:
_coordinates[index].X = value;
break;
case Ordinate.Y: _coordinates[index].Y = value;
break;
case Ordinate.Z:
_coordinates[index].Z = value;
break;
}
}
/// <summary>
/// Sets the value for a given ordinate of a coordinate in this sequence.
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param>
/// <param name="value">The new ordinate value.</param>
public virtual void SetOrdinate(int index, Ordinate ordinate, double value)
{
switch (ordinate)
{
case Ordinate.X: _coordinates[index].X = value; break;
case Ordinate.Y: _coordinates[index].Y = value; break;
case Ordinate.Z: _coordinates[index].Z = value; break;
case Ordinate.M: _coordinates[index].M = value; break;
default:
throw new ArgumentException("invalid ordinate index: " + ordinate);
}
IncrementVersion();
}
public static double GetOrdinate(this ICoordinate self, Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
return(self.X);
case Ordinate.Y:
return(self.Y);
case Ordinate.Z:
return(self.Z);
default:
throw new NotImplementedException();
}
}
public override double[] GetOrdinates(Ordinate ordinate)
{
if (IsEmpty)
{
return(new double[0]);
}
var ordinateFlag = OrdinatesUtility.ToOrdinatesFlag(ordinate);
if ((_coordinates.Ordinates & ordinateFlag) != ordinateFlag)
{
return new[] { Coordinate.NullOrdinate }
}
;
return(new [] { _coordinates.GetOrdinate(0, ordinate) });
}
public double GetOrdinate(int index, Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
return(coordinates[index].X);
case Ordinate.Y:
return(coordinates[index].Y);
case Ordinate.Z:
return(coordinates[index].Z);
case Ordinate.M:
return(coordinates[index].M);
}
return(Double.NaN);
}
/// <summary>
/// Function to determine whether an ordinate should be handled or not.
/// </summary>
/// <param name="ordinate"></param>
/// <returns></returns>
private bool HandleOrdinate(Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
case Ordinate.Y:
return(true);
case Ordinate.M:
return((HandleOrdinates & Ordinates.M) != Ordinates.None);
case Ordinate.Z:
return((HandleOrdinates & Ordinates.Z) != Ordinates.None);
default:
return(false);
}
}
/// <summary>
/// Sets the value for a given ordinate of a coordinate in this sequence.
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param>
/// <param name="value">The new ordinate value.</param>
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
switch (ordinate)
{
case Ordinate.X:
Coordinates[index].X = value;
break;
case Ordinate.Y:
Coordinates[index].Y = value;
break;
case Ordinate.Z:
Coordinates[index].Z = value;
break;
//default:
// //throw new ArgumentException("invalid ordinate index: " + ordinate);
}
}
public override double[] GetOrdinates(Ordinate ordinate)
{
if (IsEmpty)
{
return(new double[0]);
}
var result = new double[NumPoints];
var offset = 0;
for (var i = 0; i < NumGeometries; i++)
{
var geom = GetGeometryN(i);
var ordinates = geom.GetOrdinates(ordinate);
Array.Copy(ordinates, 0, result, offset, ordinates.Length);
offset += ordinates.Length;
}
return(result);
}
/// <summary>
/// Evaluates the <see cref="Interval"/> of the <paramref name="ordinate"/>-values in
/// <paramref name="sequence"/> and writes it using the provided <paramref name="writer"/>
/// </summary>
/// <param name="sequence">The sequence</param>
/// <param name="ordinate">The ordinate</param>
/// <param name="writer">The writer</param>
protected void WriteInterval(CoordinateSequence sequence, Ordinate ordinate, BinaryWriter writer)
{
Interval interval;
if (!sequence.TryGetOrdinateIndex(ordinate, out int ordinateIndex))
{
interval = ordinate == Ordinate.M
? Interval.Create(ShapeFileConstants.NoDataValue)
: Interval.Create(double.NaN);
}
else if (ordinate == Ordinate.M)
{
double val = sequence.GetOrdinate(0, ordinateIndex);
if (double.IsNaN(val))
{
val = ShapeFileConstants.NoDataValue;
}
interval = Interval.Create(val);
for (int i = 1, cnt = sequence.Count; i < cnt; i++)
{
val = sequence.GetOrdinate(i, ordinateIndex);
if (double.IsNaN(val))
{
val = ShapeFileConstants.NoDataValue;
}
interval = interval.ExpandedByValue(val);
}
}
else
{
double val = sequence.GetOrdinate(0, ordinateIndex);
interval = Interval.Create(val);
for (int i = 1, cnt = sequence.Count; i < cnt; i++)
{
interval = interval.ExpandedByValue(sequence.GetOrdinate(i, ordinateIndex));
}
}
writer.Write(interval.Min);
writer.Write(interval.Max);
}
private static double RandomOrdinate(Ordinate o, IPrecisionModel pm)
{
switch (o)
{
case Ordinate.X:
return(pm.MakePrecise(-180 + 360 * Rnd.NextDouble()));
case Ordinate.Y:
return(pm.MakePrecise(-90 + 180 * Rnd.NextDouble()));
case Ordinate.Z:
return(200 * Rnd.NextDouble());
case Ordinate.M:
return(200 + 200 * Rnd.NextDouble());
default:
throw new NotSupportedException();
}
}
/// <summary>
/// Sets the value for a given ordinate of a coordinate in this sequence.
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param>
/// <param name="value">The new ordinate value.</param>
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
switch (ordinate)
{
case Ordinate.X:
Coordinates[index].X = value;
break;
case Ordinate.Y:
Coordinates[index].Y = value;
break;
case Ordinate.Z:
Coordinates[index].Z = value;
break;
//default:
// //throw new ArgumentException("invalid ordinate index: " + ordinate);
}
}
/// <summary>
/// Sets a specific X, Y or Z value depending on the index specified and the ordinate specified
/// </summary>
/// <param name="index"></param>
/// <param name="ordinate"></param>
/// <param name="value"></param>
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
switch (ordinate)
{
case Ordinate.X: _internalList[index].X = value; break;
case Ordinate.Y: _internalList[index].Y = value; break;
case Ordinate.Z: _internalList[index].Z = value; break;
case Ordinate.M: _internalList[index].M = value; break;
}
IncrementVersion();
}
public override double[] GetOrdinates(Ordinate ordinate)
{
if (IsEmpty)
return new double[0];
var result = new double[NumPoints];
var offset = 0;
for (var i = 0; i < NumGeometries; i++)
{
var geom = GetGeometryN(i);
var ordinates = geom.GetOrdinates(ordinate);
Array.Copy(ordinates, 0, result, offset, ordinates.Length);
offset += ordinates.Length;
}
return result;
}
public double GetOrdinate(int index, Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
return _xy[index * 2];
case Ordinate.Y:
return _xy[index * 2 + 1];
case Ordinate.Z:
return _z != null ? _z[index] : Coordinate.NullOrdinate;
case Ordinate.M:
return _m != null ? _m[index] : Coordinate.NullOrdinate;
default:
throw new NotSupportedException();
}
}
public double GetOrdinate(int index, Ordinate ordinateIndex)
{
// Z ord is always 0
if (ordinateIndex > Ordinate.Y) return 0;
return _seq.GetOrdinate(index, _indexMap[(int) ordinateIndex]);
}
/// <summary>
/// Function to create a random ordinates. For x-ordinates the values are limited to <see cref="MinX"/> and <see cref="MaxX"/>. For y-Ordinates the bounds are <see cref="MinY"/> and <see cref="MaxY"/>. z- and m-ordinates are limited to the range [0; 1000[.
/// </summary>
/// <param name="ordinate">The ordinate to obtain</param>
/// <returns>A random value that should represent an ordinate value.</returns>
private double RandomOrdinate(Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
return MinX + RND.NextDouble() * (MaxX - MinX);
case Ordinate.Y:
return MinY + RND.NextDouble() * (MaxY - MinY);
default:
return RND.NextDouble() * 1000;
}
}
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
switch (ordinate)
{
case Ordinate.X:
_xy[index * 2] = value;
break;
case Ordinate.Y:
_xy[index * 2 + 1] = value;
break;
case Ordinate.Z:
if (_z != null) _z[index] = value;
break;
case Ordinate.M:
if (_m != null) _m[index] = value;
break;
default:
throw new NotSupportedException();
}
_coordinateArrayRef = null;
}
private static double RandomOrdinate(Ordinate o, IPrecisionModel pm)
{
switch (o)
{
case Ordinate.X:
return pm.MakePrecise(-180 + 360 * Rnd.NextDouble());
case Ordinate.Y:
return pm.MakePrecise(-90 + 180 * Rnd.NextDouble());
case Ordinate.Z:
return 200 * Rnd.NextDouble();
case Ordinate.M:
return 200 + 200 * Rnd.NextDouble();
default:
throw new NotSupportedException();
}
}
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
throw new NotImplementedException();
}
/// <summary> /// Sets the ordinate of a coordinate in this sequence. /// </summary> /// <param name="index">The coordinate index.</param> /// <param name="ordinate">The ordinate index in the coordinate, 0 based, /// smaller than the number of dimensions.</param> /// <param name="value">The new ordinate value.</param> /// <remarks> /// Warning: for performance reasons the ordinate index is not checked. /// If it is larger than the dimension a meaningless value may be returned. /// </remarks> public abstract void SetOrdinate(int index, Ordinate ordinate, double value);
/// <summary> /// Returns the ordinate of a coordinate in this sequence. /// Ordinate indices 0 and 1 are assumed to be X and Y. /// Ordinate indices greater than 1 have user-defined semantics /// (for instance, they may contain other dimensions or measure values). /// </summary> /// <param name="index">The coordinate index in the sequence.</param> /// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param> /// <returns></returns> public abstract double GetOrdinate(int index, Ordinate ordinate);
/// <summary>
/// Sets the value for a given ordinate of a coordinate in this sequence.
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param>
/// <param name="value">The new ordinate value.</param>
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
switch (ordinate)
{
case Ordinate.X:
_coordinates[index].X = value;
break;
case Ordinate.Y: _coordinates[index].Y = value;
break;
case Ordinate.Z:
_coordinates[index].Z = value;
break;
}
}
private AxisPlaneCoordinateSequence(ICoordinateSequence seq, Ordinate[] indexMap)
{
_seq = seq;
_indexMap = indexMap;
}
public void SetOrdinate(int index, Ordinate ordinateIndex, double value)
{
throw new NotSupportedException();
}
/// <summary>
/// Returns the ordinate of a coordinate in this sequence.
/// Ordinate indices 0 and 1 are assumed to be X and Y.
/// Ordinate indices greater than 1 have user-defined semantics
/// (for instance, they may contain other dimensions or measure values).
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param>
/// <returns></returns>
public double GetOrdinate(int index, Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
return Coordinates[index].X;
case Ordinate.Y:
return Coordinates[index].Y;
case Ordinate.Z:
return Coordinates[index].Z;
default:
return Double.NaN;
}
}
//TODO: Implement missing methods
public double GetOrdinate(int index, Ordinate ordinate)
{
throw new NotImplementedException();
}
/// <summary>
/// Function to determine whether an ordinate should be handled or not.
/// </summary>
/// <param name="ordinate"></param>
/// <returns></returns>
private bool HandleOrdinate(Ordinate ordinate)
{
switch (ordinate)
{
case Ordinate.X:
case Ordinate.Y:
return true;
case Ordinate.M:
return (HandleOrdinates & Ordinates.M) != Ordinates.None;
case Ordinate.Z:
return (HandleOrdinates & Ordinates.Z) != Ordinates.None;
default:
return false;
}
}
/// <summary>
/// Sets the value for a given ordinate of a coordinate in this sequence.
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param>
/// <param name="value">The new ordinate value.</param>
public void SetOrdinate(int index, Ordinate ordinate, double value)
{
var exc = (ExtendedCoordinate)_coordinates[index];
switch (ordinate)
{
case Ordinate.X:
exc.X = value;
break;
case Ordinate.Y:
exc.Y = value;
break;
case Ordinate.Z:
exc.Z = value;
break;
case Ordinate.M:
exc.M = value;
break;
}
}
private static double[] GetRange(this IGeometry self, Ordinate ordinate, double[] minmax)
{
foreach (var sequence in self.GetSequences())
{
for (var i = 0; i < sequence.Count; i++)
{
var ordinateValue = sequence.GetOrdinate(i, ordinate);
minmax[0] = minmax[0] < ordinateValue ? minmax[0] : ordinateValue;
minmax[1] = minmax[1] > ordinateValue ? minmax[1] : ordinateValue;
}
}
return minmax;
}
/// <summary>
/// Returns the ordinate of a coordinate in this sequence.
/// Ordinate indices 0 and 1 are assumed to be X and Y.
/// Ordinate indices greater than 1 have user-defined semantics
/// (for instance, they may contain other dimensions or measure values).
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param>
/// <returns></returns>
public double GetOrdinate(int index, Ordinate ordinate)
{
var exc = (ExtendedCoordinate) _coordinates[index];
switch (ordinate)
{
case Ordinate.X:
return exc.X;
case Ordinate.Y:
return exc.Y;
case Ordinate.Z:
return exc.Z;
case Ordinate.M:
return exc.M;
default:
return Double.NaN;
}
}
private static bool HasOrdinate(ICoordinateSequence seq, Ordinate ordinate)
{
return (seq.Ordinates & OrdinatesUtility.ToOrdinatesFlag(new[] { ordinate })) != Ordinates.None;
}
/// <summary>
/// Gets a specific X, Y or Z value depending on the index specified and the ordinate specified
/// </summary>
/// <param name="index"></param>
/// <param name="ordinate"></param>
/// <returns></returns>
public double GetOrdinate(int index, Ordinate ordinate)
{
return _internalList[index].Z;
}
/// <summary>
/// Sets the ordinate of a coordinate in this sequence.
/// </summary>
/// <param name="index">The coordinate index.</param>
/// <param name="ordinate">The ordinate index in the coordinate, 0 based,
/// smaller than the number of dimensions.</param>
/// <param name="value">The new ordinate value.</param>
/// <remarks>
/// Warning: for performance reasons the ordinate index is not checked:
/// if it is over dimensions you may not get an exception but a meaningless value.
/// </remarks>
public override void SetOrdinate(int index, Ordinate ordinate, double value)
{
CoordRef = null;
_coords[index * Dimension + (int) ordinate] = (float) value;
}
/// <summary>
/// Returns the ordinate of a coordinate in this sequence.
/// Ordinate indices 0 and 1 are assumed to be X and Y.
/// Ordinate indices greater than 1 have user-defined semantics
/// (for instance, they may contain other dimensions or measure values).
/// </summary>
/// <param name="index">The coordinate index in the sequence.</param>
/// <param name="ordinate">The ordinate index in the coordinate (in range [0, dimension-1]).</param>
/// <returns></returns>
public override double GetOrdinate(int index, Ordinate ordinate)
{
return _coords[index * Dimension + (int) ordinate];
}
