Google Maps Android हीटमैप सुविधा

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

परिचय

Android के लिए Maps SDK यूटिलिटी लाइब्रेरी में हीटमैप यूटिलिटी होती है जिसका इस्तेमाल एक हीटमैप जोड़ने के लिए किया जा सकता है आपके ऐप्लिकेशन में किसी Google मैप पर या ज़्यादा हीटमैप का इस्तेमाल किया जा सकता है.

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

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

नीचे दिए गए उदाहरण में, लाल रंग उन इलाकों को दिखाता है जिनमें पुलिस ज़्यादा काम करती है एक स्टेशन है.

अगर आपने अब तक Android यूटिलिटी लाइब्रेरी के लिए Maps SDK टूल को सेट अप नहीं किया है, सेटअप गाइड का पालन करें कृपया ध्यान दें.

आसान हीटमैप जोड़ें

अपने मैप में हीटमैप जोड़ने के लिए, आपको ऐसे डेटासेट की ज़रूरत होगी जिसमें हर रुचि की जगह के निर्देशांक. सबसे पहले, HeatmapTileProvider इसे LatLng ऑब्जेक्ट के कलेक्शन के पास भेजना. इसके बाद, नया TileOverlay उसे हीटमैप टाइल प्रोवाइडर पास करना होगा और मैप पर टाइल ओवरले जोड़ना था.

यह यूटिलिटी HeatmapTileProvider क्लास की सेवा देती है, लागू करता है: TileProvider हीटमैप के लिए टाइल इमेज उपलब्ध कराने वाला इंटरफ़ेस. HeatmapTileProvider, LatLng का संग्रह स्वीकार करता है ऑब्जेक्ट (या WeightedLatLng ऑब्जेक्ट, जैसा कि नीचे बताया गया है). इससे टाइल बनती है रेडियस, ग्रेडिएंट, और ओपैसिटी के आधार पर अलग-अलग ज़ूम लेवल की इमेज विकल्प दिए गए हैं. आप इन विकल्पों के लिए डिफ़ॉल्ट वैल्यू बदलें.

इन चरणों के बारे में ज़्यादा जानकारी:

1. इस्तेमाल की जाने वाली चीज़ें HeatmapTileProvider.Builder() नई फ़ाइल जोड़ने के लिए, उसे LatLng ऑब्जेक्ट का कलेक्शन पास करें HeatmapTileProvider.
2. कोई नया ऑफ़र बनाएं काम के विकल्पों वाला TileOverlayOptions ऑब्जेक्ट, HeatmapTileProvider सहित.
3. कॉल करें मैप पर ओवरले जोड़ने के लिए GoogleMap.addTileOverlay().

private fun addHeatMap() {
    var latLngs: List<LatLng?>? = null

    // Get the data: latitude/longitude positions of police stations.
    try {
        latLngs = readItems(R.raw.police_stations)
    } catch (e: JSONException) {
        Toast.makeText(context, "Problem reading list of locations.", Toast.LENGTH_LONG)
            .show()
    }

    // Create a heat map tile provider, passing it the latlngs of the police stations.
    val provider = HeatmapTileProvider.Builder()
        .data(latLngs)
        .build()

    // Add a tile overlay to the map, using the heat map tile provider.
    val overlay = map.addTileOverlay(TileOverlayOptions().tileProvider(provider))
}

@Throws(JSONException::class)
private fun readItems(@RawRes resource: Int): List<LatLng?> {
    val result: MutableList<LatLng?> = ArrayList()
    val inputStream = context.resources.openRawResource(resource)
    val json = Scanner(inputStream).useDelimiter("\\A").next()
    val array = JSONArray(json)
    for (i in 0 until array.length()) {
        val `object` = array.getJSONObject(i)
        val lat = `object`.getDouble("lat")
        val lng = `object`.getDouble("lng")
        result.add(LatLng(lat, lng))
    }
    return result
}

      

