Zoom MKMapView para encheckboxr os pinos de anotação?

Eu estou usando o MKMapView e adicionei um número de pinos de anotação ao mapa sobre uma área de 5-10 km. Quando executo o aplicativo meu mapa começa a diminuir o zoom para mostrar o mundo inteiro, qual é a melhor maneira de ampliar o mapa para que os pinos se encaixem na visualização?

EDIT: Meu pensamento inicial seria usar MKCoordinateRegionMake e calcular o centro de coordenadas, longitudeDelta e latitudeDelta de minhas annotations. Tenho certeza que isso vai funcionar, mas eu só queria verificar se não estava faltando nada óbvio.

Código adicionado, BTW: FGLocation é uma class que está em conformidade com MKAnnotation , locationFake é um NSMutableArray desses objects. Comentários são sempre bem vindos ….

 - (MKCoordinateRegion)regionFromLocations { CLLocationCoordinate2D upper = [[locationFake objectAtIndex:0] coordinate]; CLLocationCoordinate2D lower = [[locationFake objectAtIndex:0] coordinate]; // FIND LIMITS for(FGLocation *eachLocation in locationFake) { if([eachLocation coordinate].latitude > upper.latitude) upper.latitude = [eachLocation coordinate].latitude; if([eachLocation coordinate].latitude  upper.longitude) upper.longitude = [eachLocation coordinate].longitude; if([eachLocation coordinate].longitude < lower.longitude) lower.longitude = [eachLocation coordinate].longitude; } // FIND REGION MKCoordinateSpan locationSpan; locationSpan.latitudeDelta = upper.latitude - lower.latitude; locationSpan.longitudeDelta = upper.longitude - lower.longitude; CLLocationCoordinate2D locationCenter; locationCenter.latitude = (upper.latitude + lower.latitude) / 2; locationCenter.longitude = (upper.longitude + lower.longitude) / 2; MKCoordinateRegion region = MKCoordinateRegionMake(locationCenter, locationSpan); return region; } 

Você acertou.

Encontre suas latitudes e longitudes máximas e mínimas, aplique algumas aritméticas simples e use o MKCoordinateRegionMake .

Para iOS 7 e superior, use showAnnotations:animated: MKMapView.h em MKMapView.h :

 // Position the map such that the provided array of annotations are all visible to the fullest extent possible. - (void)showAnnotations:(NSArray *)annotations animated:(BOOL)animated NS_AVAILABLE(10_9, 7_0); 

Este é o que eu encontrei aqui que funcionou para mim:

(EDIT: Eu atualizei a solução usando a sugestão do @ Micah para aumentar o pointRect em 0.1 para garantir que o rect não seja infinitesimalmente pequeno!)

 MKMapRect zoomRect = MKMapRectNull; for (id  annotation in mapView.annotations) { MKMapPoint annotationPoint = MKMapPointForCoordinate(annotation.coordinate); MKMapRect pointRect = MKMapRectMake(annotationPoint.x, annotationPoint.y, 0.1, 0.1); zoomRect = MKMapRectUnion(zoomRect, pointRect); } [mapView setVisibleMapRect:zoomRect animated:YES]; 

Você também pode atualizar isso para include o pino userLocation substituindo a primeira linha por:

 MKMapPoint annotationPoint = MKMapPointForCoordinate(mapView.userLocation.coordinate); MKMapRect zoomRect = MKMapRectMake(annotationPoint.x, annotationPoint.y, 0.1, 0.1); 

A Apple adicionou um novo método para o IOS 7 para simplificar um pouco a vida.

 [mapView showAnnotations:yourAnnotationArray animated:YES]; 

Você pode extrair facilmente de uma matriz armazenada na exibição do mapa:

 yourAnnotationArray = mapView.annotations; 

e ajuste rapidamente a câmera também!

 mapView.camera.altitude *= 1.4; 

isso não funcionará a menos que o usuário tenha o iOS 7+ ou o OS X 10.9+ instalado. confira a animação personalizada aqui

Eu uso este código e funciona bem para mim:

 -(void)zoomToFitMapAnnotations:(MKMapView*)aMapView { if([aMapView.annotations count] == 0) return; CLLocationCoordinate2D topLeftCoord; topLeftCoord.latitude = -90; topLeftCoord.longitude = 180; CLLocationCoordinate2D bottomRightCoord; bottomRightCoord.latitude = 90; bottomRightCoord.longitude = -180; for(MapViewAnnotation *annotation in mapView.annotations) { topLeftCoord.longitude = fmin(topLeftCoord.longitude, annotation.coordinate.longitude); topLeftCoord.latitude = fmax(topLeftCoord.latitude, annotation.coordinate.latitude); bottomRightCoord.longitude = fmax(bottomRightCoord.longitude, annotation.coordinate.longitude); bottomRightCoord.latitude = fmin(bottomRightCoord.latitude, annotation.coordinate.latitude); } MKCoordinateRegion region; region.center.latitude = topLeftCoord.latitude - (topLeftCoord.latitude - bottomRightCoord.latitude) * 0.5; region.center.longitude = topLeftCoord.longitude + (bottomRightCoord.longitude - topLeftCoord.longitude) * 0.5; region.span.latitudeDelta = fabs(topLeftCoord.latitude - bottomRightCoord.latitude) * 1.1; // Add a little extra space on the sides region.span.longitudeDelta = fabs(bottomRightCoord.longitude - topLeftCoord.longitude) * 1.1; // Add a little extra space on the sides region = [aMapView regionThatFits:region]; [mapView setRegion:region animated:YES]; } 

No uso Swift

 mapView.showAnnotations(annotationArray, animated: true) 

No objective c

 [mapView showAnnotations:annotationArray animated:YES]; 

A solução do @jowie funciona muito bem. Uma pegadinha, se um mapa tiver apenas uma anotação, você terá um mapa totalmente reduzido. Eu adicionei 0.1 ao tamanho de make rect para garantir que setVisibleMapRect tenha algo para aplicar zoom.

 MKMapRect pointRect = MKMapRectMake(annotationPoint.x, annotationPoint.y, 0.1, 0.1); 

Eu converti a resposta de Rafael Moreira. O crédito vai para ele. Para aqueles que estão procurando a versão Swift, aqui está o código:

  func zoomToFitMapAnnotations(aMapView: MKMapView) { guard aMapView.annotations.count > 0 else { return } var topLeftCoord: CLLocationCoordinate2D = CLLocationCoordinate2D() topLeftCoord.latitude = -90 topLeftCoord.longitude = 180 var bottomRightCoord: CLLocationCoordinate2D = CLLocationCoordinate2D() bottomRightCoord.latitude = 90 bottomRightCoord.longitude = -180 for annotation: MKAnnotation in myMap.annotations as! [MKAnnotation]{ topLeftCoord.longitude = fmin(topLeftCoord.longitude, annotation.coordinate.longitude) topLeftCoord.latitude = fmax(topLeftCoord.latitude, annotation.coordinate.latitude) bottomRightCoord.longitude = fmax(bottomRightCoord.longitude, annotation.coordinate.longitude) bottomRightCoord.latitude = fmin(bottomRightCoord.latitude, annotation.coordinate.latitude) } var region: MKCoordinateRegion = MKCoordinateRegion() region.center.latitude = topLeftCoord.latitude - (topLeftCoord.latitude - bottomRightCoord.latitude) * 0.5 region.center.longitude = topLeftCoord.longitude + (bottomRightCoord.longitude - topLeftCoord.longitude) * 0.5 region.span.latitudeDelta = fabs(topLeftCoord.latitude - bottomRightCoord.latitude) * 1.4 region.span.longitudeDelta = fabs(bottomRightCoord.longitude - topLeftCoord.longitude) * 1.4 region = aMapView.regionThatFits(region) myMap.setRegion(region, animated: true) } 

Se você está procurando pelo iOS 8 e acima , a maneira mais simples de fazer isso é configurar o var layoutMargins: UIEdgeInsets { get set } da sua visualização de mapa antes de chamar func showAnnotations(annotations: [MKAnnotation], animated: Bool)

Por exemplo (Swift 2.1):

 @IBOutlet weak var map: MKMapView! { didSet { map.delegate = self map.mapType = .Standard map.pitchEnabled = false map.rotateEnabled = false map.scrollEnabled = true map.zoomEnabled = true } } // call 'updateView()' when viewWillAppear or whenever you set the map annotations func updateView() { map.layoutMargins = UIEdgeInsets(top: 25, left: 25, bottom: 25, right: 25) map.showAnnotations(map.annotations, animated: true) } 

Swift 3 Esta é a maneira correta de ajustar todas as annotations no mapa.

 func zoomMapaFitAnnotations() { var zoomRect = MKMapRectNull for annotation in mapview.annotations { let annotationPoint = MKMapPointForCoordinate(annotation.coordinate) let pointRect = MKMapRectMake(annotationPoint.x, annotationPoint.y, 0, 0) if (MKMapRectIsNull(zoomRect)) { zoomRect = pointRect } else { zoomRect = MKMapRectUnion(zoomRect, pointRect) } } self.mapview.setVisibleMapRect(zoomRect, edgePadding: UIEdgeInsetsMake(50, 50, 50, 50), animated: true) } 

Adicionado este loop If dentro do loop for para excluir o pino de localização dos usuários deste método (necessário no meu caso, e talvez outros)

 if (![annotation isKindOfClass:[MKUserLocation class]] ) { //Code Here... } 

Para o iOS 7 e superior (referindo-se ao MKMapView.h):

 // Position the map such that the provided array of annotations are all visible to the fullest extent possible. - (void)showAnnotations:(NSArray *)annotations animated:(BOOL)animated NS_AVAILABLE(10_9, 7_0); 

observação de – Abhishek Bedi

Você acabou de ligar:

  [yourMapView showAnnotations:@[yourAnnotation] animated:YES]; 

Eu criei uma extensão para mostrar todas as annotations usando algum código daqui e de lá rapidamente. Isso não mostrará todas as annotations se elas não puderem ser exibidas, mesmo no nível máximo de zoom.

 import MapKit extension MKMapView { func fitAllAnnotations() { var zoomRect = MKMapRectNull; for annotation in annotations { let annotationPoint = MKMapPointForCoordinate(annotation.coordinate) let pointRect = MKMapRectMake(annotationPoint.x, annotationPoint.y, 0.1, 0.1); zoomRect = MKMapRectUnion(zoomRect, pointRect); } setVisibleMapRect(zoomRect, edgePadding: UIEdgeInsetsMake(20, 20, 20, 20), animated: true) } } 

Em Swift

  var zoomRect = MKMapRectNull; for i in 0.. 

Graças a jowie eu atualizei minha antiga categoria para uma solução mais elegante. Compartilhamento completo, quase copiar e colar solução pronta

MKMapView + AnnotationsRegion.h

 #import  @interface MKMapView (AnnotationsRegion) -(void)updateRegionForCurrentAnnotationsAnimated:(BOOL)animated; -(void)updateRegionForCurrentAnnotationsAnimated:(BOOL)animated edgePadding:(UIEdgeInsets)edgePadding; -(void)updateRegionForAnnotations:(NSArray *)annotations animated:(BOOL)animated; -(void)updateRegionForAnnotations:(NSArray *)annotations animated:(BOOL)animated edgePadding:(UIEdgeInsets)edgePadding; @end 

MKMapView + AnnotationsRegion.m

 #import "MKMapView+AnnotationsRegion.h" @implementation MKMapView (AnnotationsRegion) -(void)updateRegionForCurrentAnnotationsAnimated:(BOOL)animated{ [self updateRegionForCurrentAnnotationsAnimated:animated edgePadding:UIEdgeInsetsZero]; } -(void)updateRegionForCurrentAnnotationsAnimated:(BOOL)animated edgePadding:(UIEdgeInsets)edgePadding{ [self updateRegionForAnnotations:self.annotations animated:animated edgePadding:edgePadding]; } -(void)updateRegionForAnnotations:(NSArray *)annotations animated:(BOOL)animated{ [self updateRegionForAnnotations:annotations animated:animated edgePadding:UIEdgeInsetsZero]; } -(void)updateRegionForAnnotations:(NSArray *)annotations animated:(BOOL)animated edgePadding:(UIEdgeInsets)edgePadding{ MKMapRect zoomRect = MKMapRectNull; for(id annotation in annotations){ MKMapPoint annotationPoint = MKMapPointForCoordinate(annotation.coordinate); MKMapRect pointRect = MKMapRectMake(annotationPoint.x, annotationPoint.y, 0.1, 0.1); zoomRect = MKMapRectUnion(zoomRect, pointRect); } [self setVisibleMapRect:zoomRect edgePadding:edgePadding animated:animated]; } @end 

Espero que ajude alguém e obrigado novamente jowie!

  - (void)zoomMapViewToFitAnnotationsWithExtraZoomToAdjust:(double)extraZoom { if ([self.annotations count] == 0) return; int i = 0; MKMapPoint points[[self.annotations count]]; for (id annotation in [self annotations]) { points[i++] = MKMapPointForCoordinate(annotation.coordinate); } MKPolygon *poly = [MKPolygon polygonWithPoints:points count:i]; MKCoordinateRegion r = MKCoordinateRegionForMapRect([poly boundingMapRect]); r.span.latitudeDelta += extraZoom; r.span.longitudeDelta += extraZoom; [self setRegion: r animated:YES]; } 

Como Abhishek Bedi aponta em um comentário, para iOS7 encaminhar a melhor maneira de fazer isso é:

 //from API docs: //- (void)showAnnotations:(NSArray *)annotations animated:(BOOL)animated NS_AVAILABLE(10_9, 7_0); [self.mapView showAnnotations:self.mapView.annotations animated:YES]; 

Para meu projeto pessoal (anterior ao iOS7), simplesmente adicionei uma categoria na class MKMapView para encapsular a funcionalidade “área visível” para uma operação muito comum: defini-la para poder ver todas as annotations atualmente carregadas na instância MKMapView ( isso inclui quantos pinos você tiver colocado, bem como a localização do usuário). o resultado foi este:

arquivo .h

 #import  @interface MKMapView (Extensions) -(void)ij_setVisibleRectToFitAllLoadedAnnotationsAnimated:(BOOL)animated; -(void)ij_setVisibleRectToFitAnnotations:(NSArray *)annotations animated:(BOOL)animated; @end 

arquivo .m

 #import "MKMapView+Extensions.h" @implementation MKMapView (Extensions) /** * Changes the currently visible portion of the map to a region that best fits all the currently loadded annotations on the map, and it optionally animates the change. * * @param animated is the change should be perfomed with an animation. */ -(void)ij_setVisibleRectToFitAllLoadedAnnotationsAnimated:(BOOL)animated { MKMapView * mapView = self; NSArray * annotations = mapView.annotations; [self ij_setVisibleRectToFitAnnotations:annotations animated:animated]; } /** * Changes the currently visible portion of the map to a region that best fits the provided annotations array, and it optionally animates the change. All elements from the array must conform to the  protocol in order to fetch the coordinates to compute the visible region of the map. * * @param annotations an array of elements conforming to the  protocol, holding the locations for which the visible portion of the map will be set. * @param animated wether or not the change should be perfomed with an animation. */ -(void)ij_setVisibleRectToFitAnnotations:(NSArray *)annotations animated:(BOOL)animated { MKMapView * mapView = self; MKMapRect r = MKMapRectNull; for (id a in annotations) { ZAssert([a conformsToProtocol:@protocol(MKAnnotation)], @"ERROR: All elements of the array MUST conform to the MKAnnotation protocol. Element (%@) did not fulfill this requirement", a); MKMapPoint p = MKMapPointForCoordinate(a.coordinate); //MKMapRectUnion performs the union between 2 rects, returning a bigger rect containing both (or just one if the other is null). here we do it for rects without a size (points) r = MKMapRectUnion(r, MKMapRectMake(px, py, 0, 0)); } [mapView setVisibleMapRect:r animated:animated]; } @end 

Como você pode ver, adicionei 2 methods até agora: um para definir a região visível do mapa para a que cabe em todas as annotations atualmente carregadas na instância do MKMapView e outro método para defini-la em qualquer matriz de objects. Então, para definir a região visível do mapView, o código seria tão simples quanto:

  //the mapView instance [self.mapView ij_setVisibleRectToFitAllLoadedAnnotationsAnimated:animated]; 

Espero que ajude =)

  var zoomRect: MKMapRect = MKMapRectNull for annotation in mapView.annotations { let annotationPoint = MKMapPointForCoordinate(annotation.coordinate) let pointRect = MKMapRectMake(annotationPoint.x, annotationPoint.y, 0.1, 0.1) zoomRect = MKMapRectUnion(zoomRect, pointRect) } mapView.setVisibleMapRect(zoomRect, animated: true) 

Eu fiz uma pequena modificação do código de Rafael para a categoria MKMapView.

 - (void)zoomToFitMapAnnotations { if ([self.annotations count] == 0) return; CLLocationCoordinate2D topLeftCoord; topLeftCoord.latitude = -90; topLeftCoord.longitude = 180; CLLocationCoordinate2D bottomRightCoord; bottomRightCoord.latitude = 90; bottomRightCoord.longitude = -180; for (id  annotation in self.annotations) { topLeftCoord.longitude = fmin(topLeftCoord.longitude, annotation.coordinate.longitude); topLeftCoord.latitude = fmax(topLeftCoord.latitude, annotation.coordinate.latitude); bottomRightCoord.longitude = fmax(bottomRightCoord.longitude, annotation.coordinate.longitude); bottomRightCoord.latitude = fmin(bottomRightCoord.latitude, annotation.coordinate.latitude); } MKCoordinateRegion region; region.center.latitude = topLeftCoord.latitude - (topLeftCoord.latitude - bottomRightCoord.latitude) * 0.5; region.center.longitude = topLeftCoord.longitude + (bottomRightCoord.longitude - topLeftCoord.longitude) * 0.5; region.span.latitudeDelta = fabs(topLeftCoord.latitude - bottomRightCoord.latitude) * 1.1; // Add a little extra space on the sides region.span.longitudeDelta = fabs(bottomRightCoord.longitude - topLeftCoord.longitude) * 1.1; // Add a little extra space on the sides [self setRegion:[self regionThatFits:region] animated:YES]; } 

Todas as respostas nesta página assumem que o mapa ocupa a canvas cheia . Eu realmente tenho um display HUD (ou seja, botões espalhados na parte superior e inferior) que dão informações ontop do mapa .. e assim os algoritmos na página exibirão os pinos bem, mas alguns deles aparecerão sob os botões de exibição do HUD .

Minha solução amplia o mapa para exibir as annotations em um subconjunto da canvas e funciona para diferentes tamanhos de canvas (ou seja, 3,5 “vs 4,0” etc):

 // create a UIView placeholder and throw it on top of the original mapview // position the UIView to fit the maximum area not hidden by the HUD display buttons // add an *other* mapview in that uiview, // get the MKCoordinateRegion that fits the pins from that fake mapview // kill the fake mapview and set the region of the original map // to that MKCoordinateRegion. 

Aqui está o que eu fiz no código (nota: eu uso NSConstraints com alguns methods auxiliares para fazer o meu código funcionar em diferentes tamanhos de canvas .. enquanto o código é bastante legível .. minha resposta aqui explica melhor .. é basicamente o mesmo stream de trabalho: )

 // position smallerMap to fit available space // don't store this map, it will slow down things if we keep it hidden or even in memory [@[_smallerMapPlaceholder] mapObjectsApplyingBlock:^(UIView *view) { [view removeFromSuperview]; [view setTranslatesAutoresizingMaskIntoConstraints:NO]; [view setHidden:NO]; [self.view addSubview:view]; }]; NSDictionary *buttonBindingDict = @{ @"mapPlaceholder": _smallerMapPlaceholder}; NSArray *constraints = [@[@"V:|-225-[mapPlaceholder(>=50)]-176-|", @"|-40-[mapPlaceholder(< =240)]-40-|" ] mapObjectsUsingBlock:^id(NSString *formatString, NSUInteger idx){ return [NSLayoutConstraint constraintsWithVisualFormat:formatString options:0 metrics:nil views:buttonBindingDict]; }]; [self.view addConstraints:[constraints flattenArray]]; [self.view layoutIfNeeded]; MKMapView *smallerMap = [[MKMapView alloc] initWithFrame:self.smallerMapPlaceholder.frame]; [_smallerMapPlaceholder addSubview:smallerMap]; MKCoordinateRegion regionThatFits = [smallerMap getRegionThatFits:self.mapView.annotations]; [smallerMap removeFromSuperview]; smallerMap = nil; [_smallerMapPlaceholder setHidden:YES]; [self.mapView setRegion:regionThatFits animated:YES]; 

aqui está o código que pega a região que se encheckbox:

 - (MKCoordinateRegion)getRegionThatFits:(NSArray *)routes { MKCoordinateRegion region; CLLocationDegrees maxLat = -90.0; CLLocationDegrees maxLon = -180.0; CLLocationDegrees minLat = 90.0; CLLocationDegrees minLon = 180.0; for(int idx = 0; idx < routes.count; idx++) { CLLocation* currentLocation = [routes objectAtIndex:idx]; if(currentLocation.coordinate.latitude > maxLat) maxLat = currentLocation.coordinate.latitude; if(currentLocation.coordinate.latitude < minLat) minLat = currentLocation.coordinate.latitude; if(currentLocation.coordinate.longitude > maxLon) maxLon = currentLocation.coordinate.longitude; if(currentLocation.coordinate.longitude < minLon) minLon = currentLocation.coordinate.longitude; } region.center.latitude = (maxLat + minLat) / 2.0; region.center.longitude = (maxLon + minLon) / 2.0; region.span.latitudeDelta = 0.01; region.span.longitudeDelta = 0.01; region.span.latitudeDelta = ((maxLat - minLat)<0.0)?100.0:(maxLat - minLat); region.span.longitudeDelta = ((maxLon - minLon)<0.0)?100.0:(maxLon - minLon); MKCoordinateRegion regionThatFits = [self regionThatFits:region]; return regionThatFits; } 

Apenas compartilhando minhas observações sobre isso:

Se você estiver usando xCode> 6 com tamanhos “inferidos” para as canvass (consulte “métricas simuladas” no inspetor de arquivos) no storyboard, chamar

- (void)showAnnotations:(NSArray *)annotations animated:(BOOL)animated

O viewDidLoad resultará em um nível de zoom muito grande em iPhones com 4 polegadas, pois o layout do mapa ainda está no tamanho das canvass mais amplas do storyboard.

Você pode mover sua chamada para showAnnotations... para ver o viewDidAppear . Em seguida, o tamanho do mapa já foi ajustado para a canvas menor de um iPhone 4.

Alternativamente, altere o valor “inferido” no inspetor de arquivos em “métricas simuladas” para o iphone de 4 polegadas.

Com base nas respostas acima, você pode usar o método universal para aplicar zoom no mapa para ajustar todas as annotations e superposições ao mesmo tempo.

 -(MKMapRect)getZoomingRectOnMap:(MKMapView*)map toFitAllOverlays:(BOOL)overlays andAnnotations:(BOOL)annotations includeUserLocation:(BOOL)userLocation { if (!map) { return MKMapRectNull; } NSMutableArray* overlaysAndAnnotationsCoordinateArray = [[NSMutableArray alloc]init]; if (overlays) { for (id  overlay in map.overlays) { MKMapPoint overlayPoint = MKMapPointForCoordinate(overlay.coordinate); NSArray* coordinate = @[[NSNumber numberWithDouble:overlayPoint.x], [NSNumber numberWithDouble:overlayPoint.y]]; [overlaysAndAnnotationsCoordinateArray addObject:coordinate]; } } if (annotations) { for (id  annotation in map.annotations) { MKMapPoint annotationPoint = MKMapPointForCoordinate(annotation.coordinate); NSArray* coordinate = @[[NSNumber numberWithDouble:annotationPoint.x], [NSNumber numberWithDouble:annotationPoint.y]]; [overlaysAndAnnotationsCoordinateArray addObject:coordinate]; } } MKMapRect zoomRect = MKMapRectNull; if (userLocation) { MKMapPoint annotationPoint = MKMapPointForCoordinate(map.userLocation.coordinate); zoomRect = MKMapRectMake(annotationPoint.x, annotationPoint.y, 0.1, 0.1); } for (NSArray* coordinate in overlaysAndAnnotationsCoordinateArray) { MKMapRect pointRect = MKMapRectMake([coordinate[0] doubleValue], [coordinate[1] doubleValue], 0.1, 0.1); zoomRect = MKMapRectUnion(zoomRect, pointRect); } return zoomRect; } 

E depois:

 MKMapRect mapRect = [self getZoomingRectOnMap:mapView toFitAllOverlays:YES andAnnotations:YES includeUserLocation:NO]; [mapView setVisibleMapRect:mapRect edgePadding:UIEdgeInsetsMake(10.0, 10.0, 10.0, 10.0) animated:YES]; 

@ “Não tenho certeza se isso é por causa de alguns outros fatores na minha implementação, mas eu acho que o showAnnotations não faz um zoom / ajuste das annotations como a implementação manual faz, então eu fiquei com o manual um – Ted Avery 17 de abril às 0:35 ”

Eu tive o mesmo problema, mas tentei fazer showAnnotations duas vezes (como abaixo) e, por algum motivo, funcionou.

[mapView showAnnotations: yourAnnotationArray animado: YES]; [mapView showAnnotations: yourAnnotationArray animado: YES];

Uma maneira compatível com o iOS 7 é usar o seguinte. Primeiro, chame showAnnotation para obter um retângulo com todas as annotations. Depois crie e UIEdgeInset com uma inserção superior da altura do pino. Assim, você garante a exibição do pino inteiro no mapa.

 [self.mapView showAnnotations:self.mapView.annotations animated:YES]; MKMapRect rect = [self.mapView visibleMapRect]; UIEdgeInsets insets = UIEdgeInsetsMake(pinHeight, 0, 0, 0); [self.mapView setVisibleMapRect:rect edgePadding:insets animated:YES]; 

Coloque isso no seu código de acordo:

  - (void)mapView:(MKMapView *)mv didAddAnnotationViews:(NSArray *)views { id mp = [annotationView annotation]; MKCoordinateRegion region = MKCoordinateRegionMakeWithDistance([mp coordinate] ,250,250); [mv setRegion:region animated:YES]; }