शेप्स

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

iOS के लिए Maps SDK टूल, आपको अपने मैप में आकार जोड़ने के कुछ आसान तरीके उपलब्ध कराता है. नीचे दिए गए आकार का इस्तेमाल किया जा सकता है:

• पॉलीलाइन, जुड़े हुए लाइन सेगमेंट की सीरीज़ होती है. इससे अपनी पसंद का कोई भी आकार बनाया जा सकता है. इसका इस्तेमाल मैप पर पाथ और रास्तों को मार्क करने के लिए किया जा सकता है.
• पॉलीगॉन एक बंद आकार होता है, जिसका इस्तेमाल मैप के क्षेत्रों को मार्क करने के लिए किया जा सकता है.
• वृत्त भौगोलिक रूप से पृथ्वी की सतह पर वृत्त का सटीक प्रोजेक्शन होता है.

आप कई तरीकों से हर आकार के लुक को बदल सकते हैं.

पॉलीलाइन

पॉलीलाइन से आप मैप पर लाइनें बना सकते हैं. GMSPolyline ऑब्जेक्ट, जगहों के क्रम को दिखाता है. इन्हें लाइन सेगमेंट की सीरीज़ के तौर पर दिखाया जाता है. GMSStrokeStyle की मदद से, पॉलीलाइन का रंग सेट किया जा सकता है.

पॉलीलाइन बनाने के लिए, आपको दो या ज़्यादा पॉइंट से जुड़े GMSMutablePath ऑब्जेक्ट को बनाकर, इसके पाथ की जानकारी देनी होगी. हर CLLocationCoordinate2D, पृथ्वी की सतह पर एक पॉइंट को दिखाता है. लाइन सेगमेंट, पॉइंट के बीच उसी क्रम में बनाए जाते हैं जिस क्रम में उन्हें पाथ में जोड़ा जाता है. addCoordinate: या addLatitude:longitude: तरीकों का इस्तेमाल करके, पाथ में पॉइंट जोड़े जा सकते हैं.

Swift

let path = GMSMutablePath()
path.add(CLLocationCoordinate2D(latitude: -33.85, longitude: 151.20))
path.add(CLLocationCoordinate2D(latitude: -33.70, longitude: 151.40))
path.add(CLLocationCoordinate2D(latitude: -33.73, longitude: 151.41))
let polyline = GMSPolyline(path: path)
      

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addCoordinate:CLLocationCoordinate2DMake(-33.85, 151.20)];
[path addCoordinate:CLLocationCoordinate2DMake(-33.70, 151.40)];
[path addCoordinate:CLLocationCoordinate2DMake(-33.73, 151.41)];
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
      

पॉलीलाइन जोड़ना

1. कोई GMSMutablePath ऑब्जेक्ट बनाएं.
2. addCoordinate: या addLatitude:longitude: तरीकों की मदद से, पाथ में पॉइंट सेट करें.
3. पाथ को आर्ग्युमेंट के तौर पर इस्तेमाल करके, नया GMSPolyline ऑब्जेक्ट इंस्टैंशिएट करें.
4. अपने हिसाब से, strokeWidth और strokeColor जैसी अन्य प्रॉपर्टी सेट करें.
5. GMSPolyline की map प्रॉपर्टी को सेट करें.
6. पॉलीलाइन मैप पर दिखेगी.

यह कोड स्निपेट, मैप पर एक रेक्टैंगल जोड़ता है:

Swift

let rectanglePath = GMSMutablePath()
rectanglePath.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.0))
rectanglePath.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.0))
rectanglePath.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.2))
rectanglePath.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.2))
rectanglePath.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.0))

let rectangle = GMSPolyline(path: path)
rectangle.map = mapView
      

Objective-C

GMSMutablePath *rectanglePath = [GMSMutablePath path];
[rectanglePath addCoordinate:CLLocationCoordinate2DMake(37.36, -122.0)];
[rectanglePath addCoordinate:CLLocationCoordinate2DMake(37.45, -122.0)];
[rectanglePath addCoordinate:CLLocationCoordinate2DMake(37.45, -122.2)];
[rectanglePath addCoordinate:CLLocationCoordinate2DMake(37.36, -122.2)];
[rectanglePath addCoordinate:CLLocationCoordinate2DMake(37.36, -122.0)];

