कैमरा और दृश्य

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

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

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

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

मैप का व्यू

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

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

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

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

टारगेट (जगह)

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

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

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

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

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

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

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

टिल्ट, मैप के केंद्र की स्थिति पर आर्क पर सीधे तौर पर कैमरे की स्थिति तय करता है, जिसे नदीर से डिग्री में मापा जाता है (कैमरे के ठीक नीचे बताई गई दिशा). 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 ऑब्जेक्ट का इस्तेमाल करें, जिससे आप भालू के निशान, झुकाव, और ज़ूम के साथ टारगेट का अक्षांश और देशांतर सेट कर पाएंगे.

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

Swift

let camera = GMSCameraPosition(
  latitude: -33.8683,
  longitude: 151.2086,
  zoom: 16
)
mapView = GMSMapView(frame: self.view.bounds, camera: camera)
      

Objective-C

GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:-33.8683
                                                        longitude:151.2086
                                                             zoom:16];
mapView = [GMSMapView mapWithFrame:self.view.bounds camera:camera];
      

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

Swift

mapView = GMSMapView(frame: self.view.bounds)
      

Objective-C

mapView = [[GMSMapView alloc] initWithFrame:self.view.bounds];
      

कैमरे की जगह बदलना

जगह की जानकारी, बियरिंग, टिल्ट, और ज़ूम सेट करने के लिए, अपने-आप कैमरे की पोज़िशन बदली जा सकती है. 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 ऑब्जेक्ट बनाया जा सकता है. इसके बाद, GMSMapView ऑब्जेक्ट animateWithCameraUpdate: की मदद से 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];
      

इसके बजाय, कैमरे को किसी नई पोज़िशन पर ले जाने के लिए, 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: तरीके को कॉल करते हैं, तो कैमरा ट्रांज़िशन, डिफ़ॉल्ट पैडिंग के 64 पॉइंट के लिए होता है. साथ ही, कस्टम पैडिंग के 100 पॉइंट भी शामिल होता है.

किसी एक प्रॉपर्टी को बदलने के लिए, 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 ऑब्जेक्ट भी बनाया जा सकता है. {0/} में कैमरे को स्क्रोल करने के लिए पॉइंट की संख्या बताने के लिए, पहले से मौजूद तरीके 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];
      

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

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: पर 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];