Een gegevensbron maken (Android SDK)

  • Artikel
  • 20 minuten om te lezen

De Azure Kaarten Android SDK slaat gegevens op in gegevensbronnen. Het gebruik van gegevensbronnen optimaliseert de gegevensbewerkingen voor het uitvoeren van query's en rendering. Er zijn momenteel twee soorten gegevensbronnen:

  • GeoJSON-bron: beheert onbewerkte locatiegegevens lokaal in GeoJSON-indeling. Goed voor kleine tot middelgrote gegevenssets (omhoog honderdduizenden vormen).
  • Bron van vectortegel: laadt gegevens die zijn opgemaakt als vectortegels voor de huidige kaartweergave, op basis van het tegelsysteem van de kaart. Ideaal voor grote tot enorme gegevenssets (miljoenen of miljarden vormen).

GeoJSON-gegevensbron

Azure Kaarten GeoJSON als een van de primaire gegevensmodellen. GeoJSON is een open georuimtelijke standaard manier voor het vertegenwoordigen van georuimtelijke gegevens in JSON-indeling. GeoJSON-klassen die beschikbaar zijn in de Azure Kaarten Android SDK voor het eenvoudig maken en serialiseren van GeoJSON-gegevens. Laad en bewaar GeoJSON-gegevens in de DataSource klasse en geef deze weer met behulp van lagen. De volgende code laat zien hoe GeoJSON-objecten kunnen worden gemaakt in Azure Kaarten.

/*
    Raw GeoJSON feature

    {
         "type": "Feature",
         "geometry": {
             "type": "Point",
             "coordinates": [-100, 45]
         },
         "properties": {
             "custom-property": "value"
         }
    }

*/

//Create a point feature.
Feature feature = Feature.fromGeometry(Point.fromLngLat(-100, 45));

//Add a property to the feature.
feature.addStringProperty("custom-property", "value");

//Add the feature to the data source.
source.add(feature);

/*
    Raw GeoJSON feature

    {
         "type": "Feature",
         "geometry": {
             "type": "Point",
             "coordinates": [-100, 45]
         },
         "properties": {
             "custom-property": "value"
         }
    }

*/

//Create a point feature.
val feature = Feature.fromGeometry(Point.fromLngLat(-100, 45))

//Add a property to the feature.
feature.addStringProperty("custom-property", "value")

//Add the feature to the data source.
source.add(feature)

Tip

GeoJSON-gegevens kunnen worden toegevoegd aan een exemplaar met behulp van een van de drie DataSource methoden: add , en importDataFromUrl setShapes . De setShapes methode biedt een efficiënte manier om alle gegevens in een gegevensbron te overschrijven. Als u de methoden aanroept om alle gegevens in een gegevensbron te vervangen, worden er twee clear add render-aanroepen naar de kaart gedaan. Met setShape de methode worden de gegevens gewed en toegevoegd aan de gegevensbron met één render-aanroep naar de kaart.

De eigenschappen kunnen ook eerst in een JsonObject worden geladen en vervolgens bij het maken ervan worden doorgegeven aan de functie, zoals hieronder wordt weergegeven.

//Create a JsonObject to store properties for the feature.
JsonObject properties = new JsonObject();
properties.addProperty("custom-property", "value");

Feature feature = Feature.fromGeometry(Point.fromLngLat(-100, 45), properties);

//Create a JsonObject to store properties for the feature.
val properties = JsonObject()
properties.addProperty("custom-property", "value")

val feature = Feature.fromGeometry(Point.fromLngLat(-100, 45), properties)

Zodra u een GeoJSON-functie hebt gemaakt, kan een gegevensbron aan de kaart worden toegevoegd via de sources eigenschap van de kaart. De volgende code laat zien hoe u een DataSource maakt, deze toevoegt aan de kaart en een functie toevoegt aan de gegevensbron.

//Create a data source and add it to the map.
DataSource source = new DataSource();
map.sources.add(source);

//Add GeoJSON feature to the data source.
source.add(feature);

De volgende code toont verschillende manieren om een GeoJSON-functie, FeatureCollection en geometrieën te maken.

//GeoJSON Point Geometry
Point point = Point.fromLngLat(LONGITUDE, LATITUDE);

//GeoJSON Point Geometry
LineString linestring = LineString.fromLngLats(PointList);

