Bewegen ein CLLocation von x Metern

Dass die Umstellung auf Swift, entnommen diese Antwort:

func locationWithBearing(bearing:Double, distanceMeters:Double, origin:CLLocationCoordinate2D) -> CLLocationCoordinate2D {
    let distRadians = distanceMeters / (6372797.6) //earth radius in meters

    let lat1 = origin.latitude * M_PI / 180
    let lon1 = origin.longitude * M_PI / 180

    let lat2 = asin(sin(lat1) * cos(distRadians) + cos(lat1) * sin(distRadians) * cos(bearing))
    let lon2 = lon1 + atan2(sin(bearing) * sin(distRadians) * cos(lat1), cos(distRadians) - sin(lat1) * sin(lat2))

    return CLLocationCoordinate2D(latitude: lat2 * 180 / M_PI, longitude: lon2 * 180 / M_PI)
}

Morgan Chen schrieb:

Alle Mathematik, die in dieser Methode erfolgt im Bogenmaß. Zu Beginn des
Methode, lon1 und lat1 konvertiert Bogenmaß zu diesem Zweck als
gut. Lager ist im Bogenmaß zu. Denken Sie daran, diese Methode dauert in
Konto die Krümmung der Erde, die Sie nicht wirklich brauchen, zu tun
für kleine Entfernungen.

Verbesserten swift-Lösung zu Peters Antwort. Nur Korrektur der Haltung sollte radian während der Berechnung vorgenommen wurde.

 func locationWithBearing(bearing:Double, distanceMeters:Double, origin:CLLocationCoordinate2D) -> CLLocationCoordinate2D {
    let distRadians = distanceMeters / (6372797.6)

    var rbearing = bearing * M_PI / 180.0

    let lat1 = origin.latitude * M_PI / 180
    let lon1 = origin.longitude * M_PI / 180

    let lat2 = asin(sin(lat1) * cos(distRadians) + cos(lat1) * sin(distRadians) * cos(rbearing))
    let lon2 = lon1 + atan2(sin(rbearing) * sin(distRadians) * cos(lat1), cos(distRadians) - sin(lat1) * sin(lat2))

    return CLLocationCoordinate2D(latitude: lat2 * 180 / M_PI, longitude: lon2 * 180 / M_PI)
}

Rasche Umsetzung mit Measurement Struktur zu tun, die Umrechnungen zwischen Grad-und Bogenmaß.

class GPSLocation {

public class func degreesToRadians(degrees: Double) -> Double {
        return Measurement(value: degrees, unit: UnitAngle.degrees).converted(to: .radians).value
    }

    public class func radiansToDegrees(radians: Double) -> Double {
        return Measurement(value: radians, unit: UnitAngle.radians).converted(to: .degrees).value
    }

    public class func location(location: CLLocation, byMovingDistance distance: Double, withBearing bearingDegrees:CLLocationDirection) -> CLLocation {
        let distanceRadians: Double = distance / 6372797.6
        let bearingRadians: Double = GPSLocation.degreesToRadians(degrees: bearingDegrees)

        let lat1 = GPSLocation.degreesToRadians(degrees: location.coordinate.latitude)
        let lon1 = GPSLocation.degreesToRadians(degrees: location.coordinate.longitude)

        let lat2 = GPSLocation.radiansToDegrees(radians:asin(sin(lat1) * cos(distanceRadians) + cos(lat1) * sin(distanceRadians) * cos(bearingRadians)))
        let lon2 = GPSLocation.radiansToDegrees(radians:lon1 + atan2(sin(bearingRadians) * sin(distanceRadians * cos(lat1)), cos(distanceRadians) - sin(lat1) * sin(lat2)))

        return CLLocation(latitude: lat2, longitude: lon2)
    }

}

Swift 4.2 als CGPoint Erweiterung

Abgeleitet von Peter O. s-Lösung

Fließkomma-Erweiterung: Dank https://stackoverflow.com/a/29179878/2500428

extension FloatingPoint
{
    var degreesToRadians: Self { return self * .pi / 180 }
    var radiansToDegrees: Self { return self * 180 / .pi }
}

extension CGPoint
{
    //NOTE: bearing is in radians
    func locationWithBearing(bearing: Double, distanceMeters: Double) -> CGPoint
    {
        let distRadians = distanceMeters / (6372797.6) //earth radius in meters

        let origLat = Double(self.y.degreesToRadians)
        let origLon = Double(self.x.degreesToRadians)

        let newLat = asin(sin(origLat) * cos(distRadians) + cos(origLat) * sin(distRadians) * cos(bearing))
        let newLon = origLon + atan2(sin(bearing) * sin(distRadians) * cos(origLat), cos(distRadians) - sin(origLat) * sin(newLat))

        return CGPoint(x: newLon.radiansToDegrees, y: newLat.radiansToDegrees)
    }
}

Verwendung:

let loc = CGPoint(x: lon, y: lat)
let newLoc = loc.locationWithBearing(bearing: 90.degreesToRadians, distanceMeters: 500.0)

Seltsam, dass niemand daran gedacht, mit MKCoordinateRegion von MapKit das automatisch ausrechnen.

import MapKit

extension CLLocation {
    func movedBy(latitudinalMeters: CLLocationDistance, longitudinalMeters: CLLocationDistance) -> CLLocation {
        let region = MKCoordinateRegion(center: coordinate, latitudinalMeters: abs(latitudinalMeters), longitudinalMeters: abs(longitudinalMeters))

        let latitudeDelta = region.span.latitudeDelta
        let longitudeDelta = region.span.longitudeDelta

        let latitudialSign = CLLocationDistance(latitudinalMeters.sign == .minus ? -1 : 1)
        let longitudialSign = CLLocationDistance(longitudinalMeters.sign == .minus ? -1 : 1)

        let newLatitude = coordinate.latitude + latitudialSign * latitudeDelta
        let newLongitude = coordinate.longitude + longitudialSign * longitudeDelta

        let newCoordinate = CLLocationCoordinate2D(latitude: newLatitude, longitude: newLongitude)

        let newLocation = CLLocation(coordinate: newCoordinate, altitude: altitude, horizontalAccuracy: horizontalAccuracy, verticalAccuracy: verticalAccuracy, course: course, speed: speed, timestamp: Date())

        return newLocation
    }
}