शेप्स

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

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

इन सभी आकृतियों के लिए, आप प्रॉपर्टी की संख्या.

कोड सैंपल

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

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

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

पॉलीलाइन

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

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

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

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

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

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

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

      

// 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() को कॉल करें और पॉलीलाइन के लिए पॉइंट की नई सूची दें.

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

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

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

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

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

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

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

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

      

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() को कॉल करके, आकार के विकल्प ऑब्जेक्ट पर यह प्रॉपर्टी सेट करें. यहां दिए गए उदाहरण में, वुडलैंड पार्क चिड़ियाघर से Kirkland, WA तक लाल से पीले रंग के ग्रेडिएंट वाली पॉलीलाइन बनाने का तरीका बताया गया है.

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

      

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() को कॉल करें, जैसा कि यहां दिखाया गया है:

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

      

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 ऑब्जेक्ट दिखाता है.

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

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

      

// 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() फ़ंक्शन का इस्तेमाल करने पर, चारों पॉइंट दिखेंगे.

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

      

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

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

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

      

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) कॉलबैक मिलेगा.

सर्कल्स

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

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

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

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

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

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

निम्न कोड स्निपेट CircleOptions ऑब्जेक्ट और कॉल करने की सुविधा GoogleMap.addCircle(CircleOptions):

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

      

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

      

सर्कल इवेंट

डिफ़ॉल्ट रूप से, सर्कल पर क्लिक नहीं किया जा सकता. आप क्लिक करने की योग्यता, GoogleMap.addCircle() को कॉल करें CircleOptions.clickable(boolean) या इस नंबर पर कॉल करें Circle.setClickable(boolean).

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

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

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
}

      

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);
    }
});

      

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

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

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

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

      

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-बिट ऐल्फ़ा-लाल-हरा-नीला (एआरजीबी) इंटिजर होता है. इससे आकार के स्ट्रोक की ऑपैसिटी और रंग के बारे में पता चलता है. *Options.strokeColor() (या पॉलीलाइन के मामले में PolylineOptions.color()) को कॉल करके, इस प्रॉपर्टी को आकार के विकल्प ऑब्जेक्ट पर सेट करें. अगर इसे तय नहीं किया जाता है, तो स्ट्रोक का डिफ़ॉल्ट रंग काला (Color.BLACK) है.

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

रंग भरें

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

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

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

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

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

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

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

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

यहां दिए गए सैंपल में, पॉलीलाइन के पैटर्न को बिंदु के बार-बार होने वाले क्रम पर सेट किया गया है. इसके बाद, 20 पिक्सल का गैप, 30 पिक्सल का डैश, और फिर 20 पिक्सल का गैप है.

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

      

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

      

पैटर्न, पंक्ति के साथ दोहराया जाता है, जो आकार के लिए तय किया गया पहला शीर्ष.

जॉइंट टाइप

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

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

polyline.jointType = JointType.ROUND

      

polyline.setJointType(JointType.ROUND);

      

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

लाइन कैप

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

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

polyline.startCap = RoundCap()

      

polyline.setStartCap(new RoundCap());

      

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

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

      

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

      

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

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

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

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

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

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

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

Z-index

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

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

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

किसको दिखाई दे

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

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

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

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

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

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"

      

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");

      

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

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