private void addHeatMap() {
    List<LatLng> latLngs = null;

    // Get the data: latitude/longitude positions of police stations.
    try {
        latLngs = readItems(R.raw.police_stations);
    } catch (JSONException e) {
        Toast.makeText(context, "Problem reading list of locations.", Toast.LENGTH_LONG).show();
    }

    // Create a heat map tile provider, passing it the latlngs of the police stations.
    HeatmapTileProvider provider = new HeatmapTileProvider.Builder()
        .data(latLngs)
        .build();

    // Add a tile overlay to the map, using the heat map tile provider.
    TileOverlay overlay = map.addTileOverlay(new TileOverlayOptions().tileProvider(provider));
}

private List<LatLng> readItems(@RawRes int resource) throws JSONException {
    List<LatLng> result = new ArrayList<>();
    InputStream inputStream = context.getResources().openRawResource(resource);
    String json = new Scanner(inputStream).useDelimiter("\\A").next();
    JSONArray array = new JSONArray(json);
    for (int i = 0; i < array.length(); i++) {
        JSONObject object = array.getJSONObject(i);
        double lat = object.getDouble("lat");
        double lng = object.getDouble("lng");
        result.add(new LatLng(lat, lng));
    }
    return result;
}

      

इस उदाहरण के लिए, डेटा को एक JSON फ़ाइल में सेव किया जाता है, police_stations.json. यहां इस फ़ाइल का एक्स्ट्रैक्ट दिया गया है:

[
{"lat" : -37.1886, "lng" : 145.708 } ,
{"lat" : -37.8361, "lng" : 144.845 } ,
{"lat" : -38.4034, "lng" : 144.192 } ,
{"lat" : -38.7597, "lng" : 143.67 } ,
{"lat" : -36.9672, "lng" : 141.083 }
]

वेटेड अक्षांश/देशांतर बिंदुओं का इस्तेमाल करें

HeatmapTileProvider बनाते समय, इसे किसी वेटेड अक्षांश/देशांतर निर्देशांकों का संग्रह. यह तब काम आता है, जब में जगहों के किसी खास सेट की अहमियत बताई गई हो.

खास जगहों पर वेट लागू करने के लिए:

1. कोई नया ऑफ़र बनाएं WeightedLatLng डालें, जहां वेट की ज़रूरत होती है. LatLng में पास और ज़रूरी इंटेंसिटी दिखाने के लिए double. इंटेंसिटी इस जगह की अहमियत को दिखाता है. बहुत ज़्यादा मान का इस्तेमाल करने पर हीटमैप ग्रेडिएंट में ज़्यादा तीव्रता वाला रंग मिलेगा. इन्होंने बदलाव किया है डिफ़ॉल्ट रूप से, सबसे ज़्यादा तीव्रता वाला रंग लाल होता है.

2. कॉल करें HeatmapTileProvider.Builder().weightedData() बनाने के लिए, HeatmapTileProvider.Builder().data() के बजाय, हीटमैप.

हीटमैप को पसंद के मुताबिक बनाएं

हीटमैप की कई प्रॉपर्टी को पसंद के मुताबिक बनाया जा सकता है. आप निर्माण के समय, Builder फ़ंक्शन के ज़रिए, विकल्पों का इस्तेमाल करती है. वैकल्पिक रूप से, किसी भी समय संबंधित सेटर को कॉल करके विकल्प बदलें HeatmapTileProvider पर क्लिक करें और फिर ओवरले की टाइल कैश मेमोरी ताकि यह नए विकल्पों के साथ सभी टाइल को फिर से ड्रॉ करे.

ये विकल्प उपलब्ध हैं:

1. दायरा: हीटमैप पर लागू किए गए गॉसियन ब्लर का साइज़, पिक्सल में दिखाया जाता है. डिफ़ॉल्ट संख्या 20 होती है. यह 10 से 50 के बीच होना चाहिए. इसका इस्तेमाल करें हीटमैप बनाते समय वैल्यू सेट करने के लिए, बिल्डर का radius(), या बाद में setRadius() से वैल्यू को बदलें.
2. ग्रेडिएंट: हीटमैप में इस्तेमाल किए गए कलर की रेंज को जनरेट करने के लिए कम से कम या सबसे ज़्यादा तीव्रता वाले कलर मैप में. एक ग्रेडिएंट बनाया गया दो सरणियों का इस्तेमाल करना: रंगों वाला पूर्णांक अरे और फ़्लोट अरे यह हर रंग के लिए शुरुआती पॉइंट दिखाता है, जो कि सबसे ज़्यादा तीव्रता वाली, जिसे 0 से 1 के बीच अंश के रूप में दिखाया जाता है. आपको ये काम करने होंगे एकल-रंग ग्रेडिएंट के लिए केवल एक रंग दर्ज करें या कम से कम दो कई रंगों वाले ग्रेडिएंट के लिए रंग. कलर मैप, इसका इस्तेमाल करके जनरेट किया जाता है इंटरपोलेशन का इस्तेमाल करें. डिफ़ॉल्ट ग्रेडिएंट में दो रंग होते हैं. इस्तेमाल की जाने वाली चीज़ें बिल्डर का gradient(), हीटमैप का इस्तेमाल करें या बाद में setGradient() की मदद से वैल्यू को बदलें.
3. ओपैसिटी: यह पूरी हीटमैप लेयर की ओपैसिटी है, और इसकी रेंज 0 से 1 तक होती है. डिफ़ॉल्ट सेटिंग 0.7 है. बिल्डर का इस्तेमाल करें हीटमैप बनाते समय वैल्यू सेट करने के लिए opacity() या बाद में setOpacity() से वैल्यू को बदलें.

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

// Create the gradient.
val colors = intArrayOf(
    Color.rgb(102, 225, 0),  // green
    Color.rgb(255, 0, 0) // red
)
val startPoints = floatArrayOf(0.2f, 1f)
val gradient = Gradient(colors, startPoints)

// Create the tile provider.
val provider = HeatmapTileProvider.Builder()
    .data(latLngs)
    .gradient(gradient)
    .build()

// Add the tile overlay to the map.
val tileOverlay = map.addTileOverlay(
    TileOverlayOptions()
        .tileProvider(provider)
)

      

// Create the gradient.
int[] colors = {
    Color.rgb(102, 225, 0), // green
    Color.rgb(255, 0, 0)    // red
};

float[] startPoints = {
    0.2f, 1f
};

Gradient gradient = new Gradient(colors, startPoints);

// Create the tile provider.
HeatmapTileProvider provider = new HeatmapTileProvider.Builder()
    .data(latLngs)
    .gradient(gradient)
    .build();

// Add the tile overlay to the map.
TileOverlay tileOverlay = map.addTileOverlay(new TileOverlayOptions().tileProvider(provider));

      

किसी मौजूदा हीटमैप की ओपैसिटी बदलने के लिए:

provider.setOpacity(0.7)
tileOverlay?.clearTileCache()

      

provider.setOpacity(0.7);
tileOverlay.clearTileCache();

      

डेटासेट बदलना

जिस डेटासेट पर हीटमैप बनाया गया है उसे बदलने के लिए, HeatmapTileProvider.setData() या HeatmapTileProvider.setWeightedData() WeightedLatLng पॉइंट के लिए. ध्यान दें: अगर आपको हीटमैप या हीटमैप से पॉइंट हटाने के लिए, डेटा कलेक्शन को अपडेट करने में मदद मिलती है और फिर setData() या setWeightedData() का इस्तेमाल करें.

val data: List<WeightedLatLng> = ArrayList()
provider.setWeightedData(data)
tileOverlay?.clearTileCache()

      

List<WeightedLatLng> data = new ArrayList<>();
provider.setWeightedData(data);
tileOverlay.clearTileCache();

      

हीटमैप को हटाना

हीटमैप को हटाने के लिए, आपको टाइल ओवरले हटाना होगा:

tileOverlay?.remove()

      

tileOverlay.remove();

      

डेमो ऐप्लिकेशन देखें

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