कैमरा और व्यू

iOS के लिए Maps SDK टूल की मदद से, उपयोगकर्ता का मैप देखने का नज़रिया बदला जा सकता है अपना पसंदीदा कैमरा बंद कर सकते हैं.

iOS के लिए Maps SDK की मदद से, उपयोगकर्ता में बदल सकते हैं. किसी भी ज़ूम पर स्तर, उपयोगकर्ता बहुत कम प्रतीक्षा अवधि के साथ मैप को पैन कर सकते हैं या इसका दृष्टिकोण बदल सकते हैं.

कैमरे में होने वाले बदलावों से आपके मार्कर, पॉलीलाइन या अन्य ग्राफ़िक में कोई बदलाव नहीं होता जोड़ा गया है, हालांकि हो सकता है कि आप नया व्यू.

मैप का व्यू

iOS के लिए Maps SDK मर्केटर का इस्तेमाल करता है प्रोजेक्शन आपके डिवाइस की स्क्रीन पर दुनिया की सतह (एक स्फ़ीयर) दिखाने के लिए (एक फ़्लैट हवाई जहाज़).

कैमरे की स्थिति

मैप व्यू को कैमरे की तरह दिखाया गया है, जो सपाट सतह पर नीचे की ओर दिखता है. स्थिति (और इसलिए मैप की रेंडरिंग) ये प्रॉपर्टी: टारगेट (अक्षांश/देशांतर की जगह), बियरिंग, झुकाव, और ज़ूम करें.

टारगेट (जगह)

कैमरा टारगेट, मैप के बीच की जगह है, जिसे इस तरह से बताया गया है अक्षांश और देशांतर निर्देशांक.

बियरिंग (ओरिएंटेशन)

कैमरा बियरिंग, कंपास की दिशा के बारे में बताता है, जिसे सही उत्तर से डिग्री में मापा गया है. ऊपर किनारे तक ले जाएं. मैप के बीच से सबसे ऊपर के किनारे तक, वर्टिकल लाइन बनाने पर बियरिंग, कैमरे के हेडिंग (डिग्री में मापी गई) से मेल खाती है सही उत्तर की ओर.

0 के बेयरिंग का मतलब है कि मैप का ऊपरी हिस्सा उत्तर की ओर है. बियरिंग की वैल्यू 90 का मतलब है कि मैप का सबसे ऊपरी हिस्सा, पूर्व की ओर दिखता है (कपास पर 90 डिग्री). मान 180 का मतलब है, मैप के सबसे ऊपर का हिस्सा दक्षिण की ओर.

Maps API की मदद से, मैप के बियरिंग में बदलाव किया जा सकता है. उदाहरण के लिए, कोई व्यक्ति कार चला रहा है अपनी यात्रा की दिशा के साथ अलाइन करने के लिए अक्सर एक रोड मैप बदल दिया जाता है, जबकि हाइकर मैप का उपयोग करके और आम तौर पर, कंपास का ओरिएंटेशन मैप में इस तरह से होता है कि एक वर्टिकल लाइन उत्तर की ओर हो.

झुकाएं (देखने का कोण)

झुकाव, चाप पर कैमरे की स्थिति को मैप के ठीक ऊपर दिखाता है बीच की स्थिति, जिसे nadir (कैमरे के ठीक नीचे की ओर इशारा करने वाली दिशा). वैल्यू 0 है, जिसका मतलब है कि कैमरा पॉइंट किया गया है सीधे नीचे. अगर वैल्यू 0 से ज़्यादा है, तो इसका मतलब है कि कैमरे को क्षितिज की ओर खींचने पर डिग्री की निर्दिष्ट संख्या. जब मैप देखने का ऐंगल बदला जाता है, तो मैप दूर की जगहों के ऐंगल में दिखता है छोटे दिखाई दे रहे हैं और आस-पास की विशेषताएं ज़्यादा बड़ी दिख रही हैं. नीचे दिए गए इन तस्वीरों में यह बात साफ़ तौर पर दिख रही है.

नीचे दी गई इमेज में, देखने का ऐंगल 0 डिग्री है. पहली इमेज में दिखाया गया है कि इसके डायग्राम में दिखाया गया है; रैंक 1, कैमरे की पोज़िशन और रैंक 2 है यह मैप की मौजूदा स्थिति है. इससे बनने वाला मैप इसके नीचे दिखाया गया है.

