Ustawianie poziomu powiększenia dla MKMapView

Mam mapę, która pokazuje się poprawnie, jedyne, co chcę teraz zrobić, to ustawić poziom powiększenia podczas ładowania. Czy jest na to sposób?

Dzięki

Znalazłem rozwiązanie, które jest bardzo proste i załatwia sprawę. Użyj MKCoordinateRegionMakeWithDistance, aby ustawić odległość w metrach w pionie i poziomie, aby uzyskać żądany zoom. A potem, oczywiście, kiedy zaktualizujesz swoją lokalizację, otrzymasz właściwe współrzędne lub możesz określić je bezpośrednio w CLLocationCoordinate2Dprzy starcie, jeśli to jest to, co musisz zrobić:

CLLocationCoordinate2D noLocation;
MKCoordinateRegion viewRegion = MKCoordinateRegionMakeWithDistance(noLocation, 500, 500);
MKCoordinateRegion adjustedRegion = [self.mapView regionThatFits:viewRegion];          
[self.mapView setRegion:adjustedRegion animated:YES];
self.mapView.showsUserLocation = YES;

Szybki:

let location = ...
let region = MKCoordinateRegion( center: location.coordinate, latitudinalMeters: CLLocationDistance(exactly: 5000)!, longitudinalMeters: CLLocationDistance(exactly: 5000)!)
mapView.setRegion(mapView.regionThatFits(region), animated: true)

Biorąc pod uwagę fakt, że linie długości geograficznej są równomiernie oddalone od siebie w dowolnym punkcie mapy, istnieje bardzo prosta implementacja ustawiania centerCoordinate i zoomLevel:

@interface MKMapView (ZoomLevel)

@property (assign, nonatomic) NSUInteger zoomLevel;

- (void)setCenterCoordinate:(CLLocationCoordinate2D)centerCoordinate
                  zoomLevel:(NSUInteger)zoomLevel
                   animated:(BOOL)animated;

@end


@implementation MKMapView (ZoomLevel)

- (void)setZoomLevel:(NSUInteger)zoomLevel {
    [self setCenterCoordinate:self.centerCoordinate zoomLevel:zoomLevel animated:NO];
}

- (NSUInteger)zoomLevel {
    return log2(360 * ((self.frame.size.width/256) / self.region.span.longitudeDelta)) + 1;
}

- (void)setCenterCoordinate:(CLLocationCoordinate2D)centerCoordinate
zoomLevel:(NSUInteger)zoomLevel animated:(BOOL)animated {
    MKCoordinateSpan span = MKCoordinateSpanMake(0, 360/pow(2, zoomLevel)*self.frame.size.width/256);
    [self setRegion:MKCoordinateRegionMake(centerCoordinate, span) animated:animated];
}

@end

Nie jest wbudowany, ale widziałem / użyłem tego kodu. Pozwala to na użycie tego:

[mapView setCenterCoordinate:myCoord zoomLevel:13 animated:YES];

Uwaga: to nie jest mój kod, nie napisałem go, więc nie mogę tego przypisać

Możesz również powiększyć, używając MKCoordinateRegion i ustawiając jego deltę szerokości i długości geograficznej. Poniżej znajduje się krótkie odniesienie, a tutaj odniesienie do systemu iOS. Nie zrobi nic wymyślnego, ale powinien pozwolić ci ustawić powiększenie podczas rysowania mapy.

MKCoordinateRegion region;
region.center.latitude = {desired lat};
region.center.longitude = {desired lng};
region.span.latitudeDelta = 1;
region.span.longitudeDelta = 1;
mapView.region = region;

Edycja 1:

MKCoordinateRegion region;
region.center.latitude = {desired lat};
region.center.longitude = {desired lng};
region.span.latitudeDelta = 1;
region.span.longitudeDelta = 1;
region = [mapView regionThatFits:region];
[mapView setRegion:region animated:TRUE];

Prosta implementacja Swift, jeśli używasz gniazd.

