आकृतियां

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

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

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

हर आकार के दिखने के तरीके में कई तरह से बदलाव किया जा सकता है.

पॉलीलाइन

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

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

SwiftObjective-C

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)
      

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. पॉलीलाइन, मैप पर दिखती है.

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

SwiftObjective-C

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
      

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 तरीके का इस्तेमाल करके, मैप पर मौजूद सभी ओवरले (इनमें पॉलीलाइन और अन्य आकार भी शामिल हैं) हटाए जा सकते हैं.

SwiftObjective-C

mapView.clear()
      

[mapView clear];
      

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

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

strokeWidth

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

geodesic

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

spans

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

strokeColor

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

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

SwiftObjective-C

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
      

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 ऑब्जेक्ट को दबाकर रखें.

SwiftObjective-C

polyline.strokeColor = .blue
      

polyline.strokeColor = [UIColor blueColor];
      

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

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

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

SwiftObjective-C

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

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

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

SwiftObjective-C

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

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

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

SwiftObjective-C

polyline.strokeColor = .red
      

polyline.strokeColor = [UIColor redColor];
      

स्टाइल

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

SwiftObjective-C

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

// 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 पर सेट करके, पूरी लाइन का रंग बदला जा सकता है. उदाहरण में, पॉलीलाइन की पूरी लंबाई पर ग्रेडिएंट लागू करने का तरीका दिखाया गया है.

SwiftObjective-C

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

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

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

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

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

SwiftObjective-C

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

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

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

SwiftObjective-C

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

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

फ़्रैक्शनल सेगमेंट

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

SwiftObjective-C

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

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

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

SwiftObjective-C

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

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 प्रॉपर्टी का इस्तेमाल करके, इसे स्टैंप के तौर पर सेट करें.

SwiftObjective-C

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
      

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 प्रॉपर्टी का इस्तेमाल करके, इसे स्टैंप के तौर पर सेट करें.

SwiftObjective-C

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
      

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 उपलब्ध है या नहीं. इस क्वेरी से यह तय होता है कि मैप व्यू में स्प्राइट स्टैंप वाले पॉलीलाइन काम करते हैं या नहीं.

SwiftObjective-C

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
      

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. पॉलीगॉन, मैप पर दिखता है.

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

SwiftObjective-C

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

// 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 को उसके पैरंट से अलग करें.

SwiftObjective-C

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

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

सर्कल्स

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

सर्कल बनाने के लिए, आपको इन दो प्रॉपर्टी की जानकारी देनी होगी:

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

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

सर्कल जोड़ना

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

SwiftObjective-C

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

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 पर सेट होती है. मैप पर ज़ूम करने पर, लाइन की चौड़ाई में बदलाव नहीं होता.

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

SwiftObjective-C

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

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

खोखला पॉलीगॉन बनाना

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

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

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

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

SwiftObjective-C

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
      

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;