नीचे दी गई इमेज में, देखने का ऐंगल 45 डिग्री है. ध्यान दें कि कैमरा ऊपर के सीधे ऊपर (0 डिग्री) और ज़मीन के बीच (90 डिग्री) के बीच, चाप के आधे रास्ते में चलता है, जगह 3 पर. कैमरा अब भी मैप के केंद्र बिंदु की ओर इशारा कर रहा है, लेकिन इलाका अब आपको 4 स्थिति की लाइन से दिखाया जाएगा.

इस स्क्रीनशॉट में मैप अब भी उसी पॉइंट पर बीच में है जिस पर मूल मैप में, लेकिन मैप के ऊपर और भी सुविधाएँ जोड़ी गई हैं. अगर आपने कैमरे और मैप के बीच के ऐंगल को 45 डिग्री से ज़्यादा बढ़ाएं स्थिति आनुपातिक रूप से बड़ी दिखाई देती है, जबकि मैप की स्थिति से परे सुविधाएं दिखाई जाती हैं ये आनुपातिक रूप से कम दिखते हैं, और एक त्रि-आयामी प्रभाव देते हैं.

ज़ूम करें

कैमरे का ज़ूम लेवल, मैप का स्केल तय करता है. ज़्यादा ज़ूम करने पर स्क्रीन पर लेवल की ज़्यादा जानकारी देखी जा सकती है, जबकि छोटे ज़ूम लेवल पर देखा जा सकता है स्क्रीन पर दुनिया के ज़्यादा से ज़्यादा हिस्से देखे जा सकते हैं. ज़ूम स्तर 0 पर, मैप का स्केल ऐसा होता है कि पूरी दुनिया के पास करीब 256 पॉइंट की चौड़ाई होती है.

ज़ूम के लेवल को 1 बढ़ाने से, स्क्रीन पर मौजूद दुनिया की चौड़ाई दोगुनी हो जाती है. इसलिए, ज़ूम के लेवल N पर, दुनिया की चौड़ाई करीब-करीब 256 * 2^N पॉइंट. उदाहरण के लिए, ज़ूम स्तर 2 पर, पूरी दुनिया लगभग 1024 पॉइंट चौड़ा.

ज़ूम लेवल, पूर्णांक में होना ज़रूरी नहीं है. ज़ूम की रेंज लेवल कई चीज़ों पर निर्भर करते हैं. इनमें टारगेट भी शामिल हैं. मैप का टाइप और स्क्रीन का साइज़. रेंज से बाहर की कोई भी संख्या, अगला सबसे नज़दीकी मान्य मान, जो कम से कम ज़ूम स्तर या ज़ूम करने की सीमा. निम्न सूची विवरण का अनुमानित स्तर दिखाती है तो आप प्रत्येक ज़ूम स्तर पर देखने की उम्मीद कर सकते हैं:

• 1: दुनिया
• 5: लैंडमास/महाद्वीप
• 10: शहर
• 15: सड़कें
• 20: इमारतें

कैमरे की शुरुआती स्थिति सेट करें

कैमरे की शुरुआती स्थिति सेट करने के लिए, GMSCameraPosition ऑब्जेक्ट है, जिसकी सहायता से आप लक्ष्य के साथ-साथ लक्ष्य का अक्षांश और देशांतर सेट कर सकते है बेयरिंग, झुकाना, और ज़ूम करना.

कैमरे की शुरुआती स्थिति सेट करने के लिए, GMSMapViewOptions ऑब्जेक्ट बनाएं और सेट करें camera प्रॉपर्टी को GMSCameraPosition के लिए. फिर अपने विकल्पों को GMSMapView सुविधा कंस्ट्रक्टर.

let options = GMSMapViewOptions()
options.camera = GMSCameraPosition.camera(withLatitude: -33.8683, longitude: 151.2086, zoom: 16)
let mapView = GMSMapView(options:options)

GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
options.camera = [GMSCameraPosition cameraWithLatitude:-33.8683
                                                        longitude:151.2086
                                                             zoom:16];