@IBOutlet weak var mapView: MKMapView! {
    didSet {
        let noLocation = CLLocationCoordinate2D()
        let viewRegion = MKCoordinateRegionMakeWithDistance(noLocation, 500, 500)
        self.mapView.setRegion(viewRegion, animated: false)
    }
}

Na podstawie odpowiedzi @ Carnal.

Szybka realizacja

import Foundation
import MapKit

class MapViewWithZoom: MKMapView {

    var zoomLevel: Int {
        get {
            return Int(log2(360 * (Double(self.frame.size.width/256) / self.region.span.longitudeDelta)) + 1);
        }

        set (newZoomLevel){
            setCenterCoordinate(coordinate:self.centerCoordinate, zoomLevel: newZoomLevel, animated: false)
        }
    }

    private func setCenterCoordinate(coordinate: CLLocationCoordinate2D, zoomLevel: Int, animated: Bool) {
        let span = MKCoordinateSpan(latitudeDelta: 0, longitudeDelta: 360 / pow(2, Double(zoomLevel)) * Double(self.frame.size.width) / 256)
        setRegion(MKCoordinateRegion(center: coordinate, span: span), animated: animated)
    }
}

W przypadku Swift 3 jest dość szybko do przodu:

private func setMapRegion(for location: CLLocationCoordinate2D, animated: Bool)
{
    let viewRegion = MKCoordinateRegionMakeWithDistance(location, <#T##latitudinalMeters: CLLocationDistance##CLLocationDistance#>, <#T##longitudinalMeters: CLLocationDistance##CLLocationDistance#>)
    MapView.setRegion(viewRegion, animated: animated)
}

Wystarczy zdefiniować szerokość i długość metrów, <CLLocationDistance>a mapView dopasuje poziom powiększenia do Twoich wartości.

Na podstawie świetnej odpowiedzi @ AdilSoomro . Wymyśliłem to:

@interface MKMapView (ZoomLevel)
- (void)setCenterCoordinate:(CLLocationCoordinate2D)centerCoordinate
                  zoomLevel:(NSUInteger)zoomLevel
                   animated:(BOOL)animated;

-(double) getZoomLevel;
@end



@implementation MKMapView (ZoomLevel)

- (void)setCenterCoordinate:(CLLocationCoordinate2D)centerCoordinate
                  zoomLevel:(NSUInteger)zoomLevel animated:(BOOL)animated {
    MKCoordinateSpan span = MKCoordinateSpanMake(0, 360/pow(2, zoomLevel)*self.frame.size.width/256);
    [self setRegion:MKCoordinateRegionMake(centerCoordinate, span) animated:animated];
}


-(double) getZoomLevel {
    return log2(360 * ((self.frame.size.width/256) / self.region.span.longitudeDelta));
}

@end

Mam nadzieję, że poniższy fragment kodu Ci pomoże.

- (void)handleZoomOutAction:(id)sender {
    MKCoordinateRegion newRegion=MKCoordinateRegionMake(mapView.region.center,MKCoordinateSpanMake(mapView.region.s       pan.latitudeDelta/0.5, mapView.region.span.longitudeDelta/0.5));
    [mapView setRegion:newRegion];
}


- (void)handleZoomInAction:(id)sender {
    MKCoordinateRegion newRegion=MKCoordinateRegionMake(mapView.region.center,MKCoordinateSpanMake(mapView.region.span.latitudeDelta*0.5, mapView.region.span.longitudeDelta*0.5));
    [mapView setRegion:newRegion];
}

Możesz wybrać dowolną wartość zamiast 0,5, aby zmniejszyć lub zwiększyć poziom powiększenia. Użyłem tych metod po kliknięciu dwóch przycisków.

Odpowiedź Swift 2.0 wykorzystująca NSUserDefaults do zapisywania i przywracania powiększenia i pozycji mapy.

Funkcja zapisywania pozycji mapy i powiększania:

func saveMapRegion() {
    let mapRegion = [
        "latitude" : mapView.region.center.latitude,
        "longitude" : mapView.region.center.longitude,
        "latitudeDelta" : mapView.region.span.latitudeDelta,
        "longitudeDelta" : mapView.region.span.longitudeDelta
    ]
    NSUserDefaults.standardUserDefaults().setObject(mapRegion, forKey: "mapRegion")
}

Uruchom funkcję za każdym razem, gdy mapa jest przenoszona:

func mapView(mapView: MKMapView, regionDidChangeAnimated animated: Bool) 
{
        saveMapRegion();
}

Funkcja zapisywania powiększenia i pozycji mapy:

func restoreMapRegion() 
{
    if let mapRegion = NSUserDefaults.standardUserDefaults().objectForKey("mapRegion") 
    {

        let longitude = mapRegion["longitude"] as! CLLocationDegrees
        let latitude = mapRegion["latitude"] as! CLLocationDegrees
        let center = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)

        let longitudeDelta = mapRegion["latitudeDelta"] as! CLLocationDegrees
        let latitudeDelta = mapRegion["longitudeDelta"] as! CLLocationDegrees
        let span = MKCoordinateSpan(latitudeDelta: latitudeDelta, longitudeDelta: longitudeDelta)

        let savedRegion = MKCoordinateRegion(center: center, span: span)

        self.mapView.setRegion(savedRegion, animated: false)
    }
}

