कैमरा और व्यू

प्लैटफ़ॉर्म चुनें: Android iOS JavaScript

iOS के लिए Maps SDK टूल की मदद से, मैप का कैमरा बदलकर मैप के लोगों का व्यूपॉइंट बदला जा सकता है.

iOS के लिए Maps SDK टूल की मदद से, उपयोगकर्ता आपके मैप को घुमा और झुका सकते हैं, ताकि वे उस ओरिएंटेशन में बदल सकें जो उनके लिए काम का हो. किसी भी ज़ूम लेवल पर, उपयोगकर्ता मैप को पैन कर सकते हैं या बहुत कम इंतज़ार के समय के साथ इसका ऐंगल बदल सकते हैं.

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

मैप का व्यू

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

ध्यान दें: मर्केटर प्रोजेक्शन में लंबाई और जगह की लंबाई कम से कम (उत्तर/दक्षिण) होती है, लेकिन अक्षांश और देशांतर में अनंत चौड़ाई होती है. इस विशेषता का मतलब है कि मैप व्यू, पूर्व और पश्चिम की ओर असीमित समय तक दोहराया जाता है. उत्तर और दक्षिण दिशा में, बेस मैप की तस्वीरों को करीब +/- 85 डिग्री पर मर्केटर प्रोजेक्शन का इस्तेमाल करके काटा जाता है. इससे मैप का आकार वर्गाकार बनता है, जिससे टाइल चुनने में आसानी होती है.

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

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

टारगेट (जगह)

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

अक्षांश -85 और 85 डिग्री के बीच हो सकता है. इस रेंज से कम या ज़्यादा की वैल्यू को, इस रेंज में मौजूद सबसे पास की वैल्यू के साथ शामिल किया जाएगा. उदाहरण के लिए, अक्षांश 100 तय करने पर वैल्यू 85 सेट हो जाएगी. देशांतर की सीमा -180 से 180 डिग्री के बीच होती है. इस रेंज से ऊपर या नीचे की वैल्यू को इस तरह से रैप किया जाएगा कि वे रेंज (-180, 180) के दायरे में आएं. उदाहरण के लिए, 480, 840, और 1200, सभी को 120 डिग्री में रैप किया जाएगा.

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

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

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

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

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

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

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

मैप को कैमरे के डिफ़ॉल्ट व्यू ऐंगल के साथ दिखाया जाता है.

कैमरे का डिफ़ॉल्ट व्यू ऐंगल.

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

मैप को 45 डिग्री के व्यूइंग ऐंगल में दिखाया गया है.

कैमरे के व्यू में 45 डिग्री का ऐंगल.

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

ज़ूम करना

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

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

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

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

ध्यान दें: स्क्रीन के साइज़ और सघनता की वजह से, हो सकता है कि कुछ डिवाइसों पर सबसे कम ज़ूम लेवल काम न करें. मैप के लिए कम से कम ज़ूम लेवल पाने के लिए, GMSMapView की minZoom प्रॉपर्टी का इस्तेमाल करें.

इन इमेज में, अलग-अलग ज़ूम लेवल का विज़ुअल लुक दिखाया गया है:

ज़ूम लेवल 5 पर मौजूद मैप.

ज़ूम लेवल 15 पर मौजूद मैप.

ज़ूम लेवल 20 पर मौजूद मैप.

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

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

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

Swift

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

Objective-C

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

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

Swift

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

Objective-C

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

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

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

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

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

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

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

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

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

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

Swift

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

Objective-C

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

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

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

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

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

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

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

Swift

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

Objective-C

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

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

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

Swift

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

Objective-C

// 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 की मदद से, बाउंडिंग बॉक्स के हर साइड के लिए अलग-अलग पैडिंग (जगह) तय की जा सकती है.

