शेप्स

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

ठोस लाल पॉलीलाइन वाला मैप

Android के लिए Google Maps API आपको अपने मैप में आकार जोड़ने के कुछ आसान तरीके उपलब्ध कराता है, ताकि आप उन्हें अपने ऐप्लिकेशन के लिए कस्टमाइज़ कर सकें.

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

इन सभी आकृतियों के लिए, कई प्रॉपर्टी में बदलाव करके इन्हें अपनी पसंद के मुताबिक बनाया जा सकता है.

कोड सैंपल

इलाकों और रास्तों को दिखाने के लिए पॉलीगॉन और पॉलीलाइन जोड़ने के ट्यूटोरियल में, एक सामान्य Android ऐप्लिकेशन के सभी कोड शामिल होते हैं.

इसके अलावा, GitHub पर ApiDemos डेटा स्टोर करने की जगह में, ऐसे सैंपल शामिल हैं जो शेप और उनकी सुविधाओं के इस्तेमाल के बारे में बताते हैं:

  • CircleDemoActivity (Java / Kotlin): सर्कल
  • PluginsDemoActivity (Java / Kotlin): पॉलीगॉन
  • PolylineDemoActivity (Java / Kotlin): पॉलीलाइन

पॉलीलाइन

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

इस वीडियो में पॉलीलाइन का इस्तेमाल करके, मैप पर उपयोगकर्ताओं को उनकी मंज़िल तक पहुंचने में मदद करने का तरीका बताया गया है.

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

किसी PolylineOptions ऑब्जेक्ट में पॉइंट जोड़ने के लिए, PolylineOptions.add() को कॉल करें. ध्यान दें कि यह तरीका पैरामीटर की अलग-अलग संख्या लेता है, ताकि आप एक साथ कई पॉइंट जोड़ सकें (अगर पॉइंट पहले से सूची में मौजूद हैं, तो आप PolylineOptions.addAll(Iterable<LatLng>) को भी कॉल कर सकते हैं).

इसके बाद, GoogleMap.addPolyline(PolylineOptions) पर कॉल करके पॉलीलाइन को मैप पर जोड़ा जा सकता है. यह तरीका Polyline ऑब्जेक्ट दिखाता है, जिसकी मदद से पॉलीलाइन को बाद में बदला जा सकता है.

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

Kotlin



// Instantiates a new Polyline object and adds points to define a rectangle
val polylineOptions = PolylineOptions()
    .add(LatLng(37.35, -122.0))
    .add(LatLng(37.45, -122.0)) // North of the previous point, but at the same longitude
    .add(LatLng(37.45, -122.2)) // Same latitude, and 30km to the west
    .add(LatLng(37.35, -122.2)) // Same longitude, and 16km to the south
    .add(LatLng(37.35, -122.0)) // Closes the polyline.

// Get back the mutable Polyline
val polyline = map.addPolyline(polylineOptions)

Java


// Instantiates a new Polyline object and adds points to define a rectangle
PolylineOptions polylineOptions = new PolylineOptions()
    .add(new LatLng(37.35, -122.0))
    .add(new LatLng(37.45, -122.0))  // North of the previous point, but at the same longitude
    .add(new LatLng(37.45, -122.2))  // Same latitude, and 30km to the west
    .add(new LatLng(37.35, -122.2))  // Same longitude, and 16km to the south
    .add(new LatLng(37.35, -122.0)); // Closes the polyline.

// Get back the mutable Polyline
Polyline polyline = map.addPolyline(polylineOptions);

रेक्टैंगल, मैप पर इस तरह दिखता है:

आयताकार पॉलीलाइन वाला मैप

पॉलीलाइन जोड़ने के बाद उसका आकार बदलने के लिए, Polyline.setPoints() को कॉल करें और पॉलीलाइन के लिए पॉइंट की नई सूची दें.

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

पॉलीलाइन कस्टमाइज़ेशन

पॉलीलाइन को अपनी पसंद के मुताबिक दिखाने के कई तरीके हैं:

  • कई रंगों वाली पॉलीलाइन, पॉलीलाइन सेगमेंट को अलग-अलग रंगों में सेट करती हैं.
  • ग्रेडिएंट पॉलीलाइन दो रंगों के ग्रेडिएंट का इस्तेमाल करके पॉलीलाइन को रंग देते हैं.
  • मुहर लगाई गई पॉलीलाइन बार-बार दोहराए जाने वाले बिटमैप का इस्तेमाल करके पॉलीलाइन को स्टाइल देती हैं.