GMSMapView *mapView = [[GMSMapView alloc] initWithOptions:options];

डिफ़ॉल्ट UIView इनइट का इस्तेमाल करके भी GMSMapView ऑब्जेक्ट बनाया जा सकता है तरीका. इस स्थिति में, कैमरे की पोज़िशन डिफ़ॉल्ट जगह से शुरू हो जाती है और आप उसे बनाने के बाद बदला जा सकता है.

let options = GMSMapViewOptions()
options.frame = self.view.bounds
let mapView = GMSMapView(options:options)

GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
options.frame = self.view.bounds;
GMSMapView *mapView = [[GMSMapView alloc] initWithOptions:options];

कैमरे की पोज़िशन बदलना

स्थान सेट करने के लिए आपके पास प्रोग्राम रूप से कैमरे की स्थिति बदलने का विकल्प होता है, बेयरिंग, झुकाना, और ज़ूम करना. GMSMapView कई तरीके उपलब्ध कराता है. कैमरे की जगह बदलने के लिए, आम तौर पर GMSCameraPosition या GMSCameraUpdate:

• GMSCameraPosition इसमें ऐसी प्रॉपर्टी और तरीके शामिल हैं जिनका इस्तेमाल कैमरे की हर पोज़िशन को बदलने के लिए किया जाता है पैरामीटर: टारगेट, बियरिंग, झुकाना, और ज़ूम.

• GMSCameraUpdate आपको टारगेट, बियरिंग, टिल्ट, और ज़ूम को बदलने की सुविधा देता है. साथ ही, का इस्तेमाल करके स्क्रोल करने, बेहतर ज़ूम करने, और पहले से तय सीमाओं में कैमरे का इस्तेमाल करें, और बहुत कुछ.

कैमरे को मूव करते समय, "स्नैप करें" का विकल्प चुना जा सकता है कैमरे को नए स्थिति का मतलब है कि इसमें ऐनिमेशन नहीं है या ऐनिमेशन नहीं है. उदाहरण के लिए, अगर तब आप कैमरे की टारगेट जगह में बदलाव को ऐनिमेट करते हैं, तो ऐनिमेशन, पहले की जगह को नए जगह से जोड़ें.

ऐनिमेशन, कैमरा के मौजूदा एट्रिब्यूट और नए कैमरे के एट्रिब्यूट के बीच अंतर करता है कैमरा एट्रिब्यूट. ऐनिमेशन की अवधि को कंट्रोल करने के लिए, Core ऐनिमेशन.

GMSCameraPosition का इस्तेमाल करें

इससे कैमरा बदलने के लिए GMSCameraPosition आप एक नया ऑब्जेक्ट बनाते हैं या किसी मौजूदा ऑब्जेक्ट को कॉपी करके उसे इस पर सेट करते हैं: GMSMapView ऑब्जेक्ट. कैमरा स्नैप करने के लिए GMSCameraPosition ऑब्जेक्ट का इस्तेमाल करें ऐनिमेशन के साथ या उसके बिना नई जगह की जानकारी हासिल करने में मदद मिलती है.

किसी भी कैमरा प्रॉपर्टी को कॉन्फ़िगर करने के लिए, GMSCameraPosition ऑब्जेक्ट का इस्तेमाल करें. जैसे, अक्षांश, देशांतर, ज़ूम, बियरिंग, और व्यूइंग ऐंगल. इसके बाद, उस ऑब्जेक्ट का इस्तेमाल करें GMSMapView की camera प्रॉपर्टी को सेट करने के लिए.

let fancy = GMSCameraPosition(
  latitude: -33,
  longitude: 151,
  zoom: 6,
  bearing: 270,
  viewingAngle: 45
)
mapView.camera = fancy
      

GMSCameraPosition *fancy = [GMSCameraPosition cameraWithLatitude:-33.8683
                                                       longitude:151.2086
                                                            zoom:6
                                                         bearing:30
                                                    viewingAngle:45];
[mapView setCamera:fancy];
      

उस GMSCameraPosition प्रॉपर्टी को हटाएं जिसे उसकी डिफ़ॉल्ट वैल्यू पर सेट करना है.

इस गतिविधि को ऐनिमेट करने के लिए, इसके बजाय animateToCameraPosition: तरीके का इस्तेमाल करें camera प्रॉपर्टी सेट कर रहा है.

