计算两个CGPoints之间的距离

Question

i need to calculate the distance between two CGPoint s. I refered this and this , but I don't get it.

Answer 1

Well, with stuff your refering too where is the full code:

CGPoint p2; //[1]
CGPoint p1;
//Assign the coord of p2 and p1...
//End Assign...
CGFloat xDist = (p2.x - p1.x); //[2]
CGFloat yDist = (p2.y - p1.y); //[3]
CGFloat distance = sqrt((xDist * xDist) + (yDist * yDist)); //[4]

The distance is the variable distance.

What is going on here:

1. So first off we make two points...
2. Then we find the distance between x coordinates of the points.
3. Now we find the distance between the y coordinates.
4. These lengths are two sides of the triangle, infact they are the legs, time to find the hypotenuse which means after doing some math to rearragne c^2 = a^2 + b^2 we get the hypotenuse to equal sqrt((xDist^2) + (yDist^2)). xDist^2 = (xDist * xDist). And likewise: yDist^2 = (yDist * yDist)

You can't really make a CGPoint be the distance, distance doesn't have an x and y component. It is just 1 number.

If you think CGPoint is a unit of measurement (for example feet is a unit of measurement) it is not.

Answer 2

I've had to do this by hand 10,000 times so I wrote a function for it and stuck it in my personal library that I always dump in at the beginning of a new program so I forget it's not cannon.

- (float)distanceBetween:(CGPoint)p1 and:(CGPoint)p2
{
    return sqrt(pow(p2.x-p1.x,2)+pow(p2.y-p1.y,2));
}

so you call it like this (say you want to know how far you moved your finger):

float moveDistance = [self distanceBetween:touchStart and:touchEnd];

This is useful in movement functions as well for spot checking in a scrolling menu:

if([self distanceBetween:touchStart and:touchAt] > 20*scalePoints)
    isItATap = FALSE;

Set "isItATap" true in touchesBegan, put the above in touchesMoved, then you know the player moved their finger too far for the touch to be a "tap", so you can have it NOT select the object the player touched and instead scroll the object around.

As for scale, that should be based on whether or not you have retina display and what size of a device you're on (divide by 2 for retina display since a physical distance of 5 "points" on a regular screen as the user's finger feels it will come up as 10 "pixels" on a retina display screen, since each point is 4 pixels, so you'll wind up with a situation where the player has a very hard time tapping on retina display (which is a common oversight)

Answer 3

Sounds like you probably want the vector from p1 to p2 (or difference ) rather than the distance.

const CGPoint p1 = {10, 10};
const CGPoint p2 = {510, 310};

const CGPoint diff = {p2.x - p1.x, p2.y - p1.y} // == (CGPoint){500, 300}

Answer 4

Short Answer

CGPoint p1, p2; // Having two points
CGFloat distance = hypotf((p1.x-p2.x), (p1.y-p2.y));

---

Longer Explination

If you have two points p1 and p2 it is obviously easy to find the difference between their height and width (eg ABS(p1.x - p2.x) ) but to find a true representation of their distance you really want the hypothenuse ( H below).

 p1
  |\  
  | \  
  |  \ H
  |   \
  |    \
  |_ _ _\
         p2

Thankfully there is a built in macro for this: hypotf (or hypot for doubles ):

// Returns the hypothenuse (the distance between p1 & p2)
CGFloat dist = hypotf((p1.x-p2.x), (p1.y-p2.y));

(original reference )

Answer 5

In Swift, you can add an extension to CGPoint:

extension CGPoint {
    func distance(to point: CGPoint) -> CGFloat {
        return sqrt(pow((point.x - x), 2) + pow((point.y - y), 2))
    }
}

and use it like this:

let distance = p1.distance(to: p2)

Answer 6

In Apple's sample projects, they use hypot. This returns hypothenuse (distance) between two points as explained in this answer .

extension CGPoint {

    func distance(from point: CGPoint) -> CGFloat {
        return hypot(point.x - x, point.y - y)
    }
}

Answer 7

only this...

    float distance = ccpLength(ccpSub(p1,p2));

where p1 and p2 are objects of CGPoint

Answer 8

Swift 4, Swift 3 solution

 extension CGPoint {
        static func distanceBetween(point p1: CGPoint,
                                    andPoint p2: CGPoint) -> CGFloat {
            return sqrt(pow((p2.x - p1.x), 2) + pow((p2.y - p1.y), 2))
        }
    }

Answer 9

Euclidean distance to another point with Vision api.

Starting from iOS 14 .

import Vision

extension CGPoint {
        
    public func distance(to point: CGPoint) -> Double {
        VNPoint(location: self).distance(VNPoint(location: point))
    }
}


print(CGPoint(x: 1, y: 1).distance(to: .zero)) // 1.4142135623730951

Answer 10