पॉलीलाइन कस्टमाइज़ेशन का इस्तेमाल करने के लिए, आपको Android डिवाइस पर Maps SDK टूल का 18.1.0 या उसके बाद का वर्शन इस्तेमाल करना होगा. साथ ही, Android रेंडरर के लिए, Maps का सबसे नया SDK टूल इस्तेमाल करना होगा.

कई रंगों वाली पॉलीलाइन बनाना

बहुरंगी पॉलीलाइन वाला मैप

StyleSpan ऑब्जेक्ट बनाकर, और addSpan() या addSpans() तरीकों का इस्तेमाल करके, उन्हें PolylineOptions में जोड़कर, पॉलीलाइन के अलग-अलग सेगमेंट को अलग-अलग रंग देने के लिए स्पैन का इस्तेमाल किया जा सकता है. डिफ़ॉल्ट रूप से, ऐरे में मौजूद हर आइटम, उससे जुड़े लाइन सेगमेंट का रंग सेट करेगा. नीचे दिए गए उदाहरण में, लाल और हरे रंग के सेगमेंट वाली पॉलीलाइन बनाने के लिए सेगमेंट के रंग सेट करने का तरीका बताया गया है:

Kotlin



val line = map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(StyleSpan(Color.RED))
        .addSpan(StyleSpan(Color.GREEN))
)

Java


Polyline line = map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(new StyleSpan(Color.RED))
        .addSpan(new StyleSpan(Color.GREEN)));

ग्रेडिएंट पॉलीलाइन बनाना

ग्रेडिएंट पॉलीलाइन वाला मैप

स्ट्रोक की शुरुआत और आखिर के रंग बताने के लिए, दो 32-बिट अल्फ़ा-लाल-हरा-नीला (ARGB) इंटीजर तय करके ग्रेडिएंट तय किया जा सकता है. PolylineOptions.addSpan() को कॉल करके, इस प्रॉपर्टी को आकार के विकल्प ऑब्जेक्ट पर सेट करें. नीचे दिए गए उदाहरण में, वुडलैंड पार्क ज़ू से लेकर कर्कलैंड, वॉशिंगटन तक की लाल से पीले रंग की ग्रेडिएंट वाली पॉलीलाइन बनाना दिखाया गया है.

Kotlin



val line = map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(
            StyleSpan(
                StrokeStyle.gradientBuilder(
                    Color.RED,
                    Color.YELLOW
                ).build()
            )
        )
)

Java


Polyline line = map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(new StyleSpan(StrokeStyle.gradientBuilder(Color.RED, Color.YELLOW).build())));

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

मुहर लगी पॉलीलाइन वाला मैप

पॉलीलाइन दिखने के तरीके को, दोहराई जाने वाली बिट मैप टेक्सचर पर सेट किया जा सकता है. ऐसा करने के लिए, TextureStyle का StampStyle बनाएं. इसके बाद, यहां दिखाए गए तरीके से PolylineOptions.addSpan() को कॉल करके, इस प्रॉपर्टी को आकार के विकल्प ऑब्जेक्ट पर सेट करें:

Kotlin



val stampStyle =
    TextureStyle.newBuilder(BitmapDescriptorFactory.fromResource(R.drawable.walking_dot)).build()
val span = StyleSpan(StrokeStyle.colorBuilder(Color.RED).stamp(stampStyle).build())
map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(span)
)

Java


StampStyle stampStyle =
        TextureStyle.newBuilder(BitmapDescriptorFactory.fromResource(R.drawable.walking_dot)).build();
StyleSpan span = new StyleSpan(StrokeStyle.colorBuilder(Color.RED).stamp(stampStyle).build());
map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(span));

पॉलीलाइन इवेंट

डिफ़ॉल्ट रूप से, पॉलीलाइन पर क्लिक नहीं किया जा सकता. क्लिक करने की सुविधा को चालू और बंद करने के लिए, Polyline.setClickable(boolean) पर कॉल करें.