GMSCameraUpdate का इस्तेमाल करें

GMSCameraUpdate आपको कैमरे की स्थिति अपडेट करने की सुविधा देता है, और यह चुन सकता है कि स्नैप करना है या ऐनिमेट करना है पोस्ट किया है. GMSCameraUpdate का फ़ायदा सुविधाजनक है. आप GMSCameraUpdate वाले टास्क को करने के लिए, GMSCameraPosition का इस्तेमाल करें, लेकिन GMSCameraUpdate इन कामों को आसान बनाने के लिए कुछ और मददगार तरीके उपलब्ध कराता है कैमरे में बदलाव करना.

उदाहरण के लिए, अगर आपको मौजूदा ज़ूम लेवल बढ़ाने के लिए GMSCameraPosition का इस्तेमाल करना है, तो पहले वर्तमान ज़ूम स्तर का पता लगाना होगा, फिर GMSCameraPosition ऑब्जेक्ट जहां ज़ूम को, इससे ज़्यादा वैल्यू पर सेट किया गया है मौजूदा ज़ूम है.

इसके अलावा, zoomIn: तरीके की मदद से GMSCameraUpdate ऑब्जेक्ट बनाया जा सकता है. इसके बाद, GMSCameraUpdate ऑब्जेक्ट को GMSMapView animateWithCameraUpdate: तरीका.

// Zoom in one zoom level
let zoomCamera = GMSCameraUpdate.zoomIn()
mapView.animate(with: zoomCamera)
      

// Zoom in one zoom level
GMSCameraUpdate *zoomCamera = [GMSCameraUpdate zoomIn];
[mapView animateWithCameraUpdate:zoomCamera];
      

कैमरे को नई पोज़िशन पर स्नैप करने के लिए, GMSMapView moveCamera: तरीके का इस्तेमाल करें आज़माएं.

अगले उदाहरण में, कैमरे की मूवमेंट को ऐनिमेट करने के लिए, GMSCameraUpdate का इस्तेमाल किया गया है साथ ही, उसे वैंकूवर पर फ़ोकस करें.

// Center the camera on Vancouver, Canada
let vancouver = CLLocationCoordinate2D(latitude: 49.26, longitude: -123.11)
let vancouverCam = GMSCameraUpdate.setTarget(vancouver)
mapView.animate(with: vancouverCam)
      

// Center the camera on Vancouver, Canada
CLLocationCoordinate2D vancouver = CLLocationCoordinate2DMake(49.26, -123.11);
GMSCameraUpdate *vancouverCam = [GMSCameraUpdate setTarget:vancouver];
[mapView animateWithCameraUpdate:vancouverCam];
      

GMSCameraUpdate ऑब्जेक्ट बनाएं

GMSCameraUpdate ऑब्जेक्ट को बनाने के लिए, उसके किसी तरीके का इस्तेमाल करें.

zoomIn: और zoomOut:

मौजूदा ज़ूम लेवल को 1.0 तक कम या ज़्यादा करते समय, अन्य सभी प्रॉपर्टी एक जैसी होनी चाहिए.

zoomTo:

ज़ूम के लेवल को, दी गई वैल्यू में बदलता है. साथ ही, दूसरे सभी को ध्यान में रखता है गुण समान हैं.

zoomBy:

ज़ूम लेवल को बढ़ाता है (या घटता है, अगर वैल्यू नेगेटिव हो) दिए गए मान से.

zoomBy:atPoint:

मान ऋणात्मक होने पर यह बढ़ता (या घटता है) दिए गए मान से ज़ूम करने का लेवल, जबकि बताए गए पॉइंट को बनाए रखें स्थिति दिखाई गई है.

setTarget:

सुरक्षित रखते हुए, कैमरे के अक्षांश और देशांतर को बदलता है अन्य सभी प्रॉपर्टी.

setTarget:zoom:

कैमरे के अक्षांश, देशांतर, और ज़ूम को बदलता है दूसरी सभी प्रॉपर्टी को सुरक्षित रखना.

setCamera:

नया GMSCameraPosition सेट करता है.

scrollByX:Y:

मैप को मूव करने के लिए कैमरे के अक्षांश और देशांतर को बदलता है पॉइंट की तय संख्या से. पॉज़िटिव x वैल्यू की वजह से ताकि मैप दाईं ओर ले जाया जा सके, ताकि ऐसा लगे कि मैप पर बाएं. पॉज़िटिव y मान की वजह से कैमरा नीचे की ओर खिसक जाता है, ताकि मैप ऊपर गया प्रतीत होता है. कैमरे के मौजूदा हिस्से के हिसाब से स्क्रोल किया जा रहा है बियरिंग. उदाहरण के लिए, अगर कैमरे की बियरिंग 90 डिग्री है, तो पूर्व "ऊपर" है.

fitBounds:

यह कैमरे को स्क्रीन पर तय सीमाओं को बीच में लाने के लिए बदल देता है ज़ूम करने की सबसे अच्छी दर. डिफ़ॉल्ट पर लागू होता है पैडिंग (जगह) को 64 पॉइंट की सीमा तक ले जाना.

fitBounds:withPadding:

यह कैमरे को फ़्रेम के बीच में ला देता है स्क्रीन को सबसे ज़्यादा ज़ूम लेवल पर सेट कर सकते हैं. इस तरीके का इस्तेमाल यह तय करने के लिए करें कि बाउंडिंग बॉक्स की सभी साइड के लिए पॉइंट में, एक जैसी पैडिंग.

fitBounds:withEdgeInsets:

यह कैमरे को फ़्रेम के बीच में ला देता है स्क्रीन को सबसे ज़्यादा ज़ूम लेवल पर सेट कर सकते हैं. UIEdgeInsets के साथ, तो आपको बाउंडिंग बॉक्स की हर साइड के लिए अलग से पैडिंग तय करनी होगी.

किसी एक प्रॉपर्टी को बदलने के लिए, GMSMapView का इस्तेमाल करें

GMSMapView कई तरीके उपलब्ध कराता है, जिससे आप बिना किसी GMSCameraPosition ऑब्जेक्ट या GMSCameraUpdate ऑब्जेक्ट. इन तरीकों से, animateToLocation: या animateToZoom: के तौर पर रिकॉर्ड करते हैं, तो आप एक कैमरे से जुड़ी प्रॉपर्टी.

उदाहरण के लिए, कैमरे में हुए बदलाव को ऐनिमेट करने के लिए, toViewingAngle: तरीके का इस्तेमाल करें झुकाएं.

mapView.animate(toViewingAngle: 45)
      

[mapView animateToViewingAngle:45];
      

टारगेट (जगह) सेट करें

स्थान से ही मैप का केंद्र तय होता है. जगह इसके हिसाब से तय की जाती हैं अक्षांश और देशांतर हैं. साथ ही, इन्हें प्रोग्राम के हिसाब से CLLocationCoordinate2D को CLLocationCoordinate2DMake की मदद से बनाया गया.

जगह बदलने के लिए GMSCameraPosition का इस्तेमाल करें. इस उदाहरण में, मैप स्नैप हो जाता है नई जगह पर जाएं.

let target = CLLocationCoordinate2D(latitude: -33.868, longitude: 151.208)
mapView.camera = GMSCameraPosition(target: target, zoom: 6)
      

CLLocationCoordinate2D target =
    CLLocationCoordinate2DMake(-33.868, 151.208);
mapView.camera = [GMSCameraPosition cameraWithTarget:target zoom:6];
      

बदलाव को ऐनिमेट और मैप को नई जगह पर पैन करने के लिए, camera प्रॉपर्टी सेट करने के बजाय animateToCameraPosition: तरीका. या GMSMapView पर animateToLocation: तरीके का इस्तेमाल करें.

mapView.animate(toLocation: CLLocationCoordinate2D(latitude: -33.868, longitude: 151.208))
      

[mapView animateToLocation:CLLocationCoordinate2DMake(-33.868, 151.208)];
      

कैमरे को मूव करने के लिए, GMSCameraUpdate ऑब्जेक्ट भी बनाया जा सकता है. इसका इस्तेमाल करें पहले से मौजूद तरीका, scrollByX:Y:, ताकि स्क्रोल करने के लिए पॉइंट की संख्या बताई जा सके X और Y दिशा में कैमरा इस्तेमाल करने की सुविधा मिलती है. इस उदाहरण में, कैमरा 200 पिक्सल आइटम दाईं ओर ले जाते हैं और 100 पॉइंट नीचे:

