कैमरा और व्यू

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

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

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

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

मैप का व्यू

Maps SDK for iOS, मर्केटर प्रोजेक्शन का इस्तेमाल करके, धरती की गोल सतह को आपके डिवाइस की फ़्लैट स्क्रीन पर दिखाता है.

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

कैमरे की पोज़िशन

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

टारगेट (जगह)

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

अक्षांश -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 डिग्री से ज़्यादा बढ़ाने पर, कैमरे और मैप की पोज़िशन के बीच के ऑब्जेक्ट, तुलनात्मक रूप से बड़े दिखते हैं. वहीं, मैप की पोज़िशन से दूर के ऑब्जेक्ट, तुलनात्मक रूप से छोटे दिखते हैं. इससे थ्री-डाइमेंशनल (3D) इफ़ेक्ट मिलता है.

ज़ूम लेवल

कैमरे के ज़ूम लेवल से, मैप का स्केल तय होता है. ज़्यादा ज़ूम करने पर, स्क्रीन पर ज़्यादा जानकारी दिखती है. वहीं, कम ज़ूम करने पर, स्क्रीन पर दुनिया का ज़्यादा हिस्सा दिखता है. ज़ूम लेवल 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 init तरीके का इस्तेमाल करके भी 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 प्रॉपर्टी को शामिल न करें जिसे आपको डिफ़ॉल्ट वैल्यू पर सेट करना है.

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

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

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

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

जगह की जानकारी बदलने के लिए, 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];
      

झुकाव (व्यूइंग ऐंगल) सेट करना

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

व्यूइंग ऐंगल, 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];