क्लिक किए जा सकने वाले पॉलीलाइन पर इवेंट क्लिक करने के लिए, OnPolylineClickListener का इस्तेमाल करें. इस लिसनर को मैप पर सेट करने के लिए, GoogleMap.setOnPolylineClickListener(OnPolylineClickListener) को कॉल करें. जब कोई उपयोगकर्ता किसी पॉलीलाइन पर क्लिक करता है, तो आपको एक onPolylineClick(Polyline) कॉलबैक मिलेगा.

पॉलीगॉन

Polygon ऑब्जेक्ट, Polyline ऑब्जेक्ट की तरह होते हैं, जिनमें क्रम के मुताबिक कई कोऑर्डिनेट होते हैं. हालांकि, ओपन-एंडेड होने के बजाय, पॉलीगॉन इस तरह डिज़ाइन किए जाते हैं कि वे बंद लूप के अंदर वाले इलाकों को तय करते हैं, जिनमें अंदर से पूरा हिस्सा भरा होता है.

मैप में Polygon को उसी तरह जोड़ा जा सकता है जिस तरह Polyline जोड़ा जाता है. सबसे पहले, कोई PolygonOptions ऑब्जेक्ट बनाएं और उसमें कुछ पॉइंट जोड़ें. ये बिंदु बहुभुज की रूपरेखा बनाएँगे. इसके बाद, GoogleMap.addPolygon(PolygonOptions) को कॉल करके मैप में पॉलीगॉन जोड़ें. इससे Polygon ऑब्जेक्ट दिखेगा.

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

Kotlin



// Instantiates a new Polygon object and adds points to define a rectangle
val rectOptions = PolygonOptions()
    .add(
        LatLng(37.35, -122.0),
        LatLng(37.45, -122.0),
        LatLng(37.45, -122.2),
        LatLng(37.35, -122.2),
        LatLng(37.35, -122.0)
    )

// Get back the mutable Polygon
val polygon = map.addPolygon(rectOptions)

Java


// Instantiates a new Polygon object and adds points to define a rectangle
PolygonOptions polygonOptions = new PolygonOptions()
    .add(new LatLng(37.35, -122.0),
        new LatLng(37.45, -122.0),
        new LatLng(37.45, -122.2),
        new LatLng(37.35, -122.2),
        new LatLng(37.35, -122.0));

// Get back the mutable Polygon
Polygon polygon = map.addPolygon(polygonOptions);

पॉलीगॉन जोड़ने के बाद इसका आकार बदलने के लिए, Polygon.setPoints() को कॉल करें और पॉलीगॉन की आउटलाइन के लिए बिंदुओं की नई सूची दें.

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

पॉलीगॉन अपने आप पूरा होना

ऊपर दिए गए उदाहरण में मौजूद बहुभुज में पाँच निर्देशांक हैं, लेकिन ध्यान दें कि पहले और अंतिम निर्देशांक एक ही स्थान हैं, जो लूप परिभाषित करते हैं. हालांकि, व्यावहारिक तौर पर, पॉलीगॉन बंद क्षेत्रों को परिभाषित करते हैं, इसलिए आपको इस आखिरी कोऑर्डिनेट को तय करने की ज़रूरत नहीं है. अगर आखिरी कोऑर्डिनेट पहले से अलग होता है, तो एपीआई, पॉलीगॉन को अपने-आप "बंद" कर देगा. इसके लिए, वह पहले कोऑर्डिनेट को कोऑर्डिनेट के क्रम के आखिर में जोड़ देगा.

नीचे दिए गए दो पॉलीगॉन एक जैसे हैं. हर पॉलीगॉन के लिए polygon.getPoints() को कॉल करने से सभी चार पॉइंट मिलेंगे.

Kotlin



val polygon1 = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0),
            LatLng(0.0, 0.0)
        )
        .strokeColor(Color.RED)
        .fillColor(Color.BLUE)
)
val polygon2 = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0)
        )
        .strokeColor(Color.RED)
        .fillColor(Color.BLUE)
)

Java


Polygon polygon1 = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5),
        new LatLng(0, 0))
    .strokeColor(Color.RED)
    .fillColor(Color.BLUE));

Polygon polygon2 = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5))
    .strokeColor(Color.RED)
    .fillColor(Color.BLUE));

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

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