GMSPolyline *rectangle = [GMSPolyline polylineWithPath:path];
rectangle.map = mapView;
      

पॉलीलाइन हटाना

अपने GMSPolyline की map प्रॉपर्टी को nil पर सेट करके, मैप से कोई पॉलीलाइन हटाई जा सकती है. इसके अलावा, मैप पर मौजूद सभी ओवरले (पॉलीलाइन और दूसरे आकार भी शामिल हैं) हटाए जा सकते हैं. इसके लिए, GMSMapView clear तरीके का इस्तेमाल करें.

Swift

mapView.clear()
      

Objective-C

[mapView clear];
      

पॉलीलाइन को पसंद के मुताबिक बनाना

GMSPolyline ऑब्जेक्ट, लाइन की थीम को कंट्रोल करने के लिए कई प्रॉपर्टी देता है. यह इन विकल्पों का इस्तेमाल करता है:

strokeWidth

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

geodesic

YES होने पर, इस पॉलीलाइन किनारे को जियोडेसिक के रूप में रेंडर करें. जियोडेसिक सेगमेंट, पृथ्वी की सतह पर मौजूद सबसे छोटे पाथ का इस्तेमाल करते हैं. ये सेगमेंट, मैप पर मरकेटर प्रोजेक्शन की मदद से घुमावदार लाइनों के तौर पर दिख सकते हैं. नॉन-जियोडेसिक सेगमेंट को मैप पर सीधी लाइनों के तौर पर दिखाया जाता है. डिफ़ॉल्ट वैल्यू NO होती है.

spans

इसका इस्तेमाल, पॉलीलाइन के एक या उससे ज़्यादा सेगमेंट का रंग बताने के लिए किया जाता है. spans प्रॉपर्टी, GMSStyleSpan ऑब्जेक्ट की कैटगरी है. पॉलीलाइन का रंग बदलने के लिए, spans प्रॉपर्टी को सेट करना सबसे ज़्यादा पसंद किया जाता है.

strokeColor

पॉलीलाइन का रंग बताने वाला UIColor ऑब्जेक्ट. डिफ़ॉल्ट वैल्यू blueColor होती है. अगर spans को सेट किया गया है, तो strokeColor प्रॉपर्टी को नज़रअंदाज़ किया जाता है.

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

Swift

let path = GMSMutablePath()
path.addLatitude(-37.81319, longitude: 144.96298)
path.addLatitude(-31.95285, longitude: 115.85734)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 10.0
polyline.geodesic = true
polyline.map = mapView
      

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addLatitude:-37.81319 longitude:144.96298];
[path addLatitude:-31.95285 longitude:115.85734];
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.strokeWidth = 10.f;
polyline.geodesic = YES;
polyline.map = mapView;
      

पॉलीलाइन को मैप में जोड़ने के बाद उसमें बदलाव करने के लिए, GMSPolyline ऑब्जेक्ट को दबाकर रखें.

Swift

polyline.strokeColor = .blue
      

Objective-C

polyline.strokeColor = [UIColor blueColor];
      

पॉलीलाइन का रंग बदलना

पॉलीलाइन, मैप पर सेगमेंट की सीरीज़ के तौर पर बनाई गई हैं. spans प्रॉपर्टी से अलग-अलग सेगमेंट या पूरी लाइन का रंग बदला जा सकता है. इस प्रॉपर्टी से आपको पॉलीलाइन को कलर करने पर पूरा कंट्रोल मिलता है. हालांकि, ऐसी कई सुविधाएं भी मौजूद हैं जिनकी मदद से, पूरी लाइन में एक स्टाइल लागू करना आसान हो जाता है.

नीचे दिया गया स्निपेट पूरी लाइन का रंग लाल करने के लिए, spanWithColor: तरीके का इस्तेमाल करता है.

Swift

