iphone - ubicados - ¿Cómo encontrar la distancia entre dos puntos CG?

encontrar la distancia entre puntos

Question

Cuando hacemos multitouch con dos dedos en un UIScrollView, obtenemos dos puntos CG. Quiero encontrar la distancia entre ellos. Luego, cuando vuelva a hacer el pellizco (dentro o fuera), entonces obtendremos nuevamente dos puntos. Luego, después de encontrar nuevamente la distancia entre estos dos puntos, quiero decidir si pellizqué o no. Si me pellizqué, seguramente la nueva distancia será menor y viceversa.

¿Pero no sé cómo encontrar una medida precisa de la distancia entre 2 puntos para hacer una comparación? ¿Alguien tiene idea sobre esto?

Answer 1

Con Swift 4, puede elegir uno de los 5 siguientes códigos de Playground para obtener la distancia entre dos instancias de CGPoint .

1. Usando la función Darwin sqrt(_:)

import CoreGraphics
func distance(from lhs: CGPoint, to rhs: CGPoint) -> CGFloat {
let xDistance = lhs.x - rhs.x
let yDistance = lhs.y - rhs.y
return sqrt(xDistance * xDistance + yDistance * yDistance)
}
let point1 = CGPoint(x: -10, y: -100)
let point2 = CGPoint(x: 30, y: 600)
distance(from: point1, to: point2) // 701.141925718324

2. Usando el CGFloat squareRoot()

import CoreGraphics
func distance(from lhs: CGPoint, to rhs: CGPoint) -> CGFloat {
let xDistance = lhs.x - rhs.x
let yDistance = lhs.y - rhs.y
return (xDistance * xDistance + yDistance * yDistance).squareRoot()
}
let point1 = CGPoint(x: -10, y: -100)
let point2 = CGPoint(x: 30, y: 600)
distance(from: point1, to: point2) // 701.141925718324

3. Usando el CGFloat squareRoot() y la función Core Graphics pow(_:_:)

import CoreGraphics
func distance(from lhs: CGPoint, to rhs: CGPoint) -> CGFloat {
return (pow(lhs.x - rhs.x, 2) + pow(lhs.y - rhs.y, 2)).squareRoot()
}
let point1 = CGPoint(x: -10, y: -100)
let point2 = CGPoint(x: 30, y: 600)
distance(from: point1, to: point2) // 701.141925718324

4. Usando la función de Core Graphics hypot(_:_:)

import CoreGraphics
func distance(from lhs: CGPoint, to rhs: CGPoint) -> CGFloat {
return hypot(lhs.x - rhs.x, lhs.y - rhs.y)
}
let point1 = CGPoint(x: -10, y: -100)
let point2 = CGPoint(x: 30, y: 600)
distance(from: point1, to: point2) // 701.141925718324

5. Usando Core Graphics hypot(_:_:) function y CGFloat distance(to:) method

import CoreGraphics
func distance(from lhs: CGPoint, to rhs: CGPoint) -> CGFloat {
return hypot(lhs.x.distance(to: rhs.x), lhs.y.distance(to: rhs.y))
}
let point1 = CGPoint(x: -10, y: -100)
let point2 = CGPoint(x: 30, y: 600)
distance(from: point1, to: point2) // 701.141925718324

Answer 2

Creo que usar multiply será más rápido que la función pow que algunos prefieren. En Swift:

public func distanceBetween(p1 : CGPoint, p2 : CGPoint) -> CGFloat {
let dx : CGFloat = p1.x - p2.x
let dy : CGFloat = p1.y - p2.y
return sqrt(dx * dx + dy * dy)
}

Sugerencia para comparar distancias

Sin embargo, un consejo: si está comparando distancias (por ejemplo, para encontrar la más pequeña o la más grande), entonces es mejor omitir el bit sqrt (que es lento) y simplemente comparar los cuadrados de distancias.

Answer 3

Escribí esto, lo uso mucho:

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

Llamar así:

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

Normalmente uso cocos2d, pero todavía uso mi propia función para algunas cosas porque cuando estaba aprendiendo escribí muchas de mis funciones para cosas simples en lugar de buscar las funciones de orden superior "oficiales", y además no soy un gran fan de las funciones (vars, vars), prefiero [self functions vars y: vars]

Answer 4

Puede usar la función hypotf() o hypotf() para calcular la hipotenusa. Dado dos puntos p1 y p2 :

CGFloat distance = hypotf(p1.x - p2.x, p1.y - p2.y);

Y eso es.

Answer 5

Si desea encontrar el valor de distancia absoluta entre dos puntos, puede usar (para Cocos2d):

float distance = abs(ccpDistance(point1, point2));

Answer 6

Para usuarios rápidos

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

Answer 7

Distancia entre p1 y p2 :

CGFloat xDist = (p2.x - p1.x);
CGFloat yDist = (p2.y - p1.y);
CGFloat distance = sqrt((xDist * xDist) + (yDist * yDist));

Swift 3:

func distance(_ a: CGPoint, _ b: CGPoint) -> CGFloat {
let xDist = a.x - b.x
let yDist = a.y - b.y
return CGFloat(sqrt((xDist * xDist) + (yDist * yDist)))
}

Antecedentes: teorema de Pitágoras

Editar: si solo necesita calcular si la distancia entre los puntos aumenta o disminuye, puede omitir el sqrt (), que lo hará un poco más rápido.

Answer 8

#define rw_pointOffset(point1, point2) CGPointMake(point2.x - point1.x, point2.y - point1.y)
#define rw_pointDistance(point1, point2) sqrtf( powf(point2.x - point1.x, 2.0f) + powf(point2.y - point1.y, 2.0f))

Y así es como lo usas:

CGPoint offset = rw_pointOffset(view1.center, view2.center);
float distance = rw_pointDistance(view1.center, view2.center);

Answer 9

-(float)distanceFrom:(CGPoint)point1 to:(CGPoint)point2
{
CGFloat xDist = (point2.x - point1.x);
CGFloat yDist = (point2.y - point1.y);
return sqrt((xDist * xDist) + (yDist * yDist));
}

Si está usando cocos2d

float distance = ccpDistance(point1, point2);