एक ही एरिया में दो पाथ होने चाहिए. दोनों क्षेत्रों में से बड़ा क्षेत्र फ़िल एरिया के बारे में बताता है. यह एक साधारण पॉलीगॉन है, जिसमें कोई अतिरिक्त विकल्प नहीं होता. इसके बाद, addHole() तरीके को दूसरा पाथ पास करें. जब दूसरा छोटा पाथ, बड़े पाथ से पूरा भरा हुआ होता है, तो यह ऐसा लगता है जैसे पॉलीगॉन का कोई हिस्सा हटा दिया गया हो. अगर यह छेद पॉलीगॉन की आउटलाइन को काटता है, तो पॉलीगॉन बिना किसी चीज़ के रेंडर किया जा सकता है.

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

Kotlin



val hole = listOf(
    LatLng(1.0, 1.0),
    LatLng(1.0, 2.0),
    LatLng(2.0, 2.0),
    LatLng(2.0, 1.0),
    LatLng(1.0, 1.0)
)
val hollowPolygon = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0),
            LatLng(3.0, 0.0),
            LatLng(0.0, 0.0)
        )
        .addHole(hole)
        .fillColor(Color.BLUE)
)

Java


List<LatLng> hole = Arrays.asList(new LatLng(1, 1),
    new LatLng(1, 2),
    new LatLng(2, 2),
    new LatLng(2, 1),
    new LatLng(1, 1));
Polygon hollowPolygon = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5),
        new LatLng(3, 0),
        new LatLng(0, 0))
    .addHole(hole)
    .fillColor(Color.BLUE));

खोखला पॉलीगॉन, मैप पर नीचे दिखाए गए तरीके से दिखता है:

खोखले आयत की पॉलीलाइन वाला मैप

पॉलीगॉन इवेंट

डिफ़ॉल्ट रूप से, पॉलीगॉन क्लिक नहीं किए जा सकते. क्लिक करने की सुविधा को चालू और बंद करने के लिए, Polygon.setClickable(boolean) पर कॉल करें.

क्लिक किए जा सकने वाले पॉलीगॉन पर इवेंट पर क्लिक करने के लिए, OnPolygonClickListener का इस्तेमाल करें. इस लिसनर को मैप पर सेट करने के लिए, GoogleMap.setOnPolygonClickListener(OnPolygonClickListener) को कॉल करें. जब कोई उपयोगकर्ता किसी पॉलीगॉन पर क्लिक करता है, तो आपको एक onPolygonClick(Polygon) कॉलबैक मिलेगा.

सर्कल्स

गोल घेरे वाला मैप

सामान्य Polygon क्लास के अलावा, Maps API में Circle ऑब्जेक्ट के लिए खास क्लास भी शामिल हैं, ताकि इन्हें आसानी से बनाया जा सके.

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

  • LatLng के तौर पर center
  • radius मीटर में.

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

सर्कल जोड़ने के बाद उसका आकार बदलने के लिए, Circle.setRadius() या Circle.setCenter() को कॉल किया जा सकता है और नई वैल्यू दी जा सकती हैं.

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

यह कोड स्निपेट, CircleOptions ऑब्जेक्ट बनाकर और GoogleMap.addCircle(CircleOptions) को कॉल करके, मैप में एक सर्कल जोड़ता है:

Kotlin



// Instantiates a new CircleOptions object and defines the center and radius
val circleOptions = CircleOptions()
    .center(LatLng(37.4, -122.1))
    .radius(1000.0) // In meters

// Get back the mutable Circle
val circle = map.addCircle(circleOptions)

Java


// Instantiates a new CircleOptions object and defines the center and radius
CircleOptions circleOptions = new CircleOptions()
    .center(new LatLng(37.4, -122.1))
    .radius(1000); // In meters

// Get back the mutable Circle
Circle circle = map.addCircle(circleOptions);

सर्कल इवेंट

डिफ़ॉल्ट रूप से, सर्कल पर क्लिक नहीं किया जा सकता. क्लिक करने की सुविधा को चालू और बंद करने के लिए, CircleOptions.clickable(boolean) से GoogleMap.addCircle() पर कॉल करें या Circle.setClickable(boolean) को कॉल करें.

क्लिक किए जा सकने वाले सर्कल पर हुए इवेंट पर क्लिक करने के लिए, OnCircleClickListener का इस्तेमाल करें. इस लिसनर को मैप पर सेट करने के लिए, GoogleMap.setOnCircleClickListener(OnCircleClickListener) को कॉल करें.