// Move the camera 200 points to the right, and 100 points downwards
let downwards = GMSCameraUpdate.scrollBy(x: 200, y: 100)
mapView.animate(with: downwards)
      

// Move the camera 200 points to the right, and 100 points downwards
GMSCameraUpdate *downwards = [GMSCameraUpdate scrollByX:200.0 Y:100.0];
[mapView animateWithCameraUpdate:downwards];
      

बेयरिंग सेट करें (अभिविन् यास)

बेयरिंग कंपास की दिशा है, जिसे सही उत्तर से डिग्री में मापा गया है. क्लिक करें. उदाहरण के लिए, किसी नक्शे में 90 डिग्री का बेयरिंग मिलने का परिणाम जहां सबसे ऊपरी किनारे पूर्व की ओर होता है.

बेयरिंग को GMSCameraPosition या GMSCameraUpdate के साथ प्रोग्रामेटिक रूप से सेट करें या GMSMapView वाले animateToBearing: तरीके का इस्तेमाल करें.

mapView.animate(toBearing: 0)
      

[mapView animateToBearing:0];
      

झुकाव सेट करें (देखने का कोण)

देखने का कोण, चाप पर कैमरे की स्थिति है. पृथ्वी की सतह और मैप का केंद्र स्थिति, nadir (दिशा कैमरे के नीचे रखते हैं). जब आप देखने का कोण बदलते हैं, तो मैप कैमरे और मैप की पोज़िशन के बीच की सुविधाओं के साथ, ऐंगल में दिखता है आनुपातिक रूप से बड़ा दिखाई दे रहा है, और मैप की स्थिति से परे सुविधाएँ दिखाई दे रही हैं आनुपातिक रूप से छोटा, जो एक त्रि-आयामी प्रभाव देता है.

देखने का कोण 0 (मैप की ओर सीधे नीचे की ओर इशारा करता हुआ) और और ज़ूम-लेवल पर निर्भर करता है. 16 या उससे ज़्यादा ज़ूम लेवल के लिए, कोण 65 डिग्री है. 10 या उससे कम लेवल के ज़ूम के लिए, ज़्यादा से ज़्यादा 30 का ऐंगल होना चाहिए डिग्री.

GMSCameraPosition का इस्तेमाल करके, व्यूइंग ऐंगल को प्रोग्राम के हिसाब से सेट करें या GMSCameraUpdate या GMSMapView वाले animateToViewingAngle: तरीके का इस्तेमाल करें.

mapView.animate(toViewingAngle: 45)
      

[mapView animateToViewingAngle:45];
      

ज़ूम सेट करें

कैमरे का ज़ूम लेवल, मैप का स्केल तय करता है. ज़्यादा ज़ूम करने पर हैं, तो आप स्क्रीन पर ज़्यादा बारीकियां देख सकते हैं, जबकि छोटे ज़ूम लेवल पर आपको दुनिया के बारे में ज़्यादा जानकारी मिल सकती है.

GMSCameraPosition या GMSCameraUpdate का इस्तेमाल करके, प्रोग्राम के हिसाब से ज़ूम सेट करें या GMSMapView वाले animateToZoom: तरीके के साथ.

mapView.animate(toZoom: 12)
      

[mapView animateToZoom:12];
      

इस उदाहरण में, GMSCameraUpdate बनाने के लिए zoomIn: तरीके का इस्तेमाल किया गया है ऑब्जेक्ट का इस्तेमाल करके, ज़ूम इन को मौजूदा लेवल से एक लेवल तक ऐनिमेट किया जा सकता है.

// Zoom in one zoom level
let zoomCamera = GMSCameraUpdate.zoomIn()
mapView.animate(with: zoomCamera)
      

// Zoom in one zoom level
GMSCameraUpdate *zoomCamera = [GMSCameraUpdate zoomIn];
[mapView animateWithCameraUpdate:zoomCamera];
      

सीमाएं तय करें