I extended above function to count distance between two CGRects. I count it by counting distance between centers of CGRects and then substracting distance to boundaries of rectangles from their centers. I copied function counting intersection point between two lines from: https://www.hackingwithswift.com/example-code/core-graphics/how-to-calculate-the-point-where-two-lines-intersect

   func distanceBetweenRectangles(r1: CGRect, r2: CGRect) -> CGFloat { // returns distance between boundaries of two rectangles or -1 if they intersect
    let midR1 = CGPoint(x: r1.midX, y: r1.midY)
    let midR2 = CGPoint(x: r2.midX, y: r2.midY)
    let midXDistance = abs(midR1.x - midR2.x)
    let midYDistance = abs(midR1.y - midR2.y)
    var result: CGFloat = 0
    if ((midXDistance < r1.width*0.5)&&(midYDistance < r1.height*0.5))||((midXDistance < r2.width*0.5)&&(midYDistance < r2.height*0.5)) {
        result = -1
    } else {
        let midDistance = distanceBetweenPoints(p1: midR1, p2: midR2)
        let rectCrossPoint1 = rectCross(rect: r1, start1: midR1, end1: midR2)
        let rectCrossPoint2 = rectCross(rect: r2, start1: midR1, end1: midR2)
        let boundR1Distance = distanceBetweenPoints(p1: rectCrossPoint1, p2: midR1)
        let boundR2Distance = distanceBetweenPoints(p1: rectCrossPoint2, p2: midR2)
        result = midDistance - boundR1Distance - boundR2Distance
    }
    return result
}

func distanceBetweenPoints(p1: CGPoint, p2: CGPoint) -> CGFloat { // counts distance between two points
    return sqrt(pow(p2.x-p1.x,2)+pow(p2.y-p1.y,2));
}

func rectCross(rect: CGRect, start1: CGPoint, end1: CGPoint) -> CGPoint { // returns point where line crosses rect or 0,0 if not
    var start2 = CGPoint(x: rect.minX, y: rect.minY)
    var end2 = CGPoint(x: rect.maxX, y: rect.minY)
    let point1 = linesCross(start1: start1, end1: end1, start2: start2, end2: end2)
    start2 = CGPoint(x: rect.maxX, y: rect.minY)
    end2 = CGPoint(x: rect.maxX, y: rect.maxY)
    let point2 = linesCross(start1: start1, end1: end1, start2: start2, end2: end2)
    start2 = CGPoint(x: rect.minX, y: rect.maxY)
    end2 = CGPoint(x: rect.maxX, y: rect.maxY)
    let point3 = linesCross(start1: start1, end1: end1, start2: start2, end2: end2)
    start2 = CGPoint(x: rect.minX, y: rect.minY)
    end2 = CGPoint(x: rect.minX, y: rect.maxY)
    let point4 = linesCross(start1: start1, end1: end1, start2: start2, end2: end2)
    
    if (point1.x > 0)&&(point1.y > 0) {
        return point1
    } else if (point2.x > 0)&&(point2.y > 0) {
        return point2
    } else if (point3.x > 0)&&(point3.y > 0) {
        return point3
    } else if (point4.x > 0)&&(point4.y > 0) {
        return point4
    }
    return CGPoint(x: 0, y: 0)
}

func linesCross(start1: CGPoint, end1: CGPoint, start2: CGPoint, end2: CGPoint) -> CGPoint { // returns point where two sections cross or 0,0, this function was copied from https://www.hackingwithswift.com/example-code/core-graphics/how-to-calculate-the-point-where-two-lines-intersect
    let delta1x = end1.x - start1.x
    let delta1y = end1.y - start1.y
    let delta2x = end2.x - start2.x
    let delta2y = end2.y - start2.y
    // create a 2D matrix from our vectors and calculate the determinant
    let determinant = delta1x * delta2y - delta2x * delta1y
    if abs(determinant) < 0.0001 {
        // if the determinant is effectively zero then the lines are parallel/colinear
        return CGPoint(x: 0, y: 0)
    }
    // if the coefficients both lie between 0 and 1 then we have an intersection
    let ab = ((start1.y - start2.y) * delta2x - (start1.x - start2.x) * delta2y) / determinant
    if ab > 0 && ab < 1 {
        let cd = ((start1.y - start2.y) * delta1x - (start1.x - start2.x) * delta1y) / determinant

        if cd > 0 && cd < 1 {
            // lines cross – figure out exactly where and return it
            let intersectX = start1.x + ab * delta1x
            let intersectY = start1.y + ab * delta1y
            return CGPoint(x: intersectX, y: intersectY)
        }
    }
    return CGPoint(x: 0, y: 0)
}

Answer 11

extension CGPoint {
    func magnitude() -> CGFloat {
        return sqrt(x * x + y * y)
    }
    
    func distance(to: CGPoint) -> CGFloat {
        return CGPoint(x: to.x - x, y: to.y - y).magnitude()
    }
}