Centrage de MKMapView sur spot n-pixels en dessous de la pin

la technique la plus simple est de simplement décaler la carte vers le bas, disons 40% d'où le coordinate serait, en profitant du span du region du MKMapView . Si vous n'avez pas besoin de pixels réels, mais juste besoin de se déplacer vers le bas de sorte que le CLLocationCoordinate2D en question Est près du haut de la carte (disons 10% loin du haut):

CLLocationCoordinate2D center = coordinate;
center.latitude -= self.mapView.region.span.latitudeDelta * 0.40;
[self.mapView setCenterCoordinate:center animated:YES];

si vous voulez tenir compte de la rotation et du Pas de la caméra, le ci-dessus la technique peut ne pas être suffisante. Dans ce cas, vous pouvez:

• identifiez la position dans la vue vers laquelle vous voulez déplacer l'emplacement de l'utilisateur;

• Convertissez cela en CLLocation ;

• calculer la distance entre l'emplacement actuel de l'utilisateur et le nouvel emplacement désiré;

• déplacer la caméra par cette distance dans la direction 180° du cap actuel de la caméra de la carte.

E. G. dans Swift 3, quelque chose comme:

var point = mapView.convert(mapView.centerCoordinate, toPointTo: view)
point.y -= offset
let coordinate = mapView.convert(point, toCoordinateFrom: view)
let offsetLocation = coordinate.location

let distance = mapView.centerCoordinate.location.distance(from: offsetLocation) / 1000.0

let camera = mapView.camera
let adjustedCenter = mapView.centerCoordinate.adjust(by: distance, at: camera.heading - 180.0)
camera.centerCoordinate = adjustedCenter

où CLLocationCoordinate2D a le suivant extension :

extension CLLocationCoordinate2D {
    var location: CLLocation {
        return CLLocation(latitude: latitude, longitude: longitude)
    }

    private func radians(from degrees: CLLocationDegrees) -> Double {
        return degrees * .pi / 180.0
    }

    private func degrees(from radians: Double) -> CLLocationDegrees {
        return radians * 180.0 / .pi
    }

    func adjust(by distance: CLLocationDistance, at bearing: CLLocationDegrees) -> CLLocationCoordinate2D {
        let distanceRadians = distance / 6_371.0   // 6,371 = Earth's radius in km
        let bearingRadians = radians(from: bearing)
        let fromLatRadians = radians(from: latitude)
        let fromLonRadians = radians(from: longitude)

        let toLatRadians = asin( sin(fromLatRadians) * cos(distanceRadians)
            + cos(fromLatRadians) * sin(distanceRadians) * cos(bearingRadians) )

        var toLonRadians = fromLonRadians + atan2(sin(bearingRadians)
            * sin(distanceRadians) * cos(fromLatRadians), cos(distanceRadians)
                - sin(fromLatRadians) * sin(toLatRadians))

        // adjust toLonRadians to be in the range -180 to +180...
        toLonRadians = fmod((toLonRadians + 3.0 * .pi), (2.0 * .pi)) - .pi

        let result = CLLocationCoordinate2D(latitude: degrees(from: toLatRadians), longitude: degrees(from: toLonRadians))

        return result
    }
}

ainsi, même avec la caméra pointée et à un cap autre que plein nord, cela déplace l'emplacement de l'utilisateur (qui est centré, où la ligne inférieure est) jusqu'à 150 pixels (où la ligne supérieure crosshair est), donnant quelque chose comme:

évidemment, vous devriez être conscient des situations dégénérées (par exemple, vous êtes à 1 km du pôle Sud et vous essayez de déplacer la carte jusqu'à 2 km mètres; vous utilisez un angle de caméra incliné si loin que l'emplacement de l'écran désiré est au-delà de l'horizon; etc.), mais pour des scénarios pratiques et réels, quelque chose comme ce qui précède pourrait suffire. Évidemment, si vous ne laissez pas l'utilisateur changer le ton de la caméra, la réponse est encore plus facile.

réponse originale: pour déplacer l'annotation n pixels

Si vous avez un CLLocationCoordinate2D , vous pouvez convertir en un CGPoint , le déplacer de x pixels et puis le reconvertir en un CLLocationCoordinate2D :

- (void)moveCenterByOffset:(CGPoint)offset from:(CLLocationCoordinate2D)coordinate
{
    CGPoint point = [self.mapView convertCoordinate:coordinate toPointToView:self.mapView];
    point.x += offset.x;
    point.y += offset.y;
    CLLocationCoordinate2D center = [self.mapView convertPoint:point toCoordinateFromView:self.mapView];
    [self.mapView setCenterCoordinate:center animated:YES];
}

vous pouvez l'appeler par:

[self moveCenterByOffset:CGPointMake(0, 100) from:coordinate];

malheureusement, cela ne fonctionne que si le coordinate est visible avant de commencer, donc vous pourriez avoir à aller à la coordonnée originale d'abord, puis ajuster le centre.