जब कोई उपयोगकर्ता किसी सर्कल पर क्लिक करता है, तो आपको एक onCircleClick(Circle) कॉलबैक मिलेगा, जैसा कि इस कोड सैंपल में दिखाया गया है:

Kotlin



val circle = map.addCircle(
    CircleOptions()
        .center(LatLng(37.4, -122.1))
        .radius(1000.0)
        .strokeWidth(10f)
        .strokeColor(Color.GREEN)
        .fillColor(Color.argb(128, 255, 0, 0))
        .clickable(true)
)
map.setOnCircleClickListener {
    // Flip the r, g and b components of the circle's stroke color.
    val strokeColor = it.strokeColor xor 0x00ffffff
    it.strokeColor = strokeColor
}

Java


Circle circle = map.addCircle(new CircleOptions()
    .center(new LatLng(37.4, -122.1))
    .radius(1000)
    .strokeWidth(10)
    .strokeColor(Color.GREEN)
    .fillColor(Color.argb(128, 255, 0, 0))
    .clickable(true));

map.setOnCircleClickListener(new GoogleMap.OnCircleClickListener() {
    @Override
    public void onCircleClick(Circle circle) {
        // Flip the r, g and b components of the circle's stroke color.
        int strokeColor = circle.getStrokeColor() ^ 0x00ffffff;
        circle.setStrokeColor(strokeColor);
    }
});

दिखावट को पसंद के मुताबिक बनाना

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

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

Kotlin



val polyline = map.addPolyline(
    PolylineOptions()
        .add(LatLng(-37.81319, 144.96298), LatLng(-31.95285, 115.85734))
        .width(25f)
        .color(Color.BLUE)
        .geodesic(true)
)

Java


Polyline polyline = map.addPolyline(new PolylineOptions()
    .add(new LatLng(-37.81319, 144.96298), new LatLng(-31.95285, 115.85734))
    .width(25)
    .color(Color.BLUE)
    .geodesic(true));

मैप इस तरह दिखता है:

मेलबर्न से पर्थ तक की पॉलीलाइन वाला मैप

ध्यान दें: इनमें से ज़्यादातर को, बताए गए किसी भी आकार पर लागू किया जा सकता है.हालांकि, ऐसा हो सकता है कि कुछ प्रॉपर्टी कुछ खास आकृतियों के लिए समझ में न आएं. उदाहरण के लिए, पॉलीलाइन में फ़िल कलर नहीं हो सकता, क्योंकि उसके अंदर का हिस्सा नहीं है.

स्ट्रोक कलर

स्ट्रोक रंग 32-बिट अल्फ़ा-लाल-हरा-नीला (ARGB) पूर्णांक होता है, जो आकार के स्ट्रोक की अपारदर्शिता और रंग के बारे में बताता है. *Options.strokeColor() को कॉल करके (या पॉलीलाइन के मामले में PolylineOptions.color()) पर कॉल करके, इस प्रॉपर्टी को आकार के विकल्प ऑब्जेक्ट पर सेट करें. अगर इसकी जानकारी नहीं दी गई, तो स्ट्रोक का डिफ़ॉल्ट रंग काला (Color.BLACK) होता है.

मैप में आकार जोड़ने के बाद, getStrokeColor() (या पॉलीलाइन के लिए getColor()) को कॉल करके स्ट्रोक के रंग को ऐक्सेस किया जा सकता है. हालांकि, setStrokeColor() (setColor() for a polyline) पर कॉल करके इसे बदला भी जा सकता है.

फ़िल कलर

फ़िल कलर सिर्फ़ पॉलीगॉन और सर्कल पर लागू होता है. यह पॉलीलाइन पर लागू नहीं होता, क्योंकि इनके अंदर के हिस्सों को तय नहीं किया जाता. किसी पॉलीगॉन के लिए, इसके छेदों के अंदर के क्षेत्र पॉलीगॉन के अंदरूनी हिस्से का हिस्सा नहीं हैं और अगर फ़िल कलर सेट किया गया है, तो ये रंग में नहीं दिखेंगे.

फ़िल कलर एक 32-बिट अल्फ़ा-लाल-हरा-नीला (ARGB) पूर्णांक होता है, जो आकार के अंदरूनी हिस्से की ओपैसिटी और रंग के बारे में बताता है. *Options.fillColor() को कॉल करके, इस प्रॉपर्टी को आकार के विकल्प ऑब्जेक्ट पर सेट करें. अगर इसकी जानकारी नहीं दी गई, तो स्ट्रोक के डिफ़ॉल्ट रंग को पारदर्शी (Color.TRANSPARENT) रखा जाता है.