कैमरे को इस तरह से मूव करने के लिए कि पसंद की पूरी जगह सबसे ज़्यादा दिखे ज़ूम का संभावित लेवल, कैमरा व्यू के लिए सीमाएं सेट करें. उदाहरण के लिए, अगर उपयोगकर्ता के मौजूदा समय से पाँच मील के दायरे में मौजूद सभी पेट्रोल पंप दिखाना चाहते हैं कैमरा की जगह बदलें, ताकि वे सभी स्क्रीन पर दिखाई दें:

1. उस GMSCoordinateBounds को कैलकुलेट करें जिसे आपको स्क्रीन पर दिखाई दे सकते हैं.
2. नए नतीजे पाने के लिए, GMSMapView में से cameraForBounds:insets: तरीके का इस्तेमाल करें GMSCameraPosition.

इन सीमाओं को सेट करने से यह पक्का होता है कि दिया गया GMSCoordinateBounds पूरी तरह से फ़िट हो जाता है के साइज़ के हिसाब से फ़िल्टर करें. ध्यान दें कि यह तरीका, झुकाव और बियरिंग को सेट करता है मैप को 0 पर सेट करें.

नीचे दिए गए उदाहरण में कैमरे को बदलने का तरीका बताया गया है, ताकि सभी शहर वैंकूवर और कैलगरी दोनों एक ही दृश्य में दिखाई देते हैं.

let vancouver = CLLocationCoordinate2D(latitude: 49.26, longitude: -123.11)
let calgary = CLLocationCoordinate2D(latitude: 51.05,longitude: -114.05)
let bounds = GMSCoordinateBounds(coordinate: vancouver, coordinate: calgary)
let camera = mapView.camera(for: bounds, insets: UIEdgeInsets())!
mapView.camera = camera
      

CLLocationCoordinate2D vancouver = CLLocationCoordinate2DMake(49.26, -123.11);
CLLocationCoordinate2D calgary = CLLocationCoordinate2DMake(51.05, -114.05);
GMSCoordinateBounds *bounds =
    [[GMSCoordinateBounds alloc] initWithCoordinate:vancouver coordinate:calgary];
GMSCameraPosition *camera = [mapView cameraForBounds:bounds insets:UIEdgeInsetsZero];
mapView.camera = camera;
      

दिए गए हिस्से में उपयोगकर्ता को पैन करने पर पाबंदी लगाएं

ये स्थितियां मैप की सीमाएं तय करती हैं, लेकिन उपयोगकर्ता इसके बाद स्क्रोल या पैन कर सकता है चीज़ों को इन सीमाओं के बाहर रखा जा सकता है. इसके बजाय, हो सकता है कि आप निर्देशांक को बाधित करना चाहें मैप के फ़ोकल पॉइंट (कैमरा टारगेट) के बीच वाले बाउंड्री सेट करें, ताकि उपयोगकर्ता सिर्फ़ इन सीमाओं में स्क्रोल और पैन कर सकते हैं.

उदाहरण के लिए, शॉपिंग सेंटर या हवाई अड्डे के लिए एक रीटेल ऐप्लिकेशन मैप को खास सीमाओं तक ले जाया जा सकता है, ताकि उपयोगकर्ता उन सीमाओं में स्क्रोल और पैन कर सकें.

पैनिंग को खास सीमाओं तक सीमित करने के लिए, इसकी cameraTargetBounds प्रॉपर्टी सेट करें GMSMapView से GMSCoordinateBounds ऑब्जेक्ट जनरेट करता है, जो ज़रूरी सीमाएं बताता है. बाद में पाबंदी हटाने के लिए, cameraTargetBounds को 'शून्य' पर सेट करें.

mapView.cameraTargetBounds = bounds
      

mapView.cameraTargetBounds = bounds;
      

नीचे दिया गया डायग्राम, उस स्थिति को दिखाता है जब कैमरा टारगेट ऐसे क्षेत्र तक सीमित होना चाहिए जो व्यूपोर्ट से थोड़ा बड़ा हो. उपयोगकर्ता ये काम कर सकता है: स्क्रोल और पैन करें, बशर्ते कैमरे का टारगेट सीमा वाले इलाके में बना रहे. कॉन्टेंट बनाने क्रॉस, कैमरा टारगेट को दिखाता है:

