Anzeige MKMapViewAnnotations innerhalb einer Kartenansicht sichtbar-rect

Einstellung der Karte die region, so dass alle Anmerkungen enthalten sind, in einem bestimmten Teil eines MKMapView erfolgt in drei Schritten. Input sind die mapView und die annotationsFrame.

1. Berechnen MKMapRect mapRect enthält alle Anmerkungen.
2. Berechnen Sie die Polsterung-Einsätze aus mapView.bounds und annotationsFrame.
3. Nennen -setVisibleMapRect:edgePadding:animated: auf der Karte anzeigen lassen.

Unten ist ein Screenshot von einem test. Die roten overlay zeigt die annotationsFrame.

Hier ist der code. Vorsicht: Es ist alles in eine Methode zu vereinfachen, indem es Ihr code, und es ist nicht geprüft für Grenzfälle wie an in n Anmerkungen mit den gleichen Koordinaten, oder die Anmerkungen, die so weit auseinander, dass die Karte müsste vergrößert zu viel, oder mit den Koordinaten, die sich über den Rand der Karte auf +/-180 Grad Länge.

- (void)zoomAnnotationsOnMapView:(MKMapView *)mapView toFrame:(CGRect)annotationsFrame animated:(BOOL)animated
{
    if (_mapView.annotations.count < 2) return;


    //Step 1: make an MKMapRect that contains all the annotations

    NSArray *annotations = _mapView.annotations;

    id <MKAnnotation> firstAnnotation = [annotations objectAtIndex:0];
    MKMapPoint minPoint = MKMapPointForCoordinate(firstAnnotation.coordinate);
    MKMapPoint maxPoint = minPoint;

    for (id <MKAnnotation> annotation in annotations) {
        MKMapPoint point = MKMapPointForCoordinate(annotation.coordinate);
        if (point.x < minPoint.x) minPoint.x = point.x;
        if (point.y < minPoint.y) minPoint.y = point.y;
        if (point.x > maxPoint.x) maxPoint.x = point.x;
        if (point.y > maxPoint.y) maxPoint.y = point.y;
    }

    MKMapRect mapRect = MKMapRectMake(minPoint.x, minPoint.y, maxPoint.x - minPoint.x, maxPoint.y - minPoint.y);


    //Step 2: Calculate the edge padding

    UIEdgeInsets edgePadding = UIEdgeInsetsMake(
        CGRectGetMinY(annotationsFrame),
        CGRectGetMinX(annotationsFrame),
        CGRectGetMaxY(mapBounds) - CGRectGetMaxY(annotationsFrame),
        CGRectGetMaxX(mapBounds) - CGRectGetMaxX(annotationsFrame)
    );


    //Step 3: Set the map rect

    [mapView setVisibleMapRect:mapRect edgePadding:edgePadding animated:animated];
}

Wenn Sie gehen für eine perfekte Platzierung (und wer nicht), hier sind drei Dinge zu beachten:

1. Der code sorgt dafür, dass alle Koordinaten sind in der annotationsFrame, aber die Anmerkungen, die sich möglicherweise außerhalb. Um das zu verhindern, verwenden Sie einfach mehr Polsterung. Zum Beispiel, wenn Sie Ihre Anmerkungen sind 20x20 und zentriert auf die Koordinaten, die Verwendung 10 mehr Polsterung auf allen Seiten.
2. Unter iOS 7, wurde die Karte nicht Zoomen, um die perfekte zoom-Skala, sondern auf die nächsten Kacheln (Potenz von zwei). Es wird also noch mehr Raum rund um die Anmerkungen als nötig, nur, wie auf dem screenshot.
3. Auf iOS 7, die Karte nicht nur zoom perfekt, aber automatisch über die Pflege der Statusleiste. Um die Berechnung korrekt ist, müssen Sie subtrahieren Sie die status-bar Höhe von der oberen Polsterung auf iOS 7.

Wenn Sie bereit sind Ungefähre Berechnungen, die Sie tun können, es mit einigen cleveren Skalierung.