आकार को मैप में जोड़ दिए जाने के बाद, फ़िल के रंग को getFillColor() पर कॉल करके ऐक्सेस किया जा सकता है और setFillColor() पर कॉल करके इसे बदला जा सकता है.

स्ट्रोक की चौड़ाई

लाइन स्ट्रोक की चौड़ाई, पिक्सल में फ़्लोट के तौर पर (px). मैप को ज़ूम करने पर चौड़ाई स्केल नहीं होती (यानी, किसी आकार में सभी ज़ूम लेवल पर स्ट्रोक की चौड़ाई एक जैसी होगी). *Options.strokeWidth() (या पॉलीलाइन के लिए PolylineOptions.width()) को कॉल करके, इस प्रॉपर्टी को आकार के विकल्प ऑब्जेक्ट पर सेट करें. अगर इसकी जानकारी नहीं दी गई, तो डिफ़ॉल्ट स्ट्रोक 10 पिक्सल होता है.

मैप में आकार जोड़े जाने के बाद, getStrokeWidth() (या पॉलीलाइन के लिए getWidth()) को कॉल करके, स्ट्रोक की चौड़ाई को ऐक्सेस किया जा सकता है. इसे setStrokeWidth() (setWidth() for a polyline) पर कॉल करके बदला जा सकता है.

स्ट्रोक पैटर्न

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

नीचे दिया गया नमूना, पॉलीलाइन के पैटर्न को बिंदु के दोहराए गए क्रम में सेट करता है. इसके बाद, 20 पिक्सल की लंबाई का डैश, 30 पिक्सल लंबा डैश, और दूसरा 20 पिक्सल का अंतर दिखाता है.

Kotlin



val pattern = listOf(
    Dot(), Gap(20F), Dash(30F), Gap(20F)
)
polyline.pattern = pattern

Java


List<PatternItem> pattern = Arrays.asList(
    new Dot(), new Gap(20), new Dash(30), new Gap(20));
polyline.setPattern(pattern);

पैटर्न, लाइन के साथ दोहराया जाता है, जो आकार के लिए तय किए गए पहले वर्टेक्स पर पहले पैटर्न आइटम से शुरू होता है.

जोड़ों के टाइप

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

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

Kotlin



polyline.jointType = JointType.ROUND

Java


polyline.setJointType(JointType.ROUND);

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

लाइन कैप

पॉलीलाइन के हर सिरे के लिए अलग-अलग Cap स्टाइल सेट की जा सकती है. इसके विकल्प बट (डिफ़ॉल्ट), स्क्वेयर, गोल या कस्टम बिटमैप हैं. स्टाइल को PolylineOptions.startCap और PolylineOptions.endCap में सेट करें या गैटर और सेटर के सही तरीकों का इस्तेमाल करें.

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

Kotlin



polyline.startCap = RoundCap()

Java


polyline.setStartCap(new RoundCap());

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

Kotlin



polyline.endCap = CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16F)

Java


polyline.setEndCap(
    new CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16));

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

अगर बिट मैप बनाने के लिए, BitmapDescriptorFactory.fromResource() का इस्तेमाल किया जाता है, तो पक्का करें कि डेंसिटी-इंडिपेंडेंट रिसॉर्स (nodpi) का इस्तेमाल किया जा रहा हो.

जियोडेसिक सेगमेंट

जियोडेसिक सेटिंग सिर्फ़ पॉलीलाइन और पॉलीगॉन पर लागू होती है. यह सर्कल पर लागू नहीं होता, क्योंकि उन्हें सेगमेंट के कलेक्शन के तौर पर तय नहीं किया जाता.

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

इस प्रॉपर्टी को आकार के विकल्प ऑब्जेक्ट पर सेट करने के लिए, *Options.geodesic() को कॉल करें. यहां true से पता चलता है कि सेगमेंट को जियोडिक्स के तौर पर बनाया जाना चाहिए. false से पता चलता है कि सेगमेंट को सीधी लाइनों के तौर पर बनाया जाना चाहिए. अगर इसकी जानकारी नहीं दी गई है, तो नॉन-जियोडिसिक सेगमेंट (false) डिफ़ॉल्ट तौर पर सेट होते हैं.

