दिलचस्प पोस्ट
विजुअल स्टूडियो 2015 बहुत धीमा है गठबंधन (आरबीआईडी) डेटा फ्रेम और मूल डेटा फ़्रेम के नाम के साथ कॉलम बनाएं दो कस्टम कोशिकाओं के साथ UITableView (एकाधिक पहचानकर्ता) ईमेल संलग्नक कैसे भेजें? एंड्रॉइड एसडीके सामग्री लोडर पर ग्रहण लटका हुआ है PHP से कैसे आप .bat फ़ाइल चला सकते हैं? <div> में <tr>: क्या यह सही है? चरित्र पुनर्निर्माण और ओसीआर के लिए भरना सी # में एक circularly लिंक की सूची बनाना? बूटस्ट्रैप 4 में लंबवत संरेखण अजगर लिपि में एक पासवर्ड छिपा रहा है (केवल असुरक्षित अस्पष्टता) आईओएस कुंजीचेन सुरक्षा आउटपुट कमांड सीएमडी कब्जा शुद्ध सीएसएस आधारित ड्रॉपडाउन मेनू कैसे बनाऊँ? दोस्तों को निजी संदेश भेजें

एनोटेशन पिंस फिट करने के लिए MKMapView ज़ूम करना?

मैं MKMapView का उपयोग कर रहा हूं और मैंने 5-10 किलोमीटर क्षेत्र के बारे में नक्शे में कई एनोटेशन पिन जोड़े हैं। जब मैं अनुप्रयोग चलाता हूं, मेरा मानचित्र पूरे विश्व को दिखाने के लिए ज़ूम आउट हो जाता है, तो मानचित्र को ज़ूम करने का सबसे अच्छा तरीका क्या है ताकि पिंस दृश्य को फिट कर सकें?

संपादित करें: मेरी प्रारंभिक सोच MKCoordinateRegionMake का उपयोग करने और मेरे एनोटेशन से समन्वय केंद्र, रेखांश, डेल्टा और अक्षांश डेल्टा की गणना करना होगा। मुझे पूरा यकीन है कि यह काम करेगा, लेकिन मैं सिर्फ यह देखना चाहता हूं कि मुझे कुछ भी स्पष्ट नहीं है।

संहिता गयी, बीटीडब्ल्यू: एफजी लॉकिंग एक वर्ग है जो एमके एन्नेटेशन के लिए अनुकूल है, लोकेशनएफ़एक्स इन ऑब्जेक्ट्स के एनएसएमयूटीएबलएरेय है। टिप्पणियाँ हमेशा स्वागत है ….

 - (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 < lower.latitude) lower.latitude = [eachLocation coordinate].latitude; if([eachLocation coordinate].longitude > 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; } 

Solutions Collecting From Web of "एनोटेशन पिंस फिट करने के लिए MKMapView ज़ूम करना?"

आपको यह ठीक मिल गया है

अपने अधिकतम और न्यूनतम अक्षांश और रेखांकन खोजें, कुछ सरल गणित लागू करें, और MKCoordinateRegionMake उपयोग करें।

आईओएस 7 और इसके बाद के संस्करण के लिए, showAnnotations:animated: उपयोग showAnnotations:animated: से:

 // 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); 

यह वही है जो मैंने पाया है कि मेरे लिए काम किया है:

(संपादित करें: मैंने माइक्र्ह के सुझाव का उपयोग करके समाधान को अपडेट किया है, ताकि बिंदु को बढ़ाने के लिए 0.1 का निर्धारण किया जा सके, यह सुनिश्चित करने के लिए कि रीक्ट अन्तराल छोटे रूप से समाप्त न हो!)

 MKMapRect zoomRect = MKMapRectNull; for (id <MKAnnotation> 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]; 

आप इस के साथ पहली पंक्ति को बदलकर उपयोगकर्ता स्थान पिन को शामिल करने के लिए अपडेट भी कर सकते हैं:

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

ऐप्पल ने आईओएस 7 के लिए जीवन को थोड़ा सा सरल बनाने के लिए एक नया तरीका जोड़ा है।

 [mapView showAnnotations:yourAnnotationArray animated:YES]; 

आप नक्शा दृश्य में संग्रहीत एक सरणी से आसानी से खींच सकते हैं:

 yourAnnotationArray = mapView.annotations; 

और जल्दी से कैमरा भी समायोजित करें!

 mapView.camera.altitude *= 1.4; 

यह तब तक काम नहीं करेगा जब तक कि उपयोगकर्ता के पास आईओएस 7+ या ओएस एक्स 10.9+ स्थापित नहीं है। कस्टम ऐनिमेशन को यहां देखें

मैं इस कोड का उपयोग करता हूं और मेरे लिए ठीक काम करता हूं:

 -(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]; } 