Dodaj to do widokuDidLoad:

restoreMapRegion()

Wiem, że to spóźniona odpowiedź, ale po prostu chciałem sam rozwiązać problem ustawiania poziomu powiększenia. Odpowiedź goldmine jest świetna, ale okazało się, że nie działa wystarczająco dobrze w mojej aplikacji.

Przy bliższym przyjrzeniu się Goldmine stwierdza, że ​​„linie długości geograficznej są równomiernie oddalone od siebie w każdym punkcie mapy”. To nieprawda, w rzeczywistości są to linie szerokości geograficznej rozmieszczone w równych odstępach od -90 (biegun południowy) do +90 (biegun północny). Linie długości geograficznej są rozmieszczone w najszerszych odstępach na równiku, zbiegając się do punktu na biegunach.

Wdrożenie, które przyjąłem, polega zatem na zastosowaniu obliczenia szerokości geograficznej w następujący sposób:

@implementation MKMapView (ZoomLevel)

- (void)setCenterCoordinate:(CLLocationCoordinate2D)coordinate
    zoomLevel:(NSUInteger)zoom animated:(BOOL)animated
{
    MKCoordinateSpan span = MKCoordinateSpanMake(180 / pow(2, zoom) * 
        self.frame.size.height / 256, 0);
    [self setRegion:MKCoordinateRegionMake(coordinate, span) animated:animated];
}

@end

Mam nadzieję, że to pomoże na tak późnym etapie.

Szybki:

Map.setRegion(MKCoordinateRegion(center: locValue, latitudinalMeters: 200, longitudinalMeters: 200), animated: true)

locValue to Twoje współrzędne.

Tutaj umieściłem moją odpowiedź i działa na szybkie 4.2 .

MKMapWyświetl centrum i powiększ

Na podstawie odpowiedzi quentinadama

Swift 5.1

// size refers to the width/height of your tile images, by default is 256.0
// Seems to get better results using round()
// frame.width is the width of the MKMapView

let zoom = round(log2(360 * Double(frame.width) / size / region.span.longitudeDelta))

MKMapViewrozszerzenie oparte na tej odpowiedzi (+ dokładność powiększenia zmiennoprzecinkowego):

import Foundation
import MapKit

extension MKMapView {
    var zoomLevel: Double {
        get {
            return log2(360 * (Double(self.frame.size.width / 256) / self.region.span.longitudeDelta)) + 1
        }

        set (newZoomLevel){
            setCenterCoordinate(coordinate:self.centerCoordinate, zoomLevel: newZoomLevel, animated: false)
        }
    }

    private func setCenterCoordinate(coordinate: CLLocationCoordinate2D, zoomLevel: Double, animated: Bool) {
        let span = MKCoordinateSpan(latitudeDelta: 0, longitudeDelta: 360 / pow(2, zoomLevel) * Double(self.frame.size.width) / 256)
        setRegion(MKCoordinateRegion(center: coordinate, span: span), animated: animated)
    }
}