आकार को मैप में जोड़ने के बाद, isGeodesic() पर कॉल करके जियोडेसिक सेटिंग को ऐक्सेस किया जा सकता है और setGeodesic() पर कॉल करके इसे बदला जा सकता है.

Z-इंडेक्स

z-इंडेक्स मैप पर दूसरे ओवरले (दूसरे आकार, ग्राउंड ओवरले और टाइल ओवरले) के मुकाबले इस आकार के स्टैक क्रम को बताता है. उच्च z-इंडेक्स वाला ओवरले कम z-इंडेक्स वाले ओवरले के ऊपर बनाया जाता है. एक ही z-इंडेक्स वाले दो ओवरले मनचाहे तरीके से बनाए जाते हैं.

ध्यान दें कि मार्कर हमेशा दूसरे ओवरले के ऊपर बनाए जाते हैं, चाहे अन्य ओवरले का z-इंडेक्स कुछ भी हो.

*Options.zIndex() को कॉल करके, इस प्रॉपर्टी को आकार के विकल्प ऑब्जेक्ट पर सेट करें. अगर इसकी जानकारी नहीं दी गई है, तो डिफ़ॉल्ट z-इंडेक्स 0 है. मैप में आकार जोड़ने के बाद, getZIndex() को कॉल करके z-इंडेक्स को ऐक्सेस किया जा सकता है और setZIndex() पर कॉल करके इसे बदला जा सकता है.

किसको दिखे

विज़िबिलिटी यह तय करती है कि मैप पर आकार बनाया जाए या नहीं, जहां true बताता है कि इसे बनाया जाना चाहिए और false बताता है कि इसे नहीं बनाया जाना चाहिए. यह आपको कुछ समय के लिए मैप पर आकार दिखाने की अनुमति नहीं देता. अगर आपको मैप से आकार हमेशा के लिए हटाना है, तो उस आकार पर remove() को कॉल करें.

*Options.visible() को कॉल करके, इस प्रॉपर्टी को आकार के विकल्प ऑब्जेक्ट पर सेट करें. अगर इसकी जानकारी नहीं दी गई है, तो डिफ़ॉल्ट रूप से दिखने की सेटिंग true होगी. आकार को मैप में जोड़ दिए जाने के बाद, isVisible() को कॉल करके यह जानकारी ऐक्सेस की जा सकती है और setVisible() पर कॉल करके इसे बदला जा सकता है.

डेटा को किसी आकार से जोड़ें

आकार के setTag() तरीके का इस्तेमाल करके, पॉलीलाइन, पॉलीगॉन या सर्कल के साथ कोई आर्बिट्रेरी डेटा ऑब्जेक्ट स्टोर किया जा सकता है और getTag() का इस्तेमाल करके ऑब्जेक्ट को वापस लाया जा सकता है. उदाहरण के लिए, पॉलीलाइन वाले किसी डेटा ऑब्जेक्ट को स्टोर करने के लिए, Polyline.setTag() को कॉल करें और डेटा ऑब्जेक्ट वापस पाने के लिए, Polyline.getTag() को कॉल करें.

यहां दिया गया कोड, बताई गई पॉलीलाइन के लिए एक आर्बिट्रेरी टैग (A) के बारे में बताता है:

Kotlin



val polyline = map.addPolyline(
    PolylineOptions()
        .clickable(true)
        .add(
            LatLng(-35.016, 143.321),
            LatLng(-34.747, 145.592),
            LatLng(-34.364, 147.891),
            LatLng(-33.501, 150.217),
            LatLng(-32.306, 149.248),
            LatLng(-32.491, 147.309)
        )
)
polyline.tag = "A"

Java


Polyline polyline = map.addPolyline((new PolylineOptions())
    .clickable(true)
    .add(new LatLng(-35.016, 143.321),
        new LatLng(-34.747, 145.592),
        new LatLng(-34.364, 147.891),
        new LatLng(-33.501, 150.217),
        new LatLng(-32.306, 149.248),
        new LatLng(-32.491, 147.309)));

polyline.setTag("A");

यहां उन परिस्थितियों के कुछ उदाहरण दिए गए हैं जब आकार के साथ डेटा को स्टोर और फिर से पाना उपयोगी होता है:

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