polyline.spans = [GMSStyleSpan(color: .red)]
      

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithColor:[UIColor redColor]]];
      

इसके अलावा, अगर आपके पास पहले से किसी GMSStrokeStyle ऑब्जेक्ट का ऐक्सेस है, तो आप spanWithStyle: तरीके का इस्तेमाल कर सकते हैं.

Swift

let solidRed = GMSStrokeStyle.solidColor(.red)
polyline.spans = [GMSStyleSpan(style: solidRed)]
      

Objective-C

GMSStrokeStyle *solidRed = [GMSStrokeStyle solidColor:[UIColor redColor]];
polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed]];
      

iOS के लिए Maps SDK टूल के वर्शन 1.7 से पहले के वर्शन में, GMSPolyline का पूरा रंग सेट करने के लिए सिर्फ़ strokeColor प्रॉपर्टी उपलब्ध थी. spans प्रॉपर्टी को strokeColor प्रॉपर्टी के मुकाबले प्राथमिकता दी जाती है.

Swift

polyline.strokeColor = .red
      

Objective-C

polyline.strokeColor = [UIColor redColor];
      

स्टाइल

अगर आपका ऐप्लिकेशन एक ही स्ट्रोक रंग को कई बार लागू करता है, तो फिर से इस्तेमाल की जा सकने वाली स्टाइल तय करना आपके लिए उपयोगी हो सकता है. पॉलीलाइन स्टाइल, GMSStrokeStyle ऑब्जेक्ट का इस्तेमाल करके तय की जाती हैं. स्ट्रोक स्टाइल या तो एक ठोस रंग हो सकती है या फिर एक रंग से दूसरे रंग में ग्रेडिएंट हो सकता है. कोई स्टाइल बनाने के बाद, उसे spanWithStyle: तरीके का इस्तेमाल करके, GMSStyleSpan पर लागू किया जा सकता है.

Swift

// Create two styles: one that is solid blue, and one that is a gradient from red to yellow
let solidBlue = GMSStrokeStyle.solidColor(.blue)
let solidBlueSpan = GMSStyleSpan(style: solidBlue)
let redYellow = GMSStrokeStyle.gradient(from: .red, to: .yellow)
let redYellowSpan = GMSStyleSpan(style: redYellow)
      

Objective-C

// Create two styles: one that is solid blue, and one that is a gradient from red to yellow
GMSStrokeStyle *solidBlue = [GMSStrokeStyle solidColor:[UIColor blueColor]];
GMSStyleSpan *solidBlueSpan = [GMSStyleSpan spanWithStyle:solidBlue];
GMSStrokeStyle *redYellow =
    [GMSStrokeStyle gradientFromColor:[UIColor redColor] toColor:[UIColor yellowColor]];
GMSStyleSpan *redYellowSpan = [GMSStyleSpan spanWithStyle:redYellow];
      

span का स्टाइल, पॉलीलाइन के खत्म होने तक या नई स्टाइल सेट होने तक जारी रहेगा. आप पॉलीलाइन की spans प्रॉपर्टी को सिंगल GMSStyleSpan पर सेट करके पूरी लाइन का रंग बदल सकते हैं. नीचे दिया गया स्निपेट बताता है कि पॉलीलाइन की पूरी लंबाई में ग्रेडिएंट कैसे लागू करें.

Swift

polyline.spans = [GMSStyleSpan(style: redYellow)]
      

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithStyle:redYellow]];
      

अलग-अलग लाइन सेगमेंट का रंग बदलना

अगर आपको अपनी पॉलीलाइन के हर सेगमेंट को अलग-अलग स्टाइल में स्टाइल करना हो, तो GMSStyleSpan ऑब्जेक्ट की एक कैटगरी बनाकर, उसे spans प्रॉपर्टी को पास करें. डिफ़ॉल्ट रूप से, कलेक्शन का हर आइटम उससे जुड़े लाइन सेगमेंट का कलर सेट करेगा. अगर ऐरे में मौजूद एलिमेंट की संख्या, लाइन में मौजूद सेगमेंट से ज़्यादा है, तो अतिरिक्त एलिमेंट को अनदेखा कर दिया जाएगा. अगर अरे में कम एलिमेंट हैं, तो आखिरी GMSStyleSpan लाइन के बचे हुए रंग के बारे में बताएगा.

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

