public void Filter(CoordinateSequence seq, int i)
{
var result = _transform.Transform(new[] { seq.GetOrdinate(i, Ordinate.X), seq.GetOrdinate(i, Ordinate.Y) });
seq.SetOrdinate(i, Ordinate.X, result[0]);
seq.SetOrdinate(i, Ordinate.Y, result[1]);
}
/// <summary>
/// Applies this transformation to the i'th coordinate
/// in the given CoordinateSequence.
/// </summary>
/// <param name="seq"> a <code>CoordinateSequence</code></param>
/// <param name="i"> the index of the coordinate to transform</param>
public void Transform(CoordinateSequence seq, int i)
{
double xp = _m00 * seq.GetOrdinate(i, 0) + _m01 * seq.GetOrdinate(i, 1) + _m02;
double yp = _m10 * seq.GetOrdinate(i, 0) + _m11 * seq.GetOrdinate(i, 1) + _m12;
seq.SetOrdinate(i, 0, xp);
seq.SetOrdinate(i, 1, yp);
}
/// <summary>
///
/// </summary>
/// <param name="seq">The coordinate sequence</param>
public void Filter(CoordinateSequence seq, int i)
{
double xp = seq.GetOrdinate(i, 0) + _trans.X;
double yp = seq.GetOrdinate(i, 1) + _trans.Y;
seq.SetOrdinate(i, 0, xp);
seq.SetOrdinate(i, 1, yp);
}
public static void SetCoordinate(this CoordinateSequence self, int index, Coordinate coord)
{
self.SetOrdinate(index, Ordinate.X, coord.X);
self.SetOrdinate(index, Ordinate.Y, coord.Y);
if (self.Dimension > 2)
{
self.SetOrdinate(index, Ordinate.Z, coord.Z);
}
}
private static CoordinateSequence CopyToSequence(Coordinate[] coords, CoordinateSequence sequence)
{
for (int i = 0; i < coords.Length; i++)
{
sequence.SetOrdinate(i, Ordinate.X, coords[i].X);
sequence.SetOrdinate(i, Ordinate.Y, coords[i].Y);
}
return(sequence);
}
private static void FixSpike(CoordinateSequence seq, int fixIndex, int fixWithIndex)
{
seq.SetOrdinate(fixIndex, Ordinate.X, seq.GetOrdinate(fixWithIndex, Ordinate.X));
seq.SetOrdinate(fixIndex, Ordinate.Y, seq.GetOrdinate(fixWithIndex, Ordinate.Y));
if ((seq.Ordinates & Ordinates.Z) == Ordinates.Z)
{
seq.SetOrdinate(fixIndex, Ordinate.Z, seq.GetOrdinate(fixWithIndex, Ordinate.Z));
}
if ((seq.Ordinates & Ordinates.M) == Ordinates.M)
{
seq.SetOrdinate(fixIndex, Ordinate.M, seq.GetOrdinate(fixWithIndex, Ordinate.M));
}
}
private static void InitProgression(CoordinateSequence seq)
{
for (int index = 0; index < seq.Count; index++)
{
for (int ordinateIndex = 0; ordinateIndex < seq.Dimension; ordinateIndex++)
{
seq.SetOrdinate(index, ordinateIndex, index);
}
}
}
private static CoordinateSequence FillNonPlanarDimensions(CoordinateSequence seq)
{
if (seq.Dimension < 3)
{
return(seq);
}
for (int i = 0; i < seq.Count; i++)
{
for (int j = 2; j < seq.Dimension; j++)
{
seq.SetOrdinate(i, j, i * Math.Pow(10, j - 1));
}
}
return(seq);
}
public void Filter(CoordinateSequence seq)
{
if (!seq.HasZ)
{
// if no Z then short-circuit evaluation
Done = true;
return;
}
for (int i = 0; i < seq.Count; i++)
{
// if Z not populated then assign using model
if (double.IsNaN(seq.GetZ(i)))
{
double z = _em.GetZ(seq.GetOrdinate(i, Ordinate.X), seq.GetOrdinate(i, Ordinate.Y));
seq.SetOrdinate(i, Ordinate.Z, z);
}
}
}
public void SetMeasureAtIndex(int index, double m)
{
CoordinateSequence.SetOrdinate(index, Ordinate.M, m);
this.GeometryChanged();
}
/// <summary>
/// Rounds the Coordinates in the sequence to match the PrecisionModel
/// </summary>
public void Filter(CoordinateSequence seq, int i)
{
seq.SetOrdinate(i, 0, _precModel.MakePrecise(seq.GetOrdinate(i, 0)));
seq.SetOrdinate(i, 1, _precModel.MakePrecise(seq.GetOrdinate(i, 1)));
}
