Comment setRegion avec google maps sdk pour iOS?

Mise à JOUR:

L'original de la réponse ci-dessous est obsolète depuis la version 1.2 du SDK, vous pouvez maintenant utiliser le fitBounds: méthode de la GMSCameraUpdate classe:

https://developers.google.com/maps/documentation/ios/reference/interface_g_m_s_camera_update

---

Réponse originale à cette question:

La MKMapPoint type dans MapKit définit une projection 2D d'une carte. Bien que les valeurs réelles de la projection sont destinés à être opaques, elles sont équivalentes à des pixels au niveau de zoom de 20. Ceci peut être utilisé pour convertir des coordonnées lat/lon valeurs de pixels, et donc une échelle, et donc un niveau de zoom.

Commencer par définir les deux endroits qui précisent les limites de la région que vous souhaitez afficher. Ceux-ci pourraient être à l'opposé des coins de la boîte englobante, ou simplement à deux endroits, par exemple:

CLLocationCoordinate2D location1 = 
    CLLocationCoordinate2DMake(-33.8683, 151.2086); //Sydney
CLLocationCoordinate2D location2 = 
    CLLocationCoordinate2DMake(-31.9554, 115.8585); //Perth

Si vous avez plus de deux points que vous souhaitez inclure, vous pouvez calculer les limites d'eux-même. Cela peut aussi être fait en utilisant GMSCoordinateBounds, par exemple:

GMSCoordinateBounds* bounds =
    [[GMSCoordinateBounds alloc]
    initWithCoordinate: CLLocationCoordinate2DMake(-33.8683, 151.2086) //Sydney
    andCoordinate: CLLocationCoordinate2DMake(-31.9554, 115.8585)]; //Perth
bounds = [bounds including: 
    CLLocationCoordinate2DMake(-12.4667, 130.8333)]; //Darwin
CLLocationCoordinate2D location1 = bounds.southWest;
CLLocationCoordinate2D location2 = bounds.northEast;

Ensuite, vous avez besoin pour obtenir la taille de l'affichage de la carte dans les points. Vous pouvez utiliser ceci:

float mapViewWidth = _mapView.frame.size.width;
float mapViewHeight = _mapView.frame.size.height;

Mais qui ne fonctionne que si vous avez déjà créé la vue de la carte. Aussi, si vous utilisez l'exemple de code dans la guide de mise en route, l'image est réglée sur CGRectZero, comme la taille réelle sera fixée plus tard pour remplir l'écran. Dans ces cas, si vous êtes à la création d'un plein écran de la carte, alors vous pourriez vouloir quelque chose comme ceci:

float mapViewWidth = [UIScreen mainScreen].applicationFrame.size.width;
float mapViewHeight = [UIScreen mainScreen].applicationFrame.size.height;

Sinon, utilisez la taille qui vous êtes en train de créer votre plan avec vue.

Maintenant, vous avez l'info nécessaire pour calculer la position de la caméra:

MKMapPoint point1 = MKMapPointForCoordinate(location1);
MKMapPoint point2 = MKMapPointForCoordinate(location2);

MKMapPoint centrePoint = MKMapPointMake(
    (point1.x + point2.x) /2,
    (point1.y + point2.y) /2);
CLLocationCoordinate2D centreLocation = MKCoordinateForMapPoint(centrePoint);

double mapScaleWidth = mapViewWidth /fabs(point2.x - point1.x);
double mapScaleHeight = mapViewHeight /fabs(point2.y - point1.y);
double mapScale = MIN(mapScaleWidth, mapScaleHeight);

double zoomLevel = 20 + log2(mapScale);

GMSCameraPosition *camera = [GMSCameraPosition
    cameraWithLatitude: centreLocation.latitude
    longitude: centreLocation.longitude
    zoom: zoomLevel];

Vous pouvez ensuite initialiser l'affichage de la carte avec l'appareil photo, ou de l'ensemble de la carte pour cet appareil photo.

Pour que ce code compile, vous aurez besoin d'ajouter les MapKit cadre de votre projet, et puis aussi l'importer:

#import <MapKit/MapKit.h>

Noter que ce code ne gère pas les wrap-around si vos coordonnées s'étendent à travers la ligne de changement de date. Par exemple, si vous avez essayé d'utiliser ce code avec Tokyo et à Hawaii, au lieu d'afficher une zone du Pacifique, il va essayer d'afficher presque tout le monde. En mode portrait, il n'est pas possible de faire un zoom assez loin pour voir Hawaii sur la gauche et de Tokyo sur le droit, et donc la carte se termine centré sur l'Afrique avec aucun emplacement visible. Vous pourriez modifier le code ci-dessus pour gérer le wrap-around à la ligne de changement de date, si vous vouliez.

OriginalL'auteur Saxon Druce

Saxun Druce réponse est vraiment bon. Mais en plus, si vous voulez calculer un rayon à partir de n'importe quel emplacement, vous pouvez le faire avec le code suivant:

    CLLocationCoordinate2D center = CLLocationCoordinate2DMake([currentLocationLat doubleValue],[currentLocationLong doubleValue]);
float radius = 25*1000; //radius in meters (25km)

MKCoordinateRegion region = MKCoordinateRegionMakeWithDistance(center, radius*2, radius*2);

CLLocationCoordinate2D  northEast = CLLocationCoordinate2DMake(region.center.latitude - region.span.latitudeDelta/2, region.center.longitude - region.span.longitudeDelta/2);
CLLocationCoordinate2D  southWest = CLLocationCoordinate2DMake(region.center.latitude + region.span.latitudeDelta/2, region.center.longitude + region.span.longitudeDelta/2);