Swift

polyline.spans = [
  GMSStyleSpan(style: solidRed),
  GMSStyleSpan(style: solidRed),
  GMSStyleSpan(style: redYellow)
]
      

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed],
                   [GMSStyleSpan spanWithStyle:solidRed],
                   [GMSStyleSpan spanWithStyle:redYellow]];
      

एक साथ कई सेगमेंट की स्टाइल सेट करने के लिए, spanWithStyle:segments: तरीके का इस्तेमाल किया जा सकता है. उदाहरण के लिए, नीचे दिया गया कोड ऊपर दिए गए कोड के बराबर है. आखिरी GMSStyleSpan के सेगमेंट की लंबाई को हमेशा अनदेखा कर दिया जाएगा, क्योंकि स्टाइल का इस्तेमाल लाइन के बाकी हिस्सों के बारे में बताने के लिए किया जाएगा.

Swift

polyline.spans = [
  GMSStyleSpan(style: solidRed, segments:2),
  GMSStyleSpan(style: redYellow, segments:10)
]
      

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed segments:2],
                   [GMSStyleSpan spanWithStyle:redYellow segments:10]];
      

दशमलव वाले सेगमेंट

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

Swift

polyline.spans = [
  GMSStyleSpan(style: solidRed, segments: 2.5),
  GMSStyleSpan(color: .gray),
  GMSStyleSpan(color: .purple, segments: 0.75),
  GMSStyleSpan(style: redYellow)
]
      

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed segments:2.5],
                   [GMSStyleSpan spanWithColor:[UIColor grayColor]],
                   [GMSStyleSpan spanWithColor:[UIColor purpleColor] segments:0.75],
                   [GMSStyleSpan spanWithStyle:redYellow]];
      

पॉलीलाइन में दोहराए जाने वाले रंग का पैटर्न जोड़ना

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

उदाहरण के लिए, नीचे दिया गया कोड स्निपेट काले और सफ़ेद रंग में बदलने वाले पैटर्न वाली पॉलीलाइन के बारे में बताता है. इसकी लंबाई को रंब लाइन से मीटर के तौर पर माना जाता है (मरकेटर में, यह एक सीधी लाइन है) क्योंकि टाइप के बारे में kGMSLengthRhumb बताया गया है.

Swift

let styles = [
  GMSStrokeStyle.solidColor(.white),
  GMSStrokeStyle.solidColor(.black)
]
let lengths: [NSNumber] = [100000, 50000]
polyline.spans = GMSStyleSpans(
  polyline.path!,
  styles,
  lengths,
  GMSLengthKind.rhumb
)
      

Objective-C

NSArray *styles = @[[GMSStrokeStyle solidColor:[UIColor whiteColor]],
                    [GMSStrokeStyle solidColor:[UIColor blackColor]]];
NSArray *lengths = @[@100000, @50000];
polyline.spans = GMSStyleSpans(polyline.path, styles, lengths, kGMSLengthRhumb);
      

स्प्राइट स्टैंप वाली पॉलीलाइन

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

इस सुविधा को इस्तेमाल करने के लिए, GMSSpriteStyle का इस्तेमाल करें और GMSStrokeStyle की stampStyle प्रॉपर्टी के ज़रिए इसे स्टैंप के तौर पर सेट करें.

Swift

let path = GMSMutablePath()
path.addLatitude(-37.81319, longitude: 144.96298)
path.addLatitude(-31.95285, longitude: 115.85734)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 20
let image = UIImage(named: "imageFromBundleOrAsset")! // Image could be from anywhere
let stampStyle = GMSSpriteStyle(image: image)
let transparentStampStroke = GMSStrokeStyle.transparentStroke(withStamp: stampStyle)
let span = GMSStyleSpan(style: transparentStampStroke)
polyline.spans = [span]
polyline.map = mapView
      

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addLatitude:-37.81319 longitude:144.96298];
[path addLatitude:-31.95285 longitude:115.85734];
polyline.strokeWidth = 20;
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];

