/// <summary>
/// Compares this object with the specified object for order.
/// Uses the standard lexicographic ordering for the points in the LineSegment.
/// </summary>
/// <param name="o">
/// The <c>LineSegment</c> with which this <c>LineSegment</c>
/// is being compared.
/// </param>
/// <returns>
/// A negative integer, zero, or a positive integer as this <c>LineSegment</c>
/// is less than, equal to, or greater than the specified <c>LineSegment</c>.
/// </returns>
public int CompareTo(object o)
{
var other = (LineSegment)o;
var comp0 = _p0.CompareTo(other._p0);
return(comp0 != 0 ? comp0 : _p1.CompareTo(other._p1));
}
/// <summary>
/// Returns the minimum coordinate, using the usual lexicographic comparison.
/// </summary>
/// <param name="coordinates">Array to search.</param>
/// <returns>The minimum coordinate in the array, found using <c>CompareTo</c>.</returns>
public static Coordinate MinCoordinate(Coordinate[] coordinates)
{
Coordinate minCoord = null;
for (var i = 0; i < coordinates.Length; i++)
{
if (minCoord == null || minCoord.CompareTo(coordinates[i]) > 0)
{
minCoord = coordinates[i];
}
}
return(minCoord);
}
/// <summary>
/// Determines whether two <see cref="Coordinate" /> arrays of equal length
/// are equal in opposite directions.
/// </summary>
/// <param name="pts1"></param>
/// <param name="pts2"></param>
/// <returns></returns>
private static bool IsEqualReversed(Coordinate[] pts1, Coordinate[] pts2)
{
for (int i = 0; i < pts1.Length; i++)
{
Coordinate p1 = pts1[i];
Coordinate p2 = pts2[pts1.Length - i - 1];
if (p1.CompareTo(p2) != 0)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Returns the minimum coordinate, using the usual lexicographic comparison.
/// </summary>
/// <param name="seq">The coordinate sequence to search</param>
/// <returns>The minimum coordinate in the sequence, found using <see cref="Coordinate.CompareTo(Coordinate)"/></returns>
public static Coordinate MinCoordinate(CoordinateSequence seq)
{
Coordinate minCoord = null;
for (int i = 0; i < seq.Count; i++)
{
var testCoord = seq.GetCoordinate(i);
if (minCoord == null || minCoord.CompareTo(testCoord) > 0)
{
minCoord = testCoord;
}
}
return(minCoord);
}
/// <summary>
/// Returns the index of the minimum coordinate of a part of
/// the coordinate sequence (defined by <paramref name="from"/>
/// and <paramref name="to"/>), using the usual lexicographic
/// comparison.
/// </summary>
/// <param name="seq">The coordinate sequence to search</param>
/// <param name="from">The lower search index</param>
/// <param name="to">The upper search index</param>
/// <returns>The index of the minimum coordinate in the sequence, found using <see cref="Coordinate.CompareTo(Coordinate)"/></returns>
public static int MinCoordinateIndex(CoordinateSequence seq, int from, int to)
{
int minCoordIndex = -1;
Coordinate minCoord = null;
for (int i = from; i <= to; i++)
{
var testCoord = seq.GetCoordinate(i);
if (minCoord == null || minCoord.CompareTo(testCoord) > 0)
{
minCoord = testCoord;
minCoordIndex = i;
}
}
return(minCoordIndex);
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
protected internal override int CompareToSameClass(object other)
{
var point = (Point)other;
return(Coordinate.CompareTo(point.Coordinate));
}