Ihre Ziel-Bereich ist 80 groß aus eine Kartenansicht, die ist 380. Daher, Sie wollen eine region, 4.75 x größer als die region berechnet, um zu passen Ihre Anmerkungen. (0.25 extra über-und 3,5-extra unten).

Erste, Sie brauchen, um eine region (oder maprect, was auch immer Sie bevorzugen arbeiten) und machen Sie die gleichen Proportionen, wie Sie Ihr Ziel nicht sichtbaren Bereich. Dies ist, weil eine wirklich Breite und kurze region nicht berühren die oberen und unteren Rand des sichtbaren Bereichs liegt und daher die Multiplikation Ihrer Höhe, nicht etwas, das berührt die Ober-und Unterseite der Karte anzeigen. Also, wenn viewable_height/viewable_width > annotations_height/annotations_width sollten Sie die annotations_height zu annotations_width * (viewable_height/viewable_width).

Mit, die Sie dann fügen Sie 25% auf den Norden der Anmerkungen-box und 350% auf den Süden. Sie können dies tun, durch verschieben der Mitte 212.5% (von der aktuellen Höhe) von Süden und die Erhöhung der vertikale Spannweite von 475%.

Nun, all dies ist eine Annäherung gegeben, dass die Welt ist die Sphäre, und wir sind nicht auf der Suche an einer planaren Projektion (d.h. 1 Breitengrad nahe dem äquator gezogen wird, die kleiner als 1 Grad in der Nähe der Pole). Aber wenn du wally wollen, um genau zu sein kann man sich in der Skalierung die zahlen je nach Breitengrad und solche. Wenn Sie nur den Umgang mit Annotationen auf eine Stadt-Größe skalieren, werden Sie wahrscheinlich ok.

Hoffe, das hilft.

Müssen Sie zunächst die Anmerkungen:
(natürlich ist dies, nachdem Sie bereits eine Liste der Anmerkungen)

Swift4:

    self.mapView.addAnnotations(annotations)
    let currentView = mapView.visibleMapRect
    mapView.annotations(in: currentView)

Können Sie die currentView-Konstante oder direkt Ort, der MKMapRect wie folgt: Unten: (.visibleMapRect gibt:

"Der Bereich aktuell angezeigten Kartenausschnitt."

mapView.annotations(in: mapView.visibleMapRect)

Versuchen, alle Ihre Anmerkungen Kanten Wert (max und min) für lan und lon.

Definieren Sie diesen Wert am Anfang:

static float maxLat = FLT_MIN;
static float maxLon = FLT_MIN;
static float minLat = FLT_MAX;
static float minLon = FLT_MAX;

und dann verwenden Sie diese Funktion, um zu berechnen erstrecken und region:

- (void) zoomAndFit {
    for(int i = 0; i < [self.points count]; i++) {
        PRPlaceModel *place = [self.points objectAtIndex:i];
        CLLocationCoordinate2D location; 
        location.latitude = [place.lat floatValue];
        location.longitude = [place.lon floatValue];
        minLat = MIN(minLat, location.latitude);
        minLon = MIN(minLon, location.longitude);
        maxLat = MAX(maxLat, location.latitude);
        maxLon = MAX(maxLon, location.longitude);
    }
    MKCoordinateRegion region; 
    MKCoordinateSpan span; 
    span.latitudeDelta = 1.2*(maxLat - minLat); 
    span.longitudeDelta = 1.2*(maxLon - minLon);

    CLLocationCoordinate2D location; 
    location.latitude = (minLat + maxLat)/2;
    location.longitude = (minLon + maxLon)/2;

    region.span=span; 
    region.center=location; 
    [self.mapView setRegion:region animated:TRUE]; 
    [self.mapView regionThatFits:region]; 
}

Verwendung in der viewDidLoad-Methode:

-(void)viewDidLoad
{
    [super viewDidLoad];
    [self zoomAndFit];
}