UIImage *image = [UIImage imageNamed:@"imageFromBundleOrAsset"];
GMSStrokeStyle *transparentStampStroke = [GMSStrokeStyle transparentStrokeWithStampStyle:[GMSSpriteStyle spriteStyleWithImage:image]];

GMSStyleSpan *span = [GMSStyleSpan spanWithStyle:transparentStampStroke];
polyline.spans = @[span];
polyline.map = _mapView;
      

ध्यान दें: स्प्राइट स्टैंप वाली पॉलीलाइन के लिए, मेटल फ़्रेमवर्क ज़रूरी है. आपके पास GMSMapView पर mapCapabilities को प्रोग्राम के हिसाब से देखकर, यह पुष्टि करने का विकल्प होता है कि आपके मैप व्यू में स्प्राइट स्टैंप दिख रहा है या नहीं.

टेक्सचर स्टैंप वाली पॉलीलाइन

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

इस सुविधा को इस्तेमाल करने के लिए, GMSTextureStyle का इस्तेमाल करें और GMSStrokeStyle की stampStyle प्रॉपर्टी के ज़रिए इसे स्टैंप के तौर पर सेट करें.

Swift

let path = GMSMutablePath()
path.addLatitude(-37.81319, longitude: 144.96298)
path.addLatitude(-31.95285, longitude: 115.85734)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 20
let redWithStamp = GMSStrokeStyle.solidColor(.red)
let image = UIImage(named: "imageFromBundleOrAsset")! // Image could be from anywhere
redWithStamp.stampStyle = GMSTextureStyle(image: image)
let span = GMSStyleSpan(style: redWithStamp)
polyline.spans = [span]
polyline.map = mapView
      

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addLatitude:-37.81319 longitude:144.96298];
[path addLatitude:-31.95285 longitude:115.85734];
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.strokeWidth = 20;
GMSStrokeStyle *redWithStamp = [GMSStrokeStyle solidColor:[UIColor redColor]];

UIImage *image = [UIImage imageNamed:@"imageFromBundleOrAsset"]; // Image could be from anywhere
redWithStamp.stampStyle = [GMSTextureStyle textureStyleWithImage:image];

GMSStyleSpan *span = [GMSStyleSpan spanWithStyle:redWithStamp];
polyline.spans = @[span];
polyline.map = _mapView;
      

मैप क्षमताएं

GMSMapView पर mapCapabilities प्रॉपर्टी, मैप से जुड़ी खास सुविधाओं के लिए प्रोग्राम के हिसाब से, अपने-आप होने वाली जांच की सुविधा जोड़ती है. यह तब काम आता है, जब यह जानना हो कि किसी खास एपीआई को कॉल करने से पहले, कुछ मैप capabilities उपलब्ध हैं या नहीं. इस क्वेरी से पता चलता है कि मैप व्यू, स्प्राइट स्टैंप्ड पॉलीलाइन के साथ काम करता है या नहीं.

Swift

let path = GMSMutablePath()
path.addLatitude(-37.81319, longitude: 144.96298)
path.addLatitude(-31.95285, longitude: 115.85734)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 20
let image = UIImage(named: "imageFromBundleOrAsset")! // Image could be from anywhere
let spans: [GMSStyleSpan]
if (mapView.mapCapabilities.contains(.spritePolylines)) {
  let spriteStyle = GMSSpriteStyle(image: image)
  let stroke = GMSStrokeStyle.transparentStroke(withStamp: spriteStyle)
  spans = [ GMSStyleSpan(style: stroke) ]
} else {
  let stroke = GMSStrokeStyle.solidColor(.clear)
  stroke.stampStyle = GMSTextureStyle(image: image)
  spans = [ GMSStyleSpan(style: stroke) ]
}
polyline.spans = spans
polyline.map = mapView
      

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addLatitude:-37.81319 longitude:144.96298];
[path addLatitude:-31.95285 longitude:115.85734];

