Τοποθέτηση MKMapView να δείξει πολλούς σχολιασμούς ταυτόχρονα

Ο σύνδεσμος δημοσιεύτηκε από τον Jim είναι τώρα νεκρός, αλλά ήμουν σε θέση να βρει τον κωδικό (που είχα σελιδοδείκτες κάπου). Η ελπίδα αυτό βοηθά.

- (void)zoomToFitMapAnnotations:(MKMapView *)mapView { 
    if ([mapView.annotations count] == 0) return; 

    CLLocationCoordinate2D topLeftCoord; 
    topLeftCoord.latitude = -90; 
    topLeftCoord.longitude = 180; 

    CLLocationCoordinate2D bottomRightCoord; 
    bottomRightCoord.latitude = 90; 
    bottomRightCoord.longitude = -180; 

    for(id<MKAnnotation> 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;      

    // Add a little extra space on the sides
    region.span.latitudeDelta = fabs(topLeftCoord.latitude - bottomRightCoord.latitude) * 1.1;
    region.span.longitudeDelta = fabs(bottomRightCoord.longitude - topLeftCoord.longitude) * 1.1; 

    region = [mapView regionThatFits:region]; 
    [mapView setRegion:region animated:YES]; 
}

Γιατί τόσο περίπλοκο;

MKCoordinateRegion coordinateRegionForCoordinates(CLLocationCoordinate2D *coords, NSUInteger coordCount) {
    MKMapRect r = MKMapRectNull;
    for (NSUInteger i=0; i < coordCount; ++i) {
        MKMapPoint p = MKMapPointForCoordinate(coords[i]);
        r = MKMapRectUnion(r, MKMapRectMake(p.x, p.y, 0, 0));
    }
    return MKCoordinateRegionForMapRect(r);
}

Έχω κάνει κάτι παρόμοιο με αυτό σε σμίκρυνση (ή) σε μια περιοχή που περιλάμβανε ένα σημείο σχολιασμό και την τρέχουσα θέση. Θα μπορούσατε να επεκτείνετε αυτό με looping μέσα από σχολιασμούς σας.

Τα βασικά βήματα είναι τα εξής:

• Υπολογίστε το min γεωγραφικό πλάτος / μήκος
  
• Υπολογίστε το μέγιστο γεωγραφικό πλάτος / μήκος
  
• Δημιουργία CLLocation αντικείμενα για τα δύο αυτά σημεία
  
• Υπολογίστε απόσταση μεταξύ των σημείων
  
• Δημιουργία περιοχή χρησιμοποιώντας το κεντρικό σημείο μεταξύ των σημείων και την απόσταση μετατραπεί σε βαθμούς
  
• Περάστε περιοχή σε MapView για να ρυθμίσετε
  
• Χρησιμοποιήστε προσαρμοσμένη περιοχή για να ορίσετε την περιοχή MapView
  

    -(IBAction)zoomOut:(id)sender {

        CLLocationCoordinate2D southWest = _newLocation.coordinate;
        CLLocationCoordinate2D northEast = southWest;

        southWest.latitude = MIN(southWest.latitude, _annotation.coordinate.latitude);
        southWest.longitude = MIN(southWest.longitude, _annotation.coordinate.longitude);

        northEast.latitude = MAX(northEast.latitude, _annotation.coordinate.latitude);
        northEast.longitude = MAX(northEast.longitude, _annotation.coordinate.longitude);

        CLLocation *locSouthWest = [[CLLocation alloc] initWithLatitude:southWest.latitude longitude:southWest.longitude];
        CLLocation *locNorthEast = [[CLLocation alloc] initWithLatitude:northEast.latitude longitude:northEast.longitude];

        // This is a diag distance (if you wanted tighter you could do NE-NW or NE-SE)
        CLLocationDistance meters = [locSouthWest getDistanceFrom:locNorthEast];

        MKCoordinateRegion region;
        region.center.latitude = (southWest.latitude + northEast.latitude) / 2.0;
        region.center.longitude = (southWest.longitude + northEast.longitude) / 2.0;
        region.span.latitudeDelta = meters / 111319.5;
        region.span.longitudeDelta = 0.0;

        _savedRegion = [_mapView regionThatFits:region];
        [_mapView setRegion:_savedRegion animated:YES];

        [locSouthWest release];
        [locNorthEast release];
    }

Έχω μια διαφορετική απάντηση. Ήμουν έτοιμος να κάνει την υλοποίηση του αλγορίθμου zoom-to-fit τον εαυτό μου, αλλά εγώ κατάλαβα ότι η Apple θα πρέπει να έχουν έναν τρόπο να κάνουμε ό, τι θέλουμε, χωρίς πολύ δουλειά. Χρησιμοποιώντας το Doco API έδειξε γρήγορα ότι θα μπορούσα να χρησιμοποιήσω MKPolygon να κάνει ό, τι χρειάζεται:

/* this simply adds a single pin and zooms in on it nicely */
- (void) zoomToAnnotation:(MapAnnotation*)annotation {
    MKCoordinateSpan span = {0.027, 0.027};
    MKCoordinateRegion region = {[annotation coordinate], span};
    [mapView setRegion:region animated:YES];
}

/* This returns a rectangle bounding all of the pins within the supplied
   array */
- (MKMapRect) getMapRectUsingAnnotations:(NSArray*)theAnnotations {
    MKMapPoint points`theAnnotations count`;

    for (int i = 0; i < [theAnnotations count]; i++) {
        MapAnnotation *annotation = [theAnnotations objectAtIndex:i];
        points[i] = MKMapPointForCoordinate(annotation.coordinate);
    }

    MKPolygon *poly = [MKPolygon polygonWithPoints:points count:[theAnnotations count]];

    return [poly boundingMapRect];
}

/* this adds the provided annotation to the mapview object, zooming 
   as appropriate */
- (void) addMapAnnotationToMapView:(MapAnnotation*)annotation {
    if ([annotations count] == 1) {
        // If there is only one annotation then zoom into it.
        [self zoomToAnnotation:annotation];
    } else {
        // If there are several, then the default behaviour is to show all of them
        //
        MKCoordinateRegion region = MKCoordinateRegionForMapRect([self getMapRectUsingAnnotations:annotations]);

        if (region.span.latitudeDelta < 0.027) {
            region.span.latitudeDelta = 0.027;
        }

        if (region.span.longitudeDelta < 0.027) {
            region.span.longitudeDelta = 0.027;
        }
        [mapView setRegion:region];
    }

    [mapView addAnnotation:annotation];
    [mapView selectAnnotation:annotation animated:YES];
}

Η ελπίδα αυτό βοηθά.

μπορείτε να το κάνετε με αυτόν τον τρόπο ..

// Position the map so that all overlays and annotations are visible on screen.
MKMapRect regionToDisplay = [self mapRectForAnnotations:annotationsToDisplay];
if (!MKMapRectIsNull(regionToDisplay)) myMapView.visibleMapRect = regionToDisplay;

- (MKMapRect) mapRectForAnnotations:(NSArray*)annotationsArray
{
    MKMapRect mapRect = MKMapRectNull;

    //annotations is an array with all the annotations I want to display on the map
    for (id<MKAnnotation> annotation in annotations) { 

        MKMapPoint annotationPoint = MKMapPointForCoordinate(annotation.coordinate);
        MKMapRect pointRect = MKMapRectMake(annotationPoint.x, annotationPoint.y, 0, 0);

        if (MKMapRectIsNull(mapRect)) 
        {
            mapRect = pointRect;
        } else 
        {
            mapRect = MKMapRectUnion(mapRect, pointRect);
        }
    }

     return mapRect;
}

Με βάση τις πληροφορίες και προτάσεις από όλους ήρθα με τα ακόλουθα. Ευχαριστώ για όλους σε αυτή τη συζήτηση για τη συμβολή :) Αυτό θα πάει στο χειριστήριο προβολή που περιέχει το MapView.

