कैमरा और व्यू

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

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

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

मैप का व्यू

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

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

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

टारगेट (जगह)

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

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

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

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

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

झुकाव (देखने का ऐंगल)

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

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

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

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

ज़ूम करें

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

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

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

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

कैमरे की शुरुआती पोज़िशन सेट करना

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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: तरीके में पास करके कैमरे को अपडेट करें.

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

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

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

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

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

// 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: तरीके का इस्तेमाल करें.

mapView.animate(toViewingAngle: 45)
      

[mapView animateToViewingAngle:45];
      

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

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

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

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

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

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

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

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

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

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

// 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: तरीके का इस्तेमाल करें.

mapView.animate(toBearing: 0)
      

[mapView animateToBearing:0];
      

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

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

व्यू ऐंगल 0 (मैप पर सीधे नीचे की ओर) से लेकर, ज़ूम लेवल पर निर्भर ज़्यादा से ज़्यादा तक हो सकता है. ज़ूम लेवल 16 या उससे ज़्यादा के लिए, ज़्यादा से ज़्यादा ऐंगल 65 डिग्री है. ज़ूम लेवल 10 या उससे कम के लिए, ज़्यादा से ज़्यादा ऐंगल 30 डिग्री होता है.

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

mapView.animate(toViewingAngle: 45)
      

[mapView animateToViewingAngle:45];
      

ज़ूम सेट करना

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

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

mapView.animate(toZoom: 12)
      

[mapView animateToZoom:12];
      

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

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

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

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

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

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

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

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

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
      

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 को शून्य पर सेट करें.

mapView.cameraTargetBounds = bounds
      

mapView.cameraTargetBounds = bounds;
      

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

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

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

ज़ूम करने की कम से कम या ज़्यादा से ज़्यादा वैल्यू सेट करना

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

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

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

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

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

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

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

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

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