UIImage *_Nonnull image = [UIImage imageNamed:@"imageFromBundleOrAsset"]; // Image could be from anywhere

NSArray<GMSStyleSpan *> * spans;
if (_mapView.mapCapabilities & GMSMapCapabilityFlagsSpritePolylines) {
  GMSSpriteStyle *spriteStyle = [GMSSpriteStyle spriteStyleWithImage:image];
  GMSStrokeStyle *stroke = [GMSStrokeStyle transparentStrokeWithStampStyle:spriteStyle];
  spans = @[ [GMSStyleSpan spanWithStyle:stroke] ];
} else {
  GMSStrokeStyle *stroke = [GMSStrokeStyle solidColor:UIColor.clearColor];
  stroke.stampStyle = [GMSTextureStyle textureStyleWithImage:image];
  spans = @[ [GMSStyleSpan spanWithStyle:stroke] ];
}

GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.strokeWidth = 20;
polyline.spans = spans;
polyline.map = _mapView;
      

इस पैटर्न से, आपको अपने मैप व्यू की स्थिति में होने वाले बदलावों की सदस्यता लेने और अपडेट पर प्रतिक्रिया देने की सुविधा मिलती है. सुविधा की उपलब्धता के बारे में अपडेट पाने के लिए, GMSMapViewDelegate पर भी didChangeMapCapabilities को लागू किया जा सकता है.

पॉलीगॉन

पॉलीगॉन, पॉलीलाइन की तरह ही होते हैं, जिनमें क्रम के मुताबिक होते हैं. हालांकि, पॉलीगॉन ओपन-एंडेड के बजाय, बंद लूप में ठोस क्षेत्रों को परिभाषित करने के लिए डिज़ाइन किए गए हैं. iOS के लिए Maps SDK टूल में, पॉलीगॉन के बारे में GMSPolygon क्लास के हिसाब से बताया जाता है.

मैप में GMSPolygon को उसी तरह जोड़ा जा सकता है जिस तरह GMSPolyline को जोड़ा जाता है. सबसे पहले, संबंधित GMSMutablePath ऑब्जेक्ट बनाकर और उसमें पॉइंट जोड़कर इसके पाथ की जानकारी दें. ये बिंदु उस बहुभुज की आउटलाइन बनाएंगे. हर CLLocationCoordinate2D, पृथ्वी की सतह पर एक पॉइंट को दिखाता है. लाइन सेगमेंट, पॉइंट के बीच उस क्रम में बनाए जाते हैं जिस क्रम में उन्हें पाथ में जोड़ा जाता है.

कोई पॉलीगॉन जोड़ें

1. कोई GMSMutablePath ऑब्जेक्ट बनाएं.
2. addCoordinate: या addLatitude:longitude: तरीकों की मदद से, पाथ में पॉइंट सेट करें. ये बिंदु उस पॉलीगॉन की आउटलाइन बनाएंगे.
3. पाथ को आर्ग्युमेंट के तौर पर इस्तेमाल करके, नया GMSPolygon ऑब्जेक्ट इंस्टैंशिएट करें.
4. अपने हिसाब से, strokeWidth, strokeColor, और fillColor जैसी अन्य प्रॉपर्टी सेट करें.
5. GMSPolygon.map प्रॉपर्टी सेट करके, पॉलीगॉन को GMSMapView ऑब्जेक्ट पर असाइन करें.
6. पॉलीगॉन मैप पर दिखेगा.

नीचे दिया गया कोड स्निपेट, मैप में एक रेक्टैंगल जोड़ता है.

Swift

// Create a rectangular path
let rect = GMSMutablePath()
rect.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.0))
rect.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.0))
rect.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.2))
rect.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.2))

// Create the polygon, and assign it to the map.
let polygon = GMSPolygon(path: rect)
polygon.fillColor = UIColor(red: 0.25, green: 0, blue: 0, alpha: 0.05);
polygon.strokeColor = .black
polygon.strokeWidth = 2
polygon.map = mapView
      

Objective-C

