कैमरा और व्यू

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

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

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

मैप का व्यू

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

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

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

टारगेट (जगह)

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

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

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

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

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

झुकाव (व्यूइंग ऐंगल)

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

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

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

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

ज़ूम लेवल

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

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

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

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

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

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

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

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

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

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

// 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 options = GMSMapViewOptions()
options.camera = camera
let mapView = GMSMapView(options: options)
mapView.setMinZoom(10, maxZoom: 15)
      

GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:41.887
                                                       longitude:-87.622
                                                             zoom:12];
GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
options.camera = camera;
GMSMapView *mapView = [[GMSMapView alloc] initWithOptions:options];
[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 options2 = GMSMapViewOptions()
options2.camera = camera2
let mapView2 = GMSMapView(options: options2)

// The current zoom, 4, is outside of the range. The zoom will change to 10.
mapView2.setMinZoom(10, maxZoom: 15)
      

// Sets the zoom level to 4.
GMSCameraPosition *camera2 = [GMSCameraPosition cameraWithLatitude:41.887
                                                         longitude:-87.622
                                                              zoom:4];
GMSMapViewOptions *options2 = [[GMSMapViewOptions alloc] init];
options2.camera = camera2;
GMSMapView *mapView2 = [[GMSMapView alloc] initWithOptions:options2];
// The current zoom, 4, is outside of the range. The zoom will change to 10.
[mapView setMinZoom:10 maxZoom:15];