@ जॉकी का समाधान महान काम करता है एक पकड़, अगर एक नक्शा में केवल एक एनोटेशन है तो आप पूरी तरह से ज़ूम आउट मानचित्र के साथ समाप्त होंगे। मैंने तय किया है कि आकार सेट करने के लिए आकार में 0.1 को जोड़ दिया जाता है, सेट अप करने के लिए ज़ूम इन करें।

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

स्विफ्ट उपयोग में

 mapView.showAnnotations(annotationArray, animated: true) 

उद्देश्य सी में

 [mapView showAnnotations:annotationArray animated:YES]; 

मैंने राफेल मोरेरा द्वारा जवाब बदल दिया है श्रेय उसके पास जाता है आपमें से स्विफ्ट संस्करण की तलाश में, यहां कोड है:

  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) } 

यदि आप आईओएस 8 और इसके बाद के संस्करण की तलाश कर रहे हैं, तो यह करने के लिए सबसे सरल तरीका है कि var layoutMargins: UIEdgeInsets { get set } सेट करें var layoutMargins: UIEdgeInsets { get set } करें func showAnnotations(annotations: [MKAnnotation], animated: Bool)

उदाहरण के लिए (स्विफ्ट 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) } 

इस पाश को इस विधि से उपयोगकर्ताओं के स्थान पिन को बाहर करने के लिए अगर लूप के भीतर जोड़ा गया है (मेरे मामले में और अन्य हो सकता है)।

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

IOS 7 और इसके बाद के संस्करण (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); 

से टिप्पणी – अभिषेक बेदी

आप बस कॉल करते हैं:

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

मैंने यहां और वहां से स्विफ्ट 2.3 में कुछ कोड का उपयोग करते हुए सभी एनोटेशन दिखाने के लिए एक एक्सटेंशन बनाया है। यह सभी एनोटेशन नहीं दिखाएगा, यदि अधिकतम ज़ूम स्तर पर भी दिखाया नहीं जा सकता है।

 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) } } 

स्विफ्ट 3 मानचित्र में सभी एनोटेशन फिट करने के लिए यह सही तरीका है।

 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) } 

स्विफ्ट में

  var zoomRect = MKMapRectNull; for i in 0..<self.map.annotations.count { let annotation: MKAnnotation = self.map.annotations[i] let annotationPoint = MKMapPointForCoordinate(annotation.coordinate); let pointRect = MKMapRectMake(annotationPoint.x, annotationPoint.y, 0.1, 0.1); zoomRect = MKMapRectUnion(zoomRect, pointRect); } self.map.setVisibleMapRect(zoomRect, animated: true) 

Jowie के लिए धन्यवाद मैंने अपनी पुरानी श्रेणी को और अधिक सुरुचिपूर्ण समाधान में अद्यतन किया है। पूरी तरह से साझा करना, लगभग कॉपी और पेस्ट तैयार समाधान

MKMapView + AnnotationsRegion.h

 #import <MapKit/MapKit.h> @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<MKAnnotation> 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 

आशा है कि यह किसी और में धन्यवाद फिर से मदद करता है!

  - (void)zoomMapViewToFitAnnotationsWithExtraZoomToAdjust:(double)extraZoom { if ([self.annotations count] == 0) return; int i = 0; MKMapPoint points[[self.annotations count]]; for (id<MKAnnotation> 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]; } 
  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) 

इस पृष्ठ पर सभी उत्तर मानते हैं कि नक्शा पूर्ण स्क्रीन पर है । मैं वास्तव में एक एचयूडी डिस्प्ले (यानी शीर्ष और नीचे बिखरे हुए बटन) है जो नक्शा के ऊपर की जानकारी देता है .. और इसलिए पृष्ठ पर एल्गोरिदम पिन को सभी सही दिखाएगा, लेकिन उनमें से कुछ एचयूडी डिस्प्ले बटन के नीचे दिखाई देंगे ।

मेरा समाधान स्क्रीन के सबसेट में एनोटेशन प्रदर्शित करने के लिए मानचित्र को ज़ूम करता है और विभिन्न स्क्रीन आकारों के लिए काम करता है (यानी 3.5 "बनाम 4.0" आदि):

 // 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. 

यहाँ कोड में मैंने क्या किया है (ध्यान दें: मैं अपने कोड को विभिन्न स्क्रीन आकारों में काम करने के लिए कुछ सहायक विधियों के साथ NSConstraints उपयोग NSConstraints हूं .. जबकि कोड काफी पढ़ा जा सकता है .. मेरा जवाब यहां बेहतर बताता है .. यह मूल रूप से एक ही वर्कफ़्लो है: )

 // 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]; 

यहां कोड है जो क्षेत्र को फिट बैठता है:

 - (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; } 

जैसा कि अभिषेक बेदी एक टिप्पणी में बताते हैं, IOS7 के लिए यह करने का सबसे अच्छा तरीका है:

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