// Create a rectangular path
GMSMutablePath *rect = [GMSMutablePath path];
[rect addCoordinate:CLLocationCoordinate2DMake(37.36, -122.0)];
[rect addCoordinate:CLLocationCoordinate2DMake(37.45, -122.0)];
[rect addCoordinate:CLLocationCoordinate2DMake(37.45, -122.2)];
[rect addCoordinate:CLLocationCoordinate2DMake(37.36, -122.2)];

// Create the polygon, and assign it to the map.
GMSPolygon *polygon = [GMSPolygon polygonWithPath:rect];
polygon.fillColor = [UIColor colorWithRed:0.25 green:0 blue:0 alpha:0.05];
polygon.strokeColor = [UIColor blackColor];
polygon.strokeWidth = 2;
polygon.map = mapView;
      

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

बहुभुज निकालना

किसी पॉलीगॉन के GMSPolygon.map प्रॉपर्टी को nil पर सेट करके और layer को उसके पैरंट से अलग करके, उसे हटाएं.

Swift

 polygon.map = nil
 polygon.layer.removeFromSuperLayer()

Objective-C

 polygon.map = nil;
 [polygon.layer removeFromSuperlayer];
 

सर्कल्स

सामान्य GMSPolygon क्लास के अलावा, iOS के लिए Maps SDK टूल में GMSCircle भी शामिल है. इससे पृथ्वी की सतह पर आसानी से सर्कल बनाए जा सकते हैं.

सर्कल बनाने के लिए, आपको नीचे दी गई दो प्रॉपर्टी बतानी होंगी:

• CLLocationCoordinate2D के तौर पर position
• radius मीटर में.

इसके बाद, वृत्त को पृथ्वी की सतह पर उन सभी बिंदुओं का समूह माना जाता है जो दिए गए center से radius मीटर दूर हैं. इसके चलते जैसे Maps API में इस्तेमाल किया जाने वाला मरकेटर प्रोजेक्शन सपाट सतह पर गोला बनाता है, तो भूमध्य रेखा के पास होने पर यह मैप पर करीब सही सर्कल के रूप में दिखता है. साथ ही, जैसे-जैसे वह भूमध्य रेखा से दूर होता जाता है, वैसे-वैसे वह गोल घेरता (स्क्रीन पर) दिखता है.

एक सर्कल जोड़ा जा रहा है

नीचे दिया गया कोड स्निपेट, मैप में एक सर्कल जोड़ता है:

Swift

let circleCenter = CLLocationCoordinate2D(latitude: 37.35, longitude: -122.0)
let circle = GMSCircle(position: circleCenter, radius: 1000)
circle.map = mapView
      

Objective-C

CLLocationCoordinate2D circleCenter = CLLocationCoordinate2DMake(37.35, -122.0);
GMSCircle *circle = [GMSCircle circleWithPosition:circleCenter
                                         radius:1000];
circle.map = mapView;
      

आप सर्कल को मैप में जोड़ने से पहले और मैप पर जोड़ने के बाद, दोनों ही स्थितियों में अपनी पसंद के मुताबिक बना सकते हैं.

सर्कल को पसंद के मुताबिक बनाना

GMSCircle की प्रॉपर्टी में बदलाव करके, अपनी पसंद के मुताबिक रंग और स्ट्रोक की चौड़ाई तय की जा सकती है. यह इन विकल्पों का इस्तेमाल करता है:

fillColor

सर्कल के अंदरूनी रंग को बताने वाला UIColor ऑब्जेक्ट. डिफ़ॉल्ट तौर पर, यह पारदर्शी पर सेट होती है.

strokeColor

UIColor ऑब्जेक्ट, जो सर्कल की आउटलाइन के रंग को बताता है. डिफ़ॉल्ट वैल्यू blackColor होती है.

strokeWidth

स्क्रीन पॉइंट पर, सर्कल की आउटलाइन की मोटाई. डिफ़ॉल्ट वैल्यू 1 होती है. मैप को ज़ूम करने पर, मोटाई कम नहीं होती.

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

Swift