मैप हमेशा व्यूपोर्ट को भरता है, भले ही इसके नतीजे व्यूपोर्ट में दिखते हों क्षेत्रों को तय सीमाओं से बाहर रखा गया है. उदाहरण के लिए, यदि आप सीमा वाले क्षेत्र के किसी कोने पर कैमरा लक्ष्य, कोने के बाहर का क्षेत्र है व्यूपोर्ट में दिखता है, लेकिन उपयोगकर्ता उस एरिया में और स्क्रोल नहीं कर सकते. कॉन्टेंट बनाने इस डायग्राम में दिखाया गया है. क्रॉस, कैमरे को दिखाता है टारगेट:

नीचे दिए गए डायग्राम में, कैमरे के टारगेट की सीमाएं बहुत सीमित हैं. उपयोगकर्ता को मैप को स्क्रोल या पैन करने का बहुत कम मौका मिलता है. क्रॉस का मतलब है कैमरा टारगेट:

कम से कम या ज़्यादा से ज़्यादा ज़ूम सेट करना

ग्लोबल कॉन्सटेंट kGMSMinZoomLevel और kGMSMaxZoomLevel, कम से कम या ज़्यादा से ज़्यादा ज़ूम वैल्यू. डिफ़ॉल्ट रूप से, minZoom और maxZoom GMSMapView की प्रॉपर्टी इन कॉन्सटेंट पर सेट हैं.

मैप में उपलब्ध ज़ूम लेवल की सीमा सीमित करने के लिए, कम से कम और ज़्यादा से ज़्यादा वैल्यू सेट करें ज़ूम करने का लेवल. यहां दिया गया कोड, ज़ूम लेवल को 10 से 15 के बीच पर सेट करता है.

let camera = GMSCameraPosition(
  latitude: 41.887,
  longitude: -87.622,
  zoom: 12
)
let mapView = GMSMapView(frame: .zero, camera: camera)
mapView.setMinZoom(10, maxZoom: 15)
      

GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:41.887
                                                       longitude:-87.622
                                                             zoom:12];
GMSMapView *mapView = [GMSMapView mapWithFrame:CGRectZero
                                        camera:camera];
[mapView setMinZoom:10 maxZoom:15];
      

आपको ज़ूम रेंज, setMinZoom:maxZoom: तरीके से सेट करनी होगी; हालांकि, आपको minZoom और maxZoom प्रॉपर्टी का इस्तेमाल करके, मौजूदा वैल्यू को पढ़ सकता है. यह अप्रोच का इस्तेमाल करना फ़ायदेमंद होता है. यह कोड सिर्फ़ ज़ूम के कम से कम लेवल में बदलाव करता है.

mapView.setMinZoom(12, maxZoom: mapView.maxZoom)
      

[mapView setMinZoom:12 maxZoom:mapView.maxZoom];
      

अगर कम से कम और ज़्यादा से ज़्यादा ज़ूम को अपडेट करने के बाद, कैमरे का ज़ूम लेवल मान नई सीमा से बाहर है, तो वर्तमान ज़ूम अपने आप सबसे करीबी मान्य वैल्यू दिखाता है. उदाहरण के लिए, नीचे दिए गए कोड में, ओरिजनल ज़ूम को 4 से दिखाया गया है. जब ज़ूम करने की सीमा बाद में 10-15 पर सेट की जाती है, मौजूदा ज़ूम को बदलकर 10 कर दिया गया है.

// Sets the zoom level to 4.
let camera2 = GMSCameraPosition(
  latitude: 41.887,
  longitude: -87.622,
  zoom: 4
)
let mapView2 = GMSMapView(frame: .zero, camera: camera)

// The current zoom, 4, is outside of the range. The zoom will change to 10.
mapView.setMinZoom(10, maxZoom: 15)
      

// Sets the zoom level to 4.
GMSCameraPosition *camera2 = [GMSCameraPosition cameraWithLatitude:41.887
                                                         longitude:-87.622
                                                              zoom:4];
GMSMapView *mapView2 = [GMSMapView mapWithFrame:CGRectZero
                                         camera:camera];
// The current zoom, 4, is outside of the range. The zoom will change to 10.
[mapView setMinZoom:10 maxZoom:15];