ध्यान दें: fitBounds: के तरीके में, मैप पर आपकी सेट की गई पैडिंग और सीमित किए जाने पर तय की गई पैडिंग, दोनों के बारे में बताया जाता है. उदाहरण के लिए, अगर GMSMapView के आस-पास 100 पॉइंट की पैडिंग (जगह) तय करने के बाद fitBounds: तरीके को इस्तेमाल करने का विकल्प चुना जाता है, तो 100 पॉइंट की कस्टम पैडिंग के साथ-साथ, 64 पॉइंट की डिफ़ॉल्ट पैडिंग (जगह) को भी कैमरे में बदलने से होगा.

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

GMSMapView में ऐसे कई तरीके मौजूद हैं जिनसे कैमरे को मूव करने के लिए, GMSCameraPosition ऑब्जेक्ट या GMSCameraUpdate ऑब्जेक्ट का इस्तेमाल नहीं किया जा सकता. animateToLocation: या animateToZoom: जैसे इन तरीकों का इस्तेमाल करके, सिंगल कैमरा प्रॉपर्टी में होने वाले बदलाव को ऐनिमेट किया जा सकता है.

ध्यान दें: GMSMapView किसी एक प्रॉपर्टी को बदलने के तरीके बताता है. हालांकि, आम तौर पर कैमरे की जगह बदलने के लिए GMSCameraPosition या GMSCameraUpdate का इस्तेमाल किया जाता है. ऐसा तब भी किया जाता है, जब आपको कैमरे की एक से ज़्यादा प्रॉपर्टी में बदलाव करना हो.

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

Swift

mapView.animate(toViewingAngle: 45)
      

Objective-C

[mapView animateToViewingAngle:45];
      

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

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

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

Swift

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

Objective-C

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

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

Swift

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

Objective-C

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

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

Swift

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

Objective-C

// 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: तरीके की मदद से, प्रोग्राम के हिसाब से सेट करें.

Swift

mapView.animate(toBearing: 0)
      

Objective-C

[mapView animateToBearing:0];
      

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

व्यू ऐंगल, कैमरे के चाप पर मैप के बीच की पोज़िशन और पृथ्वी की सतह के बीच की जगह है. इसे नीचे (कैमरे के ठीक नीचे की दिशा) से डिग्री में मापा जाता है. जब आप व्यूइंग ऐंगल में बदलाव करते हैं, तो मैप आपके सामने दिखता है. इसमें कैमरे और मैप की पोज़िशन के बीच की चीज़ें आनुपातिक रूप से बड़ी दिखती हैं. साथ ही, मैप की पोज़िशन से आगे की चीज़ें आनुपातिक रूप से कम दिखती हैं और 3-डाइमेंशन वाला इफ़ेक्ट जनरेट होता है.

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

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

Swift

mapView.animate(toViewingAngle: 45)
      

Objective-C

[mapView animateToViewingAngle:45];
      

ज़ूम सेट करें

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

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

Swift

mapView.animate(toZoom: 12)
      

Objective-C

[mapView animateToZoom:12];
      

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

Swift

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

Objective-C

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

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

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

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

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

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

Swift

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
      

Objective-C

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;
      

ध्यान दें: cameraForBounds:insets: तरीका यहां दिए गए इनसेट के अलावा, GMSMapView पर सेट की गई पैडिंग का भी इस्तेमाल करता है.

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

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

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

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

Swift

mapView.cameraTargetBounds = bounds
      

Objective-C

mapView.cameraTargetBounds = bounds;
      

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

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

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

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

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

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

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

Swift

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

Objective-C

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 प्रॉपर्टी का इस्तेमाल करके, मौजूदा वैल्यू को पढ़ा जा सकता है. यह तरीका तब मददगार होता है, जब सिर्फ़ एक वैल्यू को सीमित किया जाता है. नीचे दिया गया कोड सिर्फ़ ज़ूम के कम से कम लेवल में बदलाव करता है.

Swift

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

Objective-C

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

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

Swift

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

Objective-C

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