कैमरा और व्यू

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

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

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

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

मैप का व्यू

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

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

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

कैमरे की प्रॉपर्टी का डायग्राम

लक्ष्य (स्थान)

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

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

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

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

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

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

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

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

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

मैप का स्क्रीनशॉट, जिसमें कैमरे को 0 डिग्री व्यू ऐंगल पर रखा गया है और उसे 18 के ज़ूम लेवल पर रखा गया है.
मैप, कैमरे के डिफ़ॉल्ट व्यू ऐंगल के साथ दिखता है.
सीधे मैप की स्थिति के ऊपर, 0 डिग्री के कोण पर कैमरे की डिफ़ॉल्ट स्थिति दिखाने वाला डायग्राम.
कैमरे का डिफ़ॉल्ट व्यू ऐंगल.

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

एक मैप का स्क्रीनशॉट, जिसमें कैमरे को 18 के ज़ूम लेवल पर 45 डिग्री व्यू ऐंगल पर रखा गया है.
मैप में 45 डिग्री देखने का कोण दिखाया गया है.
डायग्राम में दिखाया गया है कि कैमरे का व्यू ऐंगल 45 डिग्री पर सेट है, लेकिन ज़ूम लेवल अब भी 18 पर सेट है.
कैमरे का 45 डिग्री का व्यू ऐंगल.

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

Zoom

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

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

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

  • 1: दुनिया
  • 5: मैदान/महाद्वीप
  • 10: शहर
  • 15: सड़कें
  • 20: इमारतें
नीचे दी गई इमेज में, ज़ूम के अलग-अलग लेवल का विज़ुअल लुक दिखाया गया है:
मैप का स्क्रीनशॉट, जिसका ज़ूम लेवल 5 है
ज़ूम लेवल 5 पर मैप.
मैप का 15 के ज़ूम स्तर पर स्क्रीनशॉट
ज़ूम लेवल 15 पर मैप.
ज़ूम लेवल 20 पर मैप का स्क्रीनशॉट
ज़ूम लेवल 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 का इस्तेमाल करने पर, आपको बाउंडिंग बॉक्स के हर साइड के लिए अलग-अलग पैडिंग (जगह) तय करनी होती है.

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

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

उदाहरण के लिए, कैमरा टिल्ट में किसी बदलाव को ऐनिमेट करने के लिए, 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 ऑब्जेक्ट भी बनाया जा सकता है. X और Y निर्देशों में कैमरे को स्क्रोल करने पर पॉइंट की संख्या बताने के लिए, इसमें पहले से मौजूद तरीके scrollByX: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];
      

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

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

देखने का ऐंगल 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;
      

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

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

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

पैनिंग को किसी खास सीमा तक सीमित करने के लिए, 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];