शेप्स

प्लैटफ़ॉर्म चुनें: 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
इसका इस्तेमाल, पॉलीलाइन के एक या एक से ज़्यादा सेगमेंट का रंग तय करने के लिए किया जाता है. spanned प्रॉपर्टी, GMSStyleSpan ऑब्जेक्ट का एक कलेक्शन है. spans प्रॉपर्टी को सेट करना, इन कामों का पसंदीदा तरीका है पॉलीलाइन का रंग बदलें.
strokeColor
पॉलीलाइन का रंग बताने वाला UIColor ऑब्जेक्ट. डिफ़ॉल्ट रूप से, यह blueColor पर सेट होती है. strokeColor प्रॉपर्टी अगर spans सेट है, तो इसे अनदेखा कर दिया जाता है.

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

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 से पहले के वर्शन में, एक ही प्रॉपर्टी strokeColor, GMSPolyline. spans प्रॉपर्टी को प्राथमिकता दी जाती है strokeColor.

Swift

polyline.strokeColor = .red
      

Objective-C

polyline.strokeColor = [UIColor redColor];
      

स्टाइल

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

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

उदाहरण के लिए, नीचे दिया गया कोड स्निपेट एक पॉलीलाइन को काले और सफ़ेद रंग से परिभाषित करता है पंक्ति या कॉलम के लिए अलग-अलग पैटर्न का इस्तेमाल किया जा सकता है. इसकी लंबाई को रब लाइन के साथ मीटर में समझा जाता है ( Mercator, यह एक सीधी लाइन है) क्योंकि टाइप इस तरह से बताया गया है 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;
      

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

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

परतदार पॉलीलाइन

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;
      

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

पॉलीगॉन

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

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

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

  1. कोई GMSMutablePath ऑब्जेक्ट बनाएं.
  2. addCoordinate: या addLatitude:longitude: तरीकों से पाथ में पॉइंट सेट करें. ये पॉइंट, पॉलीगॉन की आउटलाइन बनाते हैं.
  3. पाथ का इस्तेमाल करके, नया GMSPolygon ऑब्जेक्ट बनाएं: तर्क है.
  4. अन्य प्रॉपर्टी सेट करें. जैसे, strokeWidth, strokeColor, और fillColor, ज़रूरत के हिसाब से.
  5. GMSMapView ऑब्जेक्ट को पॉलीगॉन असाइन करें. इसके लिए, GMSPolygon.map प्रॉपर्टी.
  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;