circle.fillColor = UIColor(red: 0.35, green: 0, blue: 0, alpha: 0.05)
circle.strokeColor = .red
circle.strokeWidth = 5
      

Objective-C

circle.fillColor = [UIColor colorWithRed:0.25 green:0 blue:0 alpha:0.05];
circle.strokeColor = [UIColor redColor];
circle.strokeWidth = 5;
      

खोखला बहुभुज बनाना

एक GMSPolygon ऑब्जेक्ट में कई पाथ को मिलाकर, कई जटिल आकार बनाए जा सकते हैं. जैसे, भरे हुए रिंग या डोनट (जहां पॉलीगॉन के अंदर पॉलीगॉन के अंदर अलग-अलग आकार वाले इलाके दिखते हैं). कॉम्प्लेक्स शेप, कई पाथ से मिलकर बने होते हैं.

ऐसा पाथ बनाएं जो पॉलीगॉन में शामिल सबसे बड़े इलाके को दिखाता हो. इसके बाद, पॉलीगॉन के holes गुण को एक या उससे ज़्यादा GMSPath ऑब्जेक्ट की कैटगरी के रूप में तय करें. इससे पॉलीगॉन के अंदर छेद बनेंगे.

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

नीचे दिया गया कोड सैंपल, दो छेदों वाला पॉलीगॉन बनाता है:

Swift

let hydeParkLocation = CLLocationCoordinate2D(latitude: -33.87344, longitude: 151.21135)
let camera = GMSCameraPosition.camera(withTarget: hydeParkLocation, zoom: 16)
let mapView = GMSMapView.map(withFrame: .zero, camera: camera)
mapView.animate(to: camera)

let hydePark = "tpwmEkd|y[QVe@Pk@BsHe@mGc@iNaAKMaBIYIq@qAMo@Eo@@[Fe@DoALu@HUb@c@XUZS^ELGxOhAd@@ZB`@J^BhFRlBN\\BZ@`AFrATAJAR?rAE\\C~BIpD"
let archibaldFountain = "tlvmEqq|y[NNCXSJQOB[TI"
let reflectionPool = "bewmEwk|y[Dm@zAPEj@{AO"

let hollowPolygon = GMSPolygon()
hollowPolygon.path = GMSPath(fromEncodedPath: hydePark)
hollowPolygon.holes = [GMSPath(fromEncodedPath: archibaldFountain)!, GMSPath(fromEncodedPath: reflectionPool)!]
hollowPolygon.fillColor = UIColor(red: 1.0, green: 0.0, blue: 0.0, alpha: 0.2)
hollowPolygon.strokeColor = UIColor(red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)
hollowPolygon.strokeWidth = 2
hollowPolygon.map = mapView
      

Objective-C

CLLocationCoordinate2D hydeParkLocation = CLLocationCoordinate2DMake(-33.87344, 151.21135);
GMSCameraPosition *camera = [GMSCameraPosition cameraWithTarget:hydeParkLocation
                                                           zoom:16];
mapView = [GMSMapView mapWithFrame:CGRectZero camera:camera];

NSString *hydePark = @"tpwmEkd|y[QVe@Pk@BsHe@mGc@iNaAKMaBIYIq@qAMo@Eo@@[Fe@DoALu@HUb@c@XUZS^ELGxOhAd@@ZB`@J^BhFRlBN\\BZ@`AFrATAJAR?rAE\\C~BIpD";
NSString *archibaldFountain = @"tlvmEqq|y[NNCXSJQOB[TI";
NSString *reflectionPool = @"bewmEwk|y[Dm@zAPEj@{AO";

GMSPolygon *hollowPolygon = [[GMSPolygon alloc] init];
hollowPolygon.path = [GMSPath pathFromEncodedPath:hydePark];
hollowPolygon.holes = @[[GMSPath pathFromEncodedPath:archibaldFountain],
                  [GMSPath pathFromEncodedPath:reflectionPool]];
hollowPolygon.fillColor = [UIColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:0.2];
hollowPolygon.strokeColor = [UIColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:1.0];
hollowPolygon.strokeWidth = 2;
hollowPolygon.map = mapView;