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

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

iOS के लिए मैप 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 का मतलब है मैप पर सबसे ऊपर, दक्षिण की ओर.

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

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

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

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

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

कैमरे का वीडियो देखने के लिए डिफ़ॉल्ट ऐंगल.

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

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

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

इस स्क्रीनशॉट में मौजूद मैप, अब भी उसी जगह पर मौजूद है जो मूल मैप में है. हालांकि, मैप के सबसे ऊपर इसके लिए और सुविधाएं दिखाई गई हैं. जब आप 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 ऑब्जेक्ट बनाया जा सकता है. इसके बाद, 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 ऑब्जेक्ट भी बनाया जा सकता है. कैमरे को 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];
      

नीचे दिए गए उदाहरण में, 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: तरीके यहां सेट किए गए इनसेट के अलावा, 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];