//GeoJSON Polygon Geometry
Polygon polygon = Polygon.fromLngLats(listOfPointList);

Polygon polygonFromOuterInner = Polygon.fromOuterInner(outerLineStringObject,innerLineStringObject);

//GeoJSON MultiPoint Geometry
MultiPoint multiPoint = MultiPoint.fromLngLats(PointList);

//GeoJSON MultiLineString Geometry
MultiLineString multiLineStringFromLngLat = MultiLineString.fromLngLats(listOfPointList);

MultiLineString multiLineString = MultiLineString.fromLineString(singleLineString);

//GeoJSON MultiPolygon Geometry
MultiPolygon multiPolygon = MultiPolygon.fromLngLats(listOflistOfPointList);

MultiPolygon multiPolygonFromPolygon = MultiPolygon.fromPolygon(polygon);

MultiPolygon multiPolygonFromPolygons = MultiPolygon.fromPolygons(PolygonList);

//GeoJSON Feature
Feature pointFeature = Feature.fromGeometry(Point.fromLngLat(LONGITUDE, LATITUDE));

//GeoJSON FeatureCollection 
FeatureCollection featureCollectionFromSingleFeature = FeatureCollection.fromFeature(pointFeature);

FeatureCollection featureCollection = FeatureCollection.fromFeatures(listOfFeatures);

//GeoJSON Point Geometry
val point = Point.fromLngLat(LONGITUDE, LATITUDE)

//GeoJSON Point Geometry
val linestring = LineString.fromLngLats(PointList)

//GeoJSON Polygon Geometry
val polygon = Polygon.fromLngLats(listOfPointList)

val polygonFromOuterInner = Polygon.fromOuterInner(outerLineStringObject, innerLineStringObject)

//GeoJSON MultiPoint Geometry
val multiPoint = MultiPoint.fromLngLats(PointList)

//GeoJSON MultiLineString Geometry
val multiLineStringFromLngLat = MultiLineString.fromLngLats(listOfPointList)

val multiLineString = MultiLineString.fromLineString(singleLineString)

//GeoJSON MultiPolygon Geometry
val multiPolygon = MultiPolygon.fromLngLats(listOflistOfPointList)

val multiPolygonFromPolygon = MultiPolygon.fromPolygon(polygon)

val multiPolygonFromPolygons = MultiPolygon.fromPolygons(PolygonList)

//GeoJSON Feature
val pointFeature = Feature.fromGeometry(Point.fromLngLat(LONGITUDE, LATITUDE))

//GeoJSON FeatureCollection 
val featureCollectionFromSingleFeature = FeatureCollection.fromFeature(pointFeature)

val featureCollection = FeatureCollection.fromFeatures(listOfFeatures)

GeoJSON serialiseren en deserialiseren

De functieverzamelings-, functie- en geometrieklassen hebben allemaal statische methoden en fromJson() toJson() die helpen bij serialisatie. Met de opgemaakte geldige JSON-tekenreeks die via de fromJson() methode wordt doorgegeven, wordt het geometrieobject gemaakt. Deze fromJson() methode betekent ook dat u GSON of andere serialisatie/deserialisatiestrategieën kunt gebruiken. De volgende code laat zien hoe u een geoJSON-functie met tekenreeksen deserialiseert in de functieklasse en deze vervolgens weer serialiseert naar een GeoJSON-tekenreeks.

//Take a stringified GeoJSON object.
String GeoJSON_STRING = "{"
    + "      \"type\": \"Feature\","            
    + "      \"geometry\": {"
    + "            \"type\": \"Point\""
    + "            \"coordinates\": [-100, 45]"
    + "      },"
    + "      \"properties\": {"
    + "            \"custom-property\": \"value\""
    + "      },"
    + "}";

//Deserialize the JSON string into a feature.
Feature feature = Feature.fromJson(GeoJSON_STRING);

//Serialize a feature collection to a string.
String featureString = feature.toJson();

//Take a stringified GeoJSON object.
val GeoJSON_STRING = ("{"
        + "      \"type\": \"Feature\","
        + "      \"geometry\": {"
        + "            \"type\": \"Point\""
        + "            \"coordinates\": [-100, 45]"
        + "      },"
        + "      \"properties\": {"
        + "            \"custom-property\": \"value\""
        + "      },"
        + "}")

//Deserialize the JSON string into a feature.
val feature = Feature.fromJson(GeoJSON_STRING)