- (void)zoomToFitMapAnnotations { 

if ([self.mapView.annotations count] == 0) return; 

int i = 0;
MKMapPoint points`self`.`mapView`.`annotations count`;

//build array of annotation points
for (id<MKAnnotation> annotation in [self.mapView annotations])
        points[i++] = MKMapPointForCoordinate(annotation.coordinate);

MKPolygon *poly = [MKPolygon polygonWithPoints:points count:i];

[self.mapView setRegion:MKCoordinateRegionForMapRect([poly boundingMapRect]) animated:YES]; 
}

Στην περίπτωσή μου, αρχίζω με τα αντικείμενα CLLocation και τη δημιουργία σχόλια για το καθένα από αυτά.
Το μόνο που πρέπει να τοποθετήσετε δύο σχολιασμούς, έτσι έχω μια απλή προσέγγιση για την κατασκευή του πίνακα των σημείων, αλλά θα μπορούσε εύκολα να επεκταθεί για να χτίσει έναν πίνακα με ένα αυθαίρετο μήκος δοθεί ένα σύνολο από CLLocations.

Εδώ είναι εφαρμογή μου (δεν απαιτεί τη δημιουργία MKMapPoints):

//start with a couple of locations
CLLocation *storeLocation = store.address.location.clLocation;
CLLocation *userLocation = [LBLocationController sharedController].currentLocation;

