Question

I have the following code:

foreach (Tuple<Point, Point> pair in pointsCollection)
        {
            var points = new List<Point>()
                        {
                            pair.Value1,
                            pair.Value2
                        };

        }

Within this foreach, I would like to be able to determine which pair of points has the most significant length between the coordinates for each point within the pair.

So, let’s say that points are made up of the following pairs:

(1) var points = new List<Point>()
{
new Point(0,100),
new Point(100,100)
};

(2) var points = new List<Point>()
{
new Point(150,100),
new Point(200,100)
};

So I have two sets of pairs, mentioned above. They both will plot a horizontal line. I am interested in knowing what the best approach would be to find the pair of points that have the greatest distance between, them, whether it is vertically or horizontally. In the two examples above, the first pair of points has a difference of 100 between the X coordinate, so that would be the point with the most significant difference. But if I have a collection of pairs of points, where some points will plot a vertical line, some points will plot a horizontal line, what would be the best approach for retrieving the pair from the set of points whose difference, again vertically or horizontally, is the greatest among all of the points in the collection?

Thanks!

Chris

Answer 1

Use OrderBy to create an ordering based on your criteria, then select the first one. In this case order by the maximum absolute difference between the horizontal and vertical components in descending order.

EDIT: Actually, I think you should be doing this on the Tuples themselves, right? I’ll work on adapting the example to that.

First, let’s add an extension for Tuple<Point,Point> to calculate it’s length.

 public static class TupleExtensions
 {
      public static double Length( this Tuple<Point,Point> tuple )
      {
          var first = tuple.Item1;
          var second = tuple.Item2;
          double deltaX = first.X - second.X;
          double deltaY = first.y - second.Y;
          return Math.Sqrt( deltaX * deltaX + deltaY * deltaY );
      }
}

Now we can order the tuples by their length

var max = pointCollection.OrderByDescending( t => t.Length() )
                         .FirstOrDefault();

Note: it is faster to just iterate over the collection and keep track of the maximum rather than sorting/selecting with LINQ.

Tuple<Point,Point> max = null;
foreach (var tuple in pointCollection)
{
     if (max == null || tuple.Length() > max.Length())
     {
         max = tuple;
     }
}

Obviously, this could be refactored to an IEnumerable extension if you used it in more than one place.