//Serialize a feature collection to a string.
val featureString = feature.toJson()

GeoJSON-gegevens importeren vanaf internet of uit een map met assets

De meeste GeoJSON-bestanden bevatten een FeatureCollection. Lees GeoJSON-bestanden als tekenreeksen en gebruik de FeatureCollection.fromJson methode om deze te deserialiseren.

De klasse heeft een ingebouwde methode met de naam die GeoJSON-bestanden kan laden met behulp van een URL naar een bestand op internet of DataSource importDataFromUrl in de assetmap. Deze methode moet worden aangeroepen voordat de gegevensbron wordt toegevoegd aan de kaart.

zone_pivot_groups: azure-maps-android

//Create a data source and add it to the map.
DataSource source = new DataSource();

//Import the geojson data and add it to the data source.
source.importDataFromUrl("URL_or_FilePath_to_GeoJSON_data");

//Examples:
//source.importDataFromUrl("asset://sample_file.json");
//source.importDataFromUrl("https://example.com/sample_file.json");

//Add data source to the map.
map.sources.add(source);

//Create a data source and add it to the map.
var source = new DataSource()

//Import the geojson data and add it to the data source.
source.importDataFromUrl("URL_or_FilePath_to_GeoJSON_data")

//Examples:
//source.importDataFromUrl("asset://sample_file.json")
//source.importDataFromUrl("https://example.com/sample_file.json")

//Add data source to the map.
map.sources.add(source)

De methode biedt een makkelijke manier om een GeoJSON-feed in een gegevensbron te laden, maar biedt beperkte controle over hoe de gegevens worden geladen en wat er gebeurt nadat de gegevens importDataFromUrl zijn geladen. De volgende code is een herbruikbare klasse voor het importeren van gegevens uit de map web of assets en het retourneren van gegevens naar de UI-thread via een callback-functie. In de callback kunt u vervolgens extra logica voor na belasting toevoegen om de gegevens te verwerken, deze toe te voegen aan de kaart, het begrenzesvak te berekenen en de camera van de kaart bij te werken.

import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.webkit.URLUtil;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.net.ssl.HttpsURLConnection;

public class Utils {

    interface SimpleCallback {
        void notify(String result);
    }

    /**
     * Imports data from a web url or asset file name and returns it to a callback.
     * @param urlOrFileName A web url or asset file name that points to data to load.
     * @param context The context of the app.
     * @param callback The callback function to return the data to.
     */
    public static void importData(String urlOrFileName, Context context, SimpleCallback callback){
        importData(urlOrFileName, context, callback, null);
    }

    /**
     * Imports data from a web url or asset file name and returns it to a callback.
     * @param urlOrFileName A web url or asset file name that points to data to load.
     * @param context The context of the app.
     * @param callback The callback function to return the data to.
     * @param error A callback function to return errors to.
     */
    public static void importData(String urlOrFileName, Context context, SimpleCallback callback, SimpleCallback error){
        if(urlOrFileName != null && callback != null) {
            ExecutorService executor = Executors.newSingleThreadExecutor();
            Handler handler = new Handler(Looper.getMainLooper());

            executor.execute(() -> {
                String data = null;

                try {

                    if(URLUtil.isNetworkUrl(urlOrFileName)){
                        data = importFromWeb(urlOrFileName);
                    } else {
                        //Assume file is in assets folder.
                        data = importFromAssets(context, urlOrFileName);
                    }

                    final String result = data;

                    handler.post(() -> {
                        //Ensure the resulting data string is not null or empty.
                        if (result != null && !result.isEmpty()) {
                            callback.notify(result);
                        } else {
                            error.notify("No data imported.");
                        }
                    });
                } catch(Exception e) {
                    if(error != null){
                        error.notify(e.getMessage());
                    }
                }
            });
        }
    }

