Centrando MKMapView en el punto N-pixels debajo del pin

La técnica más fácil es simplemente desplazar el mapa hacia abajo, digamos un 40% desde donde estaría el coordinate, aprovechando el span del region del MKMapView. Si no necesita píxeles reales, pero solo necesita que se mueva hacia abajo para que el CLLocationCoordinate2D en cuestión esté cerca de la parte superior del mapa (digamos un 10% lejos de la parte superior):

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

Si desea tener en cuenta la rotación y el tono de la cámara, la técnica anterior puede no ser adecuada. En ese caso, usted podría:

• Identificar el posición en la vista a la que desea cambiar la ubicación del usuario;

• Convertir eso en un CLLocation;

• Calcule la distancia de la ubicación del usuario actual desde esa nueva ubicación deseada;

• Mueva la cámara a esa distancia en la dirección 180° desde el rumbo actual de la cámara del mapa.

Por ejemplo, en Swift 3, algo como: {[19]]}

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

Donde CLLocationCoordinate2D tiene lo siguiente 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
    }
}

Así que, incluso con la cámara inclinada y en una dirección que no sea hacia el norte, esto mueve la ubicación del usuario (que está centrada, donde está el punto de mira inferior) hasta 150 píxeles (donde está el punto de mira superior), produciendo algo como:

Obviamente, debes ser consciente de las situaciones degeneradas (por ejemplo, estás a 1 km del polo sur y tratas de cambiar el mapa a 2 km de metros; estás usando un ángulo de cámara tan inclinado que la ubicación de la pantalla deseada está más allá del horizonte; etc.), pero para escenarios prácticos del mundo real, algo como lo anterior podría ser suficiente. Obviamente, si no dejas que el usuario cambie el tono de la cámara, la respuesta es aún más fácil.

Respuesta original: para mover la anotación n píxeles

Si tienes un CLLocationCoordinate2D, puedes convertirlo a un CGPoint, moverlo x píxeles, y luego convertirlo de nuevo a 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];
}

Puede llamar a esto por:

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

Desafortunadamente, esto solo funciona si el coordinate es visible antes de comenzar, por lo que es posible que tenga que ir a la coordenada original primero, y luego ajustar el centro.