मेरी निजी परियोजना (आईओएस 7 से पहले) के लिए मैंने एमकेमैपविव वर्ग पर एक श्रेणी को एक बहुत सामान्य ऑपरेशन के लिए "दृश्य क्षेत्र" कार्यक्षमता को आवृत करने के लिए जोड़ा है: MKMapView इंस्टेंस पर सभी वर्तमान-लोड एनोटेशन देखने में सक्षम होने के लिए सेट करना इसमें आप जितने पिन रख सकते हैं, साथ ही साथ उपयोगकर्ता के स्थान भी शामिल हैं)। परिणाम यह था:

.h फ़ाइल

 #import <MapKit/MapKit.h> @interface MKMapView (Extensions) -(void)ij_setVisibleRectToFitAllLoadedAnnotationsAnimated:(BOOL)animated; -(void)ij_setVisibleRectToFitAnnotations:(NSArray *)annotations animated:(BOOL)animated; @end 

फ़ाइल एम

 #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(px, py, 0, 0)); } [mapView setVisibleMapRect:r animated:animated]; } @end 

जैसा कि आप देख सकते हैं, मैंने अभी तक 2 तरीकों को जोड़ दिया है: एक मैक के दृश्य क्षेत्र को सेट करने के लिए, जो कि वर्तमान में लोड किए गए एनोटेशन को एमकेमैपदृश्य इंस्टेंस पर फिट करता है, और इसे ऑब्जेक्ट के किसी भी सरणी में सेट करने के लिए दूसरा तरीका तो mapView के दृश्य क्षेत्र को सेट करने के लिए कोड तब के रूप में सरल होगा:

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

मुझे उम्मीद है कि यह मदद करता है =)

मैंने 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 <MKAnnotation> 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]; } 

बस इस पर मेरी टिप्पणियों को साझा करना:

अगर आप स्टोरीबोर्ड में स्क्रीन के लिए स्क्रीन के लिए "अनुमानित" आकार के साथ एक्सकोड> 6 का प्रयोग कर रहे हैं (देखें "सिम्युलेटेड मैट्रिक्स" फ़ाइल निरीक्षक पर), कॉलिंग

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

viewDidLoad में viewDidLoad परिणामस्वरूप 4 इंच के साथ आईफोन पर एक बहुत बड़ा ज़ूम स्तर होता है क्योंकि मानचित्र के लिए लेआउट अभी भी स्टोरीबोर्ड से व्यापक स्क्रीन के आकार पर है।

आप को showAnnotations... लिए showAnnotations... को देखने के लिए अपनी कॉल को ले जा सकते showAnnotations... । फिर मानचित्र का आकार पहले ही आईफोन 4 की छोटी स्क्रीन पर समायोजित कर दिया गया है।

या वैकल्पिक रूप से "सिम्युलेटेड मेट्रिक" के अंतर्गत आईफ़ोन 4-इंच के लिए फ़ाइल इंस्पेक्टर में "अनुमानित" मान को परिवर्तित करें

Swft 3 में अन्य तरीका

 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) } 

@ "मुझे यकीन नहीं है कि यह मेरे कार्यान्वयन में कुछ अन्य कारणों के कारण है, लेकिन मुझे लगता है कि मैन्युअल कार्यान्वयन के रूप में एनोटेशन के ज़ूम / फ़िट के रूप में शो एनएनटेशन उतना करीब नहीं है, इसलिए मैं मैनुअल एक – टेड एवेरी 17 अप्रैल को 0:35 "

मेरे पास एक ही समस्या थी, लेकिन फिर मैंने दो बार शो एनोटेशन (नीचे की तरह) करने की कोशिश की, और किसी कारण से, यह काम किया।

[नक्शा देखें दिखाएँ एनोटेशन: आपका एनोटेशनअरेरे एनिमेटेड: हाँ]; [नक्शा दिखाएँ दिखाएँ एनोटेशन: आपका एनोटेशनअरेरे एनिमेटेड: हाँ];

आईओएस 7 संगत तरीके से निम्नलिखित का उपयोग करना है I सभी एनोटेशन सहित एक आयत प्राप्त करने के लिए पहले कॉल showAnnotation एनोटेशन। बाद में पिन की ऊंचाई के शीर्ष UIEdgeInset साथ बनाने और UIEdgeInset । इस प्रकार आप नक्शा पर पूरे पिन को दिखाने के लिए सुनिश्चित करते हैं।

 [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]; 

ऊपर दिए गए उत्तरों के आधार पर आप एक ही समय में सभी एनोटेशन और ओवरले फिट करने के लिए मानचित्र ज़ूम करने के लिए सार्वभौमिक विधि का उपयोग कर सकते हैं।

 -(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 <MKOverlay> 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 <MKAnnotation> 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; } 

और तब:

 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]; 

इसके अनुसार अपने कोड में इसे रखें:

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