//build an array of points however you want
CLLocationCoordinate2D points[2] = {storeLocation.coordinate, userLocation.coordinate};

//the magic part
MKPolygon *poly = [MKPolygon polygonWithCoordinates:points count:2];
[self.mapView setRegion:MKCoordinateRegionForMapRect([poly boundingMapRect])];

Χρησιμοποιώντας Swift, ένα πολύγωνο, και κάποια επιπλέον padding χρησιμοποίησα τα εξής:

func zoomToFit() {
    var allLocations:[CLLocationCoordinate2D] = [
        CLLocationCoordinate2D(latitude: 32.768805, longitude: -117.167119),
        CLLocationCoordinate2D(latitude: 32.770480, longitude: -117.148385),
        CLLocationCoordinate2D(latitude: 32.869675, longitude: -117.212929)
    ]

    var poly:MKPolygon = MKPolygon(coordinates: &allLocations, count: allLocations.count)

    self.mapView.setVisibleMapRect(poly.boundingMapRect, edgePadding: UIEdgeInsetsMake(40.0, 40.0, 40.0, 40.0), animated: false)
}

Υπάρχει μια νέα μέθοδος «MKMapView» και του iOS 7 που μπορείτε να χρησιμοποιήσετε

Δήλωση

ΤΑΧΥΣ

func showAnnotations(_ annotations: [AnyObject]!,
            animated animated: Bool)

ΣΤΟΧΟΣ-C

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

Παράμετροι

σχολιασμοί Τα σχόλια που θέλετε να είναι ορατά στο χάρτη. κινούμενα ΝΑΙ αν θέλετε η αλλαγή του χάρτη την περιοχή που θα κινουμένων σχεδίων, ή ΟΧΙ αν θέλετε το χάρτη για να εμφανιστεί η νέα περιοχή αμέσως χωρίς κινούμενα σχέδια.

Συζήτηση

Κλήση αυτή τη μέθοδο ενημερώσεις η αξία του ακινήτου περιοχή και ενδεχομένως άλλες ιδιότητες ώστε να αντικατοπτρίζει τη νέα περιοχή του χάρτη.

Εδώ είναι το Ισοδύναμο SWIFT (Επιβεβαιωμένο Εργασία στο: Xcode6.1, SDK 8.2) για απαντήσεις Μουσταφά:

    func zoomToFitMapAnnotations() {
    if self.annotations.count == 0 {return}

    var topLeftCoordinate = CLLocationCoordinate2D(latitude: -90, longitude: 180)
    var bottomRightCoordinate = CLLocationCoordinate2D(latitude: 90, longitude: -180)

    var i = 1
    for object in self.annotations {
        if let annotation = object as? MKAnnotation {
            topLeftCoordinate.longitude = fmin(topLeftCoordinate.longitude, annotation.coordinate.longitude)
            topLeftCoordinate.latitude = fmin(topLeftCoordinate.latitude, annotation.coordinate.latitude)
            bottomRightCoordinate.longitude = fmin(bottomRightCoordinate.longitude, annotation.coordinate.longitude)
            bottomRightCoordinate.latitude = fmin(bottomRightCoordinate.latitude, annotation.coordinate.latitude)
        }
    }

    var center = CLLocationCoordinate2D(latitude: topLeftCoordinate.latitude - (topLeftCoordinate.latitude - bottomRightCoordinate.latitude) * 0.5, longitude: topLeftCoordinate.longitude - (topLeftCoordinate.longitude - bottomRightCoordinate.longitude) * 0.5)

    print("\ncenter:\(center.latitude) \(center.longitude)")
    // Add a little extra space on the sides
    var span = MKCoordinateSpanMake(fabs(topLeftCoordinate.latitude - bottomRightCoordinate.latitude) * 1.01, fabs(bottomRightCoordinate.longitude - topLeftCoordinate.longitude) * 1.01)
    print("\nspan:\(span.latitudeDelta) \(span.longitudeDelta)")

    var region = MKCoordinateRegion(center: center, span: span)


    region = self.regionThatFits(region)

    self.setRegion(region, animated: true)

}

Με βάση την άριστη απάντηση me2(τώρα Swift)