GMSCoordinateBounds* bounds = [[GMSCoordinateBounds alloc]
                               initWithCoordinate: northEast
                               andCoordinate: southWest];

OriginalL'auteur fellowworldcitizen

Je suis actuellement à l'aide de cette méthode.

auto.marqueurs est un dictionnaire avec des marqueurs stockées par un code d'emplacement, de soi.currentLocation est un CLLocation2D, et l'auto.mapView est un GMSMapView.

Les maths ici est de vérifier si pour correspondre à la taille de la largeur ou de la hauteur, puis un calcul de la zoom basée sur le fait que x1 /pow(2, zoom1) = x2 /pow(2, zoom2)", conduisant à zoom2 = log2(x2 * pow(2, auto.mapView.de la caméra.zoom) /x1).

- (void)fitMarkers
{
    if (2 > self.markers.count)
    {
        [self.mapView animateToCameraPosition:[GMSCameraPosition cameraWithTarget:self.currentLocation.coordinate zoom:kZoom]];

        return;
    }

    NSArray* markers = self.markers.allValues;

    GMSCoordinateBounds* markerBounds = [[GMSCoordinateBounds alloc] initWithCoordinate:((id<GMSMarker>)markers[0]).position andCoordinate:((id<GMSMarker>)markers[1]).position];

    for (id<GMSMarker> marker in markers)
    {
        markerBounds = [markerBounds including:marker.position];
    }

    //get marker bounds in points
    CGPoint markerBoundsTopLeft = [self.mapView.projection pointForCoordinate:CLLocationCoordinate2DMake(markerBounds.northEast.latitude, markerBounds.southWest.longitude)];
    CGPoint markerBoundsBottomRight = [self.mapView.projection pointForCoordinate:CLLocationCoordinate2DMake(markerBounds.southWest.latitude, markerBounds.northEast.longitude)];

    //get user location in points
    CGPoint currentLocation = [self.mapView.projection pointForCoordinate:self.currentLocation.coordinate];

    CGPoint markerBoundsCurrentLocationMaxDelta = CGPointMake(MAX(fabs(currentLocation.x - markerBoundsTopLeft.x), fabs(currentLocation.x - markerBoundsBottomRight.x)), MAX(fabs(currentLocation.y - markerBoundsTopLeft.y), fabs(currentLocation.y - markerBoundsBottomRight.y)));

    //the marker bounds centered on self.currentLocation
    CGSize centeredMarkerBoundsSize = CGSizeMake(2.0 * markerBoundsCurrentLocationMaxDelta.x, 2.0 * markerBoundsCurrentLocationMaxDelta.y);

    //inset the view bounds to fit markers
    CGSize insetViewBoundsSize = CGSizeMake(self.mapView.bounds.size.width - kMarkerSize /2.0 - kMarkerMargin, self.mapView.bounds.size.height - kMarkerSize /2.0 - kMarkerSize);

    CGFloat x1;
    CGFloat x2;

    //decide which axis to calculate the zoom level with by comparing the width/height ratios
    if (centeredMarkerBoundsSize.width /centeredMarkerBoundsSize.height > insetViewBoundsSize.width /insetViewBoundsSize.height)
    {
        x1 = centeredMarkerBoundsSize.width;
        x2 = insetViewBoundsSize.width;
    }
    else
    {
        x1 = centeredMarkerBoundsSize.height;
        x2 = insetViewBoundsSize.height;
    }

    CGFloat zoom = log2(x2 * pow(2, self.mapView.camera.zoom) /x1);

    GMSCameraPosition* camera = [GMSCameraPosition cameraWithTarget:self.currentLocation.coordinate zoom:zoom];

    [self.mapView animateToCameraPosition:camera];
}

OriginalL'auteur Stefan Fisk

J'ai recherché dans les fichiers d'en-tête du cadre et ne se trouve que l'interface qui pourrait être utilisé pour le code suivant qui pourrait être un début. Le problème ici est que je ne peux pas trouver toutes les importations de GMSCoordinateBounds dans l'une des autres en-têtes donc je ne peux pas trouver un moyen d'afficher cette région dans GMSMapView.

GMSVisibleRegion region;
region.farLeft = CLLocationCoordinate2DMake(farLeftLatitude, farLeftlongitude);
region.farRight = CLLocationCoordinate2DMake(farRightlatitude, farRightlongitude); 

GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] initWithRegion:region];

OriginalL'auteur Bohrnsen

//J'ai trouvé cette méthode qui a fonctionné pour moi

func setMapZoomToRadius(lat:Double, lng:Double, var mile:Double)
    {

        let center = CLLocationCoordinate2DMake(lat, lng)           
        let radius: Double = (mile ) * 621.371 

        let region = MKCoordinateRegionMakeWithDistance(center, radius * 2.0, radius * 2.0)


        let northEast = CLLocationCoordinate2DMake(region.center.latitude - region.span.latitudeDelta, region.center.longitude - region.span.longitudeDelta)
        let  southWest = CLLocationCoordinate2DMake(region.center.latitude + region.span.latitudeDelta, region.center.longitude + region.span.longitudeDelta)


        print("\(region.center.longitude)  \(region.span.longitudeDelta)")
        let bounds = GMSCoordinateBounds(coordinate: southWest, coordinate: northEast)

        let camera = googleMapView.cameraForBounds(bounds, insets:UIEdgeInsetsZero)
         googleMapView.camera = camera;

      }

OriginalL'auteur iOS Developer