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

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

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

शुरुआती जानकारी

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

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

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

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

मैप पर हीटमैप

संकेत: आपके पास setGradient() तरीके का इस्तेमाल करके, हीटमैप के लिए अपने रंग सेट करने का विकल्प है. अपने हीटमैप के रंगों और दूसरी प्रॉपर्टी को पसंद के मुताबिक बनाने का तरीका जानें.

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

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

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

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

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

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

Kotlin

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
}

      

Java

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().data() के बजाय HeatmapTileProvider.Builder().weightedData() को कॉल करें.

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

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

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

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

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

Kotlin

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

      

Java

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

      

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

Kotlin

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

      

Java

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

      

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

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

Kotlin

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

      

Java

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

      

हीटमैप हटाना

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

Kotlin

tileOverlay?.remove()

      

Java

tileOverlay.remove();

      

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

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