func coordinateRegionForCoordinates(coords: [CLLocationCoordinate2D]) -> MKCoordinateRegion {
    var rect: MKMapRect = MKMapRectNull
    for coord in coords {
        let point: MKMapPoint = MKMapPointForCoordinate(coord)
        rect = MKMapRectUnion(rect, MKMapRectMake(point.x, point.y, 0, 0))
    }
    return MKCoordinateRegionForMapRect(rect)
}

- (void)zoomToFitMapAnnotations {

if ([self.mapview.annotations count] == 0) return;

int i = 0;
MKMapPoint points`self`.`mapview`.`annotations count`;

//build array of annotation points
for (id<MKAnnotation> annotation in [self.mapview annotations])
    points[i++] = MKMapPointForCoordinate(annotation.coordinate);

MKPolygon *poly = [MKPolygon polygonWithPoints:points count:i];

[self.mapview setRegion:MKCoordinateRegionForMapRect([poly boundingMapRect]) animated:YES];
}

Μια πιθανή λύση θα μπορούσε να τη μέτρηση της απόστασης μεταξύ της τρέχουσας θέσης και όλους τους σχολιασμούς και με τη μέθοδο της MKCoordinateRegionMakeWithDistance να κάνει μια περιοχή που έχει μια ελαφρώς μεγαλύτερη απόσταση από το απώτατο σχολιασμό.

Αυτό θα μπορούσε φυσικά να πάρει πιο αργά τα περισσότερα σχόλια που έχετε προσθέσει όμως.

Ξέρω ότι αυτό είναι ένα παλιό θέμα, αλλά, αν θέλετε να εμφανίσετε όλες τις επισημειώσεις ήδη στο χάρτη χρησιμοποιήσετε αυτό:

 mapView.showAnnotations(mapView.annotations, animated: true)

Προστέθηκε λίγο, αν ρήτρα για να χειριστεί 1 location-να προσθέσετε κώδικα cound απόσπασμα mustufa του. Χρησιμοποιείται η λειτουργία zoomToAnnotation pkclSoft για τα εξής:

if ([mapView.annotations count] == 1){
    MKCoordinateSpan span = {0.027, 0.027};
    region.span = span;
    CLLocationCoordinate2D singleCoordinate = [[mapView.annotations objectAtIndex:0] coordinate];
    region.center.latitude = singleCoordinate.latitude;
    region.center.longitude = singleCoordinate.longitude;
}
else
{
    // mustufa's code
}

Η εσπευσμένη 5 έκδοση:

   func regionFor(coordinates coords: [CLLocationCoordinate2D]) -> MKCoordinateRegion {
        var r = MKMapRect.null

        for i in 0 ..< coords.count {
            let p = MKMapPoint(coords[i])

            r = r.union(MKMapRect(x: p.x, y: p.y, width: 0, height: 0))
        }

        return MKCoordinateRegion(r)
    }

Σκεφτείτε αυτής της επέκτασης:

extension MKCoordinateRegion {
    init(locations: [CLLocationCoordinate2D], marginMultiplier: Double = 1.1) {
        let mapRect = locations.reduce(MKMapRect(), {
            let point = MKMapPointForCoordinate($1)
            let rect = MKMapRect(origin: point, size: MKMapSize(width: 0.0, height: 0.0))
            return MKMapRectUnion($0, rect)
        })

        var coordinateRegion = MKCoordinateRegionForMapRect(mapRect)
        coordinateRegion.span.latitudeDelta *= marginMultiplier
        coordinateRegion.span.longitudeDelta *= marginMultiplier
        self = coordinateRegion
    }
}

αυτός ο κώδικας λειτουργεί για μένα, αυτό δείχνει όλες τις καρφίτσες με την τρέχουσα θέση, ότι αυτό σας βοηθά,

func setCenterForMap() {
    var mapRect: MKMapRect = MKMapRectNull
    for loc in mapView.annotations {
        let point: MKMapPoint = MKMapPointForCoordinate(loc.coordinate)
        print( "location is : \(loc.coordinate)");
        mapRect = MKMapRectUnion(mapRect, MKMapRectMake(point.x,point.y,0,0))
    }
    if (locationManager.location != nil) {
        let point: MKMapPoint = MKMapPointForCoordinate(locationManager.location!.coordinate)
        print( "Cur location is : \(locationManager.location!.coordinate)");
        mapRect = MKMapRectUnion(mapRect, MKMapRectMake(point.x,point.y,0,0))
    }

    mapView.setVisibleMapRect(mapRect, edgePadding: UIEdgeInsetsMake(40.0, 40.0, 40.0, 40.0), animated: true)

}

