CODEWITHSUNDEEP
c#
user1307376
user1307376

Reputation: 371

Calculating the distance between 2 points

I have two points (x1,y1) and (x2,y2). I want to know whether the points are within 5 meters of one another.

Upvotes: 23

Views: 146623

Answers (10)

Craig Wright
Craig Wright

Reputation: 21

System.Numerics has this functionality for vector 3

    /// <summary>
    /// Returns the Euclidean distance between the two given points.
    /// </summary>
    /// <param name="value1">The first point.</param>
    /// <param name="value2">The second point.</param>
    /// <returns>The distance.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float Distance(Vector3 value1, Vector3 value2) {
    if (Vector.IsHardwareAccelerated) {
        Vector3 difference = value1 - value2;
        float ls = Vector3.Dot(difference, difference);
        return (float) System.Math.Sqrt(ls);
    } else {
        float dx = value1.X - value2.X;
        float dy = value1.Y - value2.Y;
        float dz = value1.Z - value2.Z;

        float ls = dx * dx + dy * dy + dz * dz;

        return (float) System.Math.Sqrt((double) ls);
    }
}

/// <summary>
/// Returns the Euclidean distance squared between the two given points.
/// </summary>
/// <param name="value1">The first point.</param>
/// <param name="value2">The second point.</param>
/// <returns>The distance squared.</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float DistanceSquared(Vector3 value1, Vector3 value2) {
    if (Vector.IsHardwareAccelerated) {
        Vector3 difference = value1 - value2;
        return Vector3.Dot(difference, difference);
    } else {
        float dx = value1.X - value2.X;
        float dy = value1.Y - value2.Y;
        float dz = value1.Z - value2.Z;

        return dx * dx + dy * dy + dz * dz;
    }
}

Reference here https://referencesource.microsoft.com/#System.Numerics/System/Numerics/Vector3.cs

Upvotes: 1

Fidel
Fidel

Reputation: 7397

Based on Jack's answer, I use the following extension method:

public static class Extensions
{
    public static double DistanceTo(this Point from, Point to)
    {
        var result = Math.Sqrt(Math.Pow((from.X - to.X), 2) + Math.Pow((from.Y - to.Y), 2));
        return result;
    }
}

Which allows for the following:

var distance = point1.DistanceTo(point2);

Upvotes: 4

j123b567
j123b567

Reputation: 3439

If you are using System.Windows.Point data type to represent a point, you can use

// assuming p1 and p2 data types
Point p1, p2;
// distanc can be calculated as follows
double distance = Point.Subtract(p2, p1).Length;

Update 2017-01-08:

  • Add reference to Microsoft documentation
  • Result of Point.Subtract is System.Windows.Vector and it has also property LengthSquared to save one sqrt calculation if you just need to compare distance.
  • Adding reference to WindowsBase assembly may be needed in your project
  • You can also use operators

Example with LengthSquared and operators

// assuming p1 and p2 data types
Point p1, p2;
// distanc can be calculated as follows
double distanceSquared = (p2 - p1).LengthSquared;

Update 2021-11-15:

Unfortunately, System.Windows.Point and WindowsBase is available only in .Net Framework. It is not part of .NET, .NET standard, .NET core.

System.Drawing.Point and System.Drawing.PointF does not have any usable methods and operators and they are just containers.

Interesing is System.Numerics.Vector2 which is probably best replacement for System.Windows.Point. It has similar API and is available in all .NET flawors. But, the semantics is strange - using Vector for Point representation.

Upvotes: 61

eakcn94
eakcn94

Reputation: 21

if u use System.Drawing.Point ;

Point p1 = new Point();
Point p2 = new Point();

Math.Pow(Math.Pow(p1.X - p2.X, 2) + Math.Pow(p1.Y - p2.Y, 2), 1 / 2);

if u use System.Windows.Point like wpf ;

Point.Subtract(_p1, _p2).Length;

Upvotes: 1

destro
destro

Reputation: 21

You can use the below formula to find the distance between the 2 points:

distance*distance = ((x2 − x1)*(x2 - x1)) + ((y2 − y1)*(y2 - y1))

Upvotes: 0

DarkPh03n1X
DarkPh03n1X

Reputation: 680

Here is my 2 cents:

double dX = x1 - x2;
double dY = y1 - y2;
double multi = dX * dX + dY * dY;
double rad = Math.Round(Math.Sqrt(multi), 3, MidpointRounding.AwayFromZero);

x1, y1 is the first coordinate and x2, y2 the second. The last line is the square root with it rounded to 3 decimal places.

Upvotes: 4

Roee Gavirel
Roee Gavirel

Reputation: 19463

Given points (X1,Y1) and (X2,Y2) then: 

dX = X1 - X2;
dY = Y1 - Y2;

if (dX*dX + dY*dY > (5*5))
{
    //your code
}

Upvotes: 5

Jack Fairfield
Jack Fairfield

Reputation: 1984

Something like this in c# would probably do the job. Just make sure you are passing consistent units (If one point is in meters, make sure the second is also in meters)

private static double GetDistance(double x1, double y1, double x2, double y2)
{
   return Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((y2 - y1), 2));
}

Called like so:

double distance = GetDistance(x1, y1, x2, y2)
if(distance <= 5)
{
   //Do stuff
}

Upvotes: 29

Felice Pollano
Felice Pollano

Reputation: 33272

measure the square distance from one point to the other:

((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)) < d*d

where d is the distance, (x1,y1) are the coordinates of the 'base point' and (x2,y2) the coordinates of the point you want to check.

or if you prefer: 

(Math.Pow(x1-x2,2)+Math.Pow(y1-y2,2)) < (d*d);

Noticed that the preferred one does not call Pow at all for speed reasons, and the second one, probably slower, as well does not call Math.Sqrt, always for performance reasons. Maybe such optimization are premature in your case, but they are useful if that code has to be executed a lot of times.

Of course you are talking in meters and I supposed point coordinates are expressed in meters too.

Upvotes: 40

user1530197
user1530197

Reputation:

the algorithm : ((x1 - x2) ^ 2 + (y1 - y2) ^ 2) < 25

Upvotes: -3

Related Questions