    /**
     * Imports data from an assets file as a string.
     * @param context The context of the app.
     * @param fileName The asset file name.
     * @return
     * @throws IOException
     */
    private static String importFromAssets(Context context, String fileName) throws IOException {
        InputStream stream = null;

        try {
            stream = context.getAssets().open(fileName);

            if(stream != null) {
                return readStreamAsString(stream);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // Close Stream and disconnect HTTPS connection.
            if (stream != null) {
                stream.close();
            }
        }

        return null;
    }

    /**
     * Imports data from the web as a string.
     * @param url URL to the data.
     * @return
     * @throws IOException
     */
    private static String importFromWeb(String url) throws IOException {
        InputStream stream = null;
        HttpsURLConnection connection = null;
        String result = null;

        try {
            connection = (HttpsURLConnection) new URL(url).openConnection();

            //For this use case, set HTTP method to GET.
            connection.setRequestMethod("GET");

            //Open communications link (network traffic occurs here).
            connection.connect();

            int responseCode = connection.getResponseCode();
            if (responseCode != HttpsURLConnection.HTTP_OK) {
                throw new IOException("HTTP error code: " + responseCode);
            }

            //Retrieve the response body as an InputStream.
            stream = connection.getInputStream();

            if (stream != null) {
                return readStreamAsString(stream);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // Close Stream and disconnect HTTPS connection.
            if (stream != null) {
                stream.close();
            }
            if (connection != null) {
                connection.disconnect();
            }
        }

        return result;
    }

    /**
     * Reads an input stream as a string.
     * @param stream Stream to convert.
     * @return
     * @throws IOException
     */
    private static String readStreamAsString(InputStream stream) throws IOException {
        //Convert the contents of an InputStream to a String.
        BufferedReader in = new BufferedReader(new InputStreamReader(stream, "UTF-8"));

        String inputLine;
        StringBuffer response = new StringBuffer();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }

        in.close();

        return response.toString();
    }
}

import android.content.Context
import android.os.Handler
import android.os.Looper
import android.webkit.URLUtil
import java.net.URL
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors

class Utils {
    companion object {

        /**
            * Imports data from a web url or asset file name and returns it to a callback.
            * @param urlOrFileName A web url or asset file name that points to data to load.
            * @param context The context of the app.
            * @param callback The callback function to return the data to.
            */
        fun importData(urlOrFileName: String?, context: Context, callback: (String?) -> Unit) {
            importData(urlOrFileName, context, callback, null)
        }

        /**
            * Imports data from a web url or asset file name and returns it to a callback.
            * @param urlOrFileName A web url or asset file name that points to data to load.
            * @param context The context of the app.
            * @param callback The callback function to return the data to.
            * @param error A callback function to return errors to.
            */
        public fun importData(urlOrFileName: String?, context: Context, callback: (String?) -> Unit, error: ((String?) -> Unit)?) {
            if (urlOrFileName != null && callback != null) {
                val executor: ExecutorService = Executors.newSingleThreadExecutor()
                val handler = Handler(Looper.getMainLooper())
                executor.execute {
                    var data: String? = null

                    try {
                        data = if (URLUtil.isNetworkUrl(urlOrFileName)) {
                            URL(urlOrFileName).readText()
                        } else { //Assume file is in assets folder.
                            context.assets.open(urlOrFileName).bufferedReader().use{
                                it.readText()
                            }
                        }

                        handler.post {
                            //Ensure the resulting data string is not null or empty.
                            if (data != null && !data.isEmpty()) {
                                callback(data)
                            } else {
                                error!!("No data imported.")
                            }
                        }
                    } catch (e: Exception) {
                        error!!(e.message)
                    }
                }
            }
        }
    }
}

De onderstaande code laat zien hoe u dit hulpprogramma gebruikt om GeoJSON-gegevens te importeren als een tekenreeks en deze via een callback terug te keren naar de UI-thread. In de callback kunnen de tekenreeksgegevens worden geser serialiseerd in een verzameling GeoJSON-functies en aan de gegevensbron worden toegevoegd. Werk eventueel de camera van de kaart bij om u te concentreren op de gegevens.

//Create a data source and add it to the map.
DataSource source = new DataSource();
map.sources.add(source);

//Import the geojson data and add it to the data source.
Utils.importData("URL_or_FilePath_to_GeoJSON_data",
    this,
    (String result) -> {
        //Parse the data as a GeoJSON Feature Collection.
        FeatureCollection fc = FeatureCollection.fromJson(result);

        //Add the feature collection to the data source.
        source.add(fc);

        //Optionally, update the maps camera to focus in on the data.

        //Calculate the bounding box of all the data in the Feature Collection.
        BoundingBox bbox = MapMath.fromData(fc);

        //Update the maps camera so it is focused on the data.
        map.setCamera(
            bounds(bbox),
            padding(20));
    });

//Create a data source and add it to the map.
DataSource source = new DataSource();
map.sources.add(source);

//Import the GeoJSON data and add it to the data source.
Utils.importData("SamplePoiDataSet.json", this) { 
    result: String? ->
        //Parse the data as a GeoJSON Feature Collection.
            val fc = FeatureCollection.fromJson(result!!)

        //Add the feature collection to the data source.
        source.add(fc)

        //Optionally, update the maps camera to focus in on the data.

        //Calculate the bounding box of all the data in the Feature Collection.
        val bbox = MapMath.fromData(fc);

        //Update the maps camera so it is focused on the data.
        map.setCamera(
            bounds(bbox),

            //Padding added to account for pixel size of rendered points.
            padding(20)
        )
    }

Een functie bijwerken

Met DataSource de klasse kunt u eenvoudig functies toevoegen en verwijderen. Voor het bijwerken van de geometrie of eigenschappen van een functie moet de functie in de gegevensbron worden vervangen. Er zijn twee methoden die kunnen worden gebruikt om een of meer functies bij te werken:

  1. Maak de nieuwe functie(en) met de gewenste updates en vervang alle functies in de gegevensbron met behulp van de setShapes methode . Deze methode werkt goed als u alle functies in een gegevensbron wilt bijwerken.
DataSource source;

private void onReady(AzureMap map) {
    //Create a data source and add it to the map.
    source = new DataSource();
    map.sources.add(source);

    //Create a feature and add it to the data source.
    Feature myFeature = Feature.fromGeometry(Point.fromLngLat(0,0));
    myFeature.addStringProperty("Name", "Original value");

    source.add(myFeature);
}

private void updateFeature(){
    //Create a new replacement feature with an updated geometry and property value.
    Feature myNewFeature = Feature.fromGeometry(Point.fromLngLat(-10, 10));
    myNewFeature.addStringProperty("Name", "New value");

    //Replace all features to the data source with the new one.
    source.setShapes(myNewFeature);
}

var source: DataSource? = null

private fun onReady(map: AzureMap) {
    //Create a data source and add it to the map.
    source = DataSource()
    map.sources.add(source)

    //Create a feature and add it to the data source.
    val myFeature = Feature.fromGeometry(Point.fromLngLat(0.0, 0.0))
    myFeature.addStringProperty("Name", "Original value")
    source!!.add(myFeature)
}

private fun updateFeature() {
    //Create a new replacement feature with an updated geometry and property value.
    val myNewFeature = Feature.fromGeometry(Point.fromLngLat(-10.0, 10.0))
    myNewFeature.addStringProperty("Name", "New value")

    //Replace all features to the data source with the new one.
    source!!.setShapes(myNewFeature)
}
  1. Houd de functie-instantie in een variabele bij en geef deze door aan de methode voor remove gegevensbronnen om deze te verwijderen. Maak de nieuwe functie(en) met de gewenste updates, werk de verwijzing naar variabelen bij en voeg deze toe aan de gegevensbron met behulp van de add methode .
DataSource source;
Feature myFeature;

private void onReady(AzureMap map) {
    //Create a data source and add it to the map.
    source = new DataSource();
    map.sources.add(source);

    //Create a feature and add it to the data source.
    myFeature = Feature.fromGeometry(Point.fromLngLat(0,0));
    myFeature.addStringProperty("Name", "Original value");

    source.add(myFeature);
}

private void updateFeature(){
    //Remove the feature instance from the data source.
    source.remove(myFeature);

    //Get properties from original feature.
    JsonObject props = myFeature.properties();

    //Update a property.
    props.addProperty("Name", "New value");

    //Create a new replacement feature with an updated geometry.
    myFeature = Feature.fromGeometry(Point.fromLngLat(-10, 10), props);

    //Re-add the feature to the data source.
    source.add(myFeature);
}

var source: DataSource? = null
var myFeature: Feature? = null

private fun onReady(map: AzureMap) {
    //Create a data source and add it to the map.
    source = DataSource()
    map.sources.add(source)

    //Create a feature and add it to the data source.
    myFeature = Feature.fromGeometry(Point.fromLngLat(0.0, 0.0))
    myFeature.addStringProperty("Name", "Original value")
    source!!.add(myFeature)
}

private fun updateFeature() {
    //Remove the feature instance from the data source.
    source!!.remove(myFeature)

    //Get properties from original feature.
    val props = myFeature!!.properties()

    //Update a property.
    props!!.addProperty("Name", "New value")

    //Create a new replacement feature with an updated geometry.
    myFeature = Feature.fromGeometry(Point.fromLngLat(-10.0, 10.0), props)

    //Re-add the feature to the data source.
    source!!.add(myFeature)
}

Tip

Als u enkele gegevens hebt die regelmatig worden bijgewerkt en andere gegevens die zelden worden gewijzigd, kunt u deze het beste opsplitsen in afzonderlijke gegevensbron-exemplaren. Wanneer een update plaatsvindt in een gegevensbron, wordt de kaart ge dwingt om alle functies in de gegevensbron opnieuw te verwijderen. Als u deze gegevens opsplitst, worden alleen de functies die regelmatig worden bijgewerkt, opnieuw verdeeld wanneer er een update plaatsvindt in die ene gegevensbron, terwijl de functies in de andere gegevensbron niet opnieuw hoeven te worden herverwerkt. Dit helpt bij de prestaties.

Bron van vectortegel

De bron van een vectortegel beschrijft hoe u toegang krijgt tot een vectortegellaag. Gebruik de VectorTileSource klasse om een bron van een vectortegel te instanteren. Vectortegellagen zijn vergelijkbaar met tegellagen, maar ze zijn niet hetzelfde. Een tegellaag is een rasterafbeelding. Vectortegellagen zijn een gecomprimeerd bestand in PBF-indeling. Dit gecomprimeerde bestand bevat vectorkaartgegevens en een of meer lagen. Het bestand kan worden weergegeven en gestijld op de client, op basis van de stijl van elke laag. De gegevens in een vectortegel bevatten geografische kenmerken in de vorm van punten, lijnen en veelhoeken. Het gebruik van vectortegellagen in plaats van rastertegellagen heeft verschillende voordelen:

  • Een bestandsgrootte van een vectortegel is doorgaans veel kleiner dan een equivalente rastertegel. Daarom wordt er minder bandbreedte gebruikt. Dit betekent een lagere latentie, een snellere kaart en een betere gebruikerservaring.
  • Aangezien vectortegels worden weergegeven op de client, passen ze zich aan de resolutie aan van het apparaat dat wordt weergegeven. Als gevolg hiervan worden de gerenderde kaarten beter gedefinieerd, met helderblauwe labels.
  • Als u de stijl van de gegevens in de vectorkaarten wilt wijzigen, hoeft u de gegevens niet opnieuw te downloaden, omdat de nieuwe stijl op de client kan worden toegepast. Daarentegen vereist het wijzigen van de stijl van een rastertegellaag meestal dat tegels van de server worden geladen en vervolgens de nieuwe stijl worden toegepast.
  • Omdat de gegevens in vectorvorm worden geleverd, is er minder verwerking aan de serverzijde nodig om de gegevens voor te bereiden. Als gevolg hiervan kunnen de nieuwere gegevens sneller beschikbaar worden gesteld.

Azure Kaarten voldoet aan de Mapbox Vector Tile Specification,een open standaard. Azure Kaarten biedt de volgende services voor vectortegels als onderdeel van het platform:

Tip

Wanneer u vector- of rasterafbeeldingtegels uit de Azure Kaarten service renderen met de web-SDK, kunt u vervangen atlas.microsoft.com door de tijdelijke aanduiding azmapsdomain.invalid . Deze tijdelijke aanduiding wordt vervangen door hetzelfde domein dat wordt gebruikt door de kaart en zal automatisch dezelfde verificatiegegevens toevoegen. Dit vereenvoudigt de verificatie met de render-service aanzienlijk wanneer u Azure Active Directory gebruikt.

Als u gegevens uit een vectortegelbron op de kaart wilt weergeven, verbindt u de bron met een van de gegevensrenderingslagen. Alle lagen die gebruikmaken van een vectorbron moeten een sourceLayer waarde opgeven in de opties. Met de volgende code wordt de Azure Kaarten service voor verkeersstroomvectortegels geladen als een vectortegelbron en vervolgens weergegeven op een kaart met behulp van een lijnlaag. Deze vectortegelbron heeft één set gegevens in de bronlaag met de naam Verkeersstroom. De regelgegevens in deze gegevensset hebben een eigenschap met de naam die in deze code wordt gebruikt om de kleur te selecteren en de grootte traffic_level van regels te schalen.

//Formatted URL to the traffic flow vector tiles, with the maps subscription key appended to it.
String trafficFlowUrl = "https://azmapsdomain.invalid/traffic/flow/tile/pbf?api-version=1.0&style=relative&zoom={z}&x={x}&y={y}";

//Create a vector tile source and add it to the map.
VectorTileSource source = new VectorTileSource(
    tiles(new String[] { trafficFlowUrl }),
    maxSourceZoom(22)
);
map.sources.add(source);

//Create a layer for traffic flow lines.
LineLayer layer = new LineLayer(source,
    //The name of the data layer within the data source to pass into this rendering layer.
    sourceLayer("Traffic flow"),

    //Color the roads based on the traffic_level property.
    strokeColor(
        interpolate(
            linear(),
            get("traffic_level"),
            stop(0, color(Color.RED)),
            stop(0.33, color(Color.YELLOW)),
            stop(0.66, color(Color.GREEN))
        )
    ),

    //Scale the width of roads based on the traffic_level property.
    strokeWidth(
        interpolate(
            linear(),
            get("traffic_level"),
            stop(0, 6),
            stop(1,1)
        )
    )
);

//Add the traffic flow layer below the labels to make the map clearer.
map.layers.add(layer, "labels");

//Formatted URL to the traffic flow vector tiles, with the maps subscription key appended to it.
val trafficFlowUrl = "https://azmapsdomain.invalid/traffic/flow/tile/pbf?api-version=1.0&style=relative&zoom={z}&x={x}&y={y}"

//Create a vector tile source and add it to the map.
val source = VectorTileSource(
    tiles(arrayOf(trafficFlowUrl)),
    maxSourceZoom(22)
)
map.sources.add(source)

//Create a layer for traffic flow lines.
val layer = LineLayer(
    source,  //The name of the data layer within the data source to pass into this rendering layer.
    sourceLayer("Traffic flow"),  //Color the roads based on the traffic_level property.
    strokeColor(
        interpolate(
            linear(),
            get("traffic_level"),
            stop(0, color(Color.RED)),
            stop(0.33, color(Color.YELLOW)),
            stop(0.66, color(Color.GREEN))
        )
    ),  //Scale the width of roads based on the traffic_level property.
    strokeWidth(
        interpolate(
            linear(),
            get("traffic_level"),
            stop(0, 6),
            stop(1, 1)
        )
    )
)

//Add the traffic flow layer below the labels to make the map clearer.
map.layers.add(layer, "labels")

Kaart met met kleur gecodeerde weglijnen met verkeersstroomniveaus

Een gegevensbron verbinden met een laag

Gegevens worden weergegeven op de kaart met behulp van renderinglagen. Naar één gegevensbron kan worden verwezen door een of meer renderinglagen. Voor de volgende renderinglagen is een gegevensbron vereist:

  • Bellenlaag: geeft puntgegevens weer als geschaalde cirkels op de kaart.
  • Symboollaag: puntgegevens worden weergegeven als pictogrammen of tekst.
  • Heatmaplaag: geeft puntgegevens weer als een dichtheids heatmap.
  • Lijnlaag: geef een lijn weer en of geef de omtrek van veelhoeken weer.
  • Polygoonlaag: vult het gebied van een veelhoek met een effen kleur of afbeeldingspatroon.

De volgende code laat zien hoe u een gegevensbron maakt, deze toevoegt aan de kaart en deze verbindt met een bellenlaag. Importeer vervolgens GeoJSON-puntgegevens van een externe locatie in de gegevensbron.

//Create a data source and add it to the map.
DataSource source = new DataSource();

//Import the geojson data and add it to the data source.
source.importDataFromUrl("URL_or_FilePath_to_GeoJSON_data");

//Add data source to the map.
map.sources.add(source);

//Create a layer that defines how to render points in the data source and add it to the map.
BubbleLayer layer = new BubbleLayer(source);
map.layers.add(layer);

//Create a data source and add it to the map.
val source = DataSource()

//Import the geojson data and add it to the data source.
source.importDataFromUrl("URL_or_FilePath_to_GeoJSON_data")

//Add data source to the map.
map.sources.add(source)

Er zijn extra renderinglagen die geen verbinding maken met deze gegevensbronnen, maar ze laden de gegevens rechtstreeks voor rendering.

  • Tegellaag: hiermee wordt een rastertegellaag boven op de kaart geplaatst.

Eén gegevensbron met meerdere lagen

Meerdere lagen kunnen worden verbonden met één gegevensbron. Er zijn veel verschillende scenario's waarin deze optie nuttig is. Denk bijvoorbeeld aan het scenario waarin een gebruiker een veelhoek tekent. We moeten het veelhoekgebied weergeven en vullen wanneer de gebruiker punten aan de kaart toevoegt. Door een gestijlde lijn toe te voegen om de veelhoek om te zetten, worden de randen van de veelhoek gemakkelijker te zien wanneer de gebruiker tekent. Als u gemakkelijk een afzonderlijke positie in de veelhoek wilt bewerken, kunnen we boven elke positie een greep toevoegen, zoals een speld of een markering.

Kaart met meerdere lagen die gegevens uit één gegevensbron weergeven

In de meeste toewijzingsplatforms hebt u een veelhoekobject, een lijnobject en een speld nodig voor elke positie in de veelhoek. Als de veelhoek wordt gewijzigd, moet u de regel en pinnen handmatig bijwerken, wat snel complex kan worden.

Met Azure Kaarten hebt u slechts één veelhoek in een gegevensbron nodig, zoals wordt weergegeven in de onderstaande code.

//Create a data source and add it to the map.
DataSource source = new DataSource();
map.sources.add(source);

//Create a polygon and add it to the data source.
source.add(Polygon.fromLngLats(/* List of points */));

//Create a polygon layer to render the filled in area of the polygon.
PolygonLayer polygonLayer = new PolygonLayer(source,
    fillColor("rgba(255,165,0,0.2)")
);

//Create a line layer for greater control of rendering the outline of the polygon.
LineLayer lineLayer = new LineLayer(source,
    strokeColor("orange"),
    strokeWidth(2f)
);

//Create a bubble layer to render the vertices of the polygon as scaled circles.
BubbleLayer bubbleLayer = new BubbleLayer(source,
    bubbleColor("orange"),
    bubbleRadius(5f),
    bubbleStrokeColor("white"),
    bubbleStrokeWidth(2f)
);

//Add all layers to the map.
map.layers.add(new Layer[] { polygonLayer, lineLayer, bubbleLayer });

//Create a data source and add it to the map.
val source = DataSource()
map.sources.add(source)

//Create a polygon and add it to the data source.
source.add(Polygon.fromLngLats())

//Create a polygon layer to render the filled in area of the polygon.
val polygonLayer = PolygonLayer(
    source,
    fillColor("rgba(255,165,0,0.2)")
)

//Create a line layer for greater control of rendering the outline of the polygon.
val lineLayer = LineLayer(
    source,
    strokeColor("orange"),
    strokeWidth(2f)
)

//Create a bubble layer to render the vertices of the polygon as scaled circles.
val bubbleLayer = BubbleLayer(
    source,
    bubbleColor("orange"),
    bubbleRadius(5f),
    bubbleStrokeColor("white"),
    bubbleStrokeWidth(2f)
)

//Add all layers to the map.
map.layers.add(arrayOf<Layer>(polygonLayer, lineLayer, bubbleLayer))

Tip

Wanneer u lagen aan de kaart toevoegt met behulp van de methode , kan de id of het exemplaar van een bestaande laag worden map.layers.add doorgegeven als een tweede parameter. Hiermee wordt aangegeven dat de kaart de nieuwe laag moet invoegen die onder de bestaande laag wordt toegevoegd. Naast het doorgeven van een laag-id ondersteunt deze methode ook de volgende waarden.

  • "labels" - Hiermee voegt u de nieuwe laag onder de kaartlabellagen in.
  • "transit" - Hiermee wordt de nieuwe laag onder de kaartweg- en doorvoerlagen invoegen.

Volgende stappen

Zie de volgende artikelen voor meer codevoorbeelden die u aan uw kaarten kunt toevoegen:

Gegevensgestuurde stijlexpressies gebruiken

Puntgegevens clusteren

Een symboollaag toevoegen

Een bellenlaag toevoegen

Een lijnlaag toevoegen

Een polygoonlaag toevoegen

Een heatmap toevoegen

Codevoorbeelden voor web-SDK