Επειδή δεν μπορώ να σχολιάσω μια απάντηση, θα ήθελα να προσθέσω λίγο μου ευκολίας στην @ ΜΕ2 «s απάντηση (αφού σκέφτηκα ότι ήταν η πιο κομψή προσέγγιση βρείτε εδώ).

Για την προσωπική μου έργο που απλώς προστίθεται μια κατηγορία από την κατηγορία MKMapView να ενσωματώσει τη λειτουργία «ορατή περιοχή» για μια κοινή επιχείρηση ver: ρύθμιση για να είναι σε θέση να δείτε όλες τις επί του παρόντος φορτωμένο σχολιασμούς στο παράδειγμα MKMapView. το αποτέλεσμα ήταν το εξής:

.h αρχείο

#import <MapKit/MapKit.h>

@interface MKMapView (Extensions)

-(void)ij_setVisibleRectToFitAllLoadedAnnotationsAnimated:(BOOL)animated;
-(void)ij_setVisibleRectToFitAnnotations:(NSArray *)annotations animated:(BOOL)animated;


@end

.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 <MKAnnotation> protocol in order to fetch the coordinates to compute the visible region of the map.
 *
 *  @param annotations an array of elements conforming to the <MKAnnotation> 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<MKAnnotation> 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(p.x, p.y, 0, 0));
    }

    [mapView setVisibleMapRect:r animated:animated];

}

@end

Όπως μπορείτε να δείτε, έχω προσθέσει 2 μεθόδους μέχρι σήμερα: ένα για τη ρύθμιση της ορατής περιοχής του χάρτη με εκείνο που ταιριάζει σε όλους σήμερα φορτωμένο σχολιασμούς στο παράδειγμα MKMapView, και μια άλλη μέθοδος για να το θέσετε σε οποιαδήποτε σειρά από αντικείμενα. Έτσι για να ρυθμίσετε ορατή περιοχή του MapView είναι ο κώδικας θα είναι τότε τόσο απλό:

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

Ελπίζω ότι αυτό βοηθά =)

Με βάση την απάντηση ΜΕ2 έγραψα μια κατηγορία για MKMapView να προσθέσετε κάποια περιθώρια και να παραλείψετε το χρήστη σχολιασμό θέση:

@interface MKMapView (ZoomToFitAnnotations)
- (void)zoomToFitAnnotations:(BOOL)animated;
@end

@implementation MKMapView (ZoomToFitAnnotations)
- (void)zoomToFitAnnotations:(BOOL)animated {
    if (self.annotations.count == 0)
        return;

    MKMapRect rect = MKMapRectNull;
    for (id<MKAnnotation> annotation in self.annotations) {
        if ([annotation isKindOfClass:[MKUserLocation class]] == false) {
            MKMapPoint point = MKMapPointForCoordinate(annotation.coordinate);
            rect = MKMapRectUnion(rect, MKMapRectMake(point.x, point.y, 0, 0));
        }
    }

    MKCoordinateRegion region = MKCoordinateRegionForMapRect(rect);
    region.span.longitudeDelta *= 2; // Margin
    region.span.latitudeDelta *= 2; // Margin
    [self setRegion:region animated:animated];
}
@end

CLLocationCoordinate2D min = CLLocationCoordinate2DMake(99999.0, 99999.0);
CLLocationCoordinate2D max = CLLocationCoordinate2DMake(-99999.0, -99999.0);

// find max/min....

// zoom to cover area
// TODO: Maybe better using a MKPolygon which can calculate its own fitting region.
CLLocationCoordinate2D center = CLLocationCoordinate2DMake((max.latitude + min.latitude) / 2.0, (max.longitude + min.longitude) / 2.0);
MKCoordinateSpan span = MKCoordinateSpanMake(max.latitude - min.latitude, max.longitude - min.longitude);
MKCoordinateRegion region = MKCoordinateRegionMake(center, span);

[_mapView setRegion:[_mapView regionThatFits:region] animated:YES];

Ελπίζω ότι αυτό είναι τουλάχιστον περίπτωση, αυτό είναι αυτό που έβαλα μαζί για Mono (που βασίζονται στα ανοικτά της απάντησης pkclSoft του):

void ZoomMap (MKMapView map)
{
    var annotations = map.Annotations;

    if (annotations == null || annotations.Length == 0) 
        return;

    var points = annotations.OfType<MapAnnotation> ()
                            .Select (s => MKMapPoint.FromCoordinate (s.Coordinate))
                            .ToArray ();            

    map.SetVisibleMapRect(MKPolygon.FromPoints (points).BoundingMapRect, true); 
}