Gegevensgestuurde stijlexpressie (Android SDK)

Met expressies kunt u bedrijfslogica toepassen op stijlopties die de eigenschappen observeren die in elke vorm in een gegevensbron zijn gedefinieerd. Expressies kunnen gegevens in een gegevensbron of laag filteren. Expressies kunnen bestaan uit voorwaardelijke logica, zoals if-statements. En ze kunnen worden gebruikt voor het bewerken van gegevens met behulp van tekenreeksoperators, logische operators en wiskundige operators.

Gegevensgestuurde stijlen verminderen de hoeveelheid code die nodig is voor het implementeren van bedrijfslogica rond stijl. Bij gebruik met lagen worden expressies geëvalueerd tijdens het renderen op een afzonderlijke thread. Deze functionaliteit biedt betere prestaties in vergelijking met het evalueren van bedrijfslogica op de UI-thread.

De Azure Kaarten Android SDK ondersteunt vrijwel dezelfde stijlexpressie als de Azure Kaarten Web SDK, zodat alle dezelfde concepten die worden beschreven in de Web SDK (Data-driven Style Expressions) kunnen worden overgedragen naar een Android-app. Alle stijlexpressie in de Azure Kaarten Android SDK zijn beschikbaar onder de com.microsoft.azure.maps.mapcontrol.options.Expression naamruimte . Er zijn veel verschillende typen stijlexpressie.

Alle voorbeelden in deze sectie van het document gebruiken de volgende functie om verschillende manieren te demonstreren waarop deze expressies kunnen worden gebruikt.

{
    "type": "Feature",
    "geometry": {
        "type": "Point",
        "coordinates": [-122.13284, 47.63699]
    },
    "properties": {
        "id": 123,
        "entityType": "restaurant",
        "revenue": 12345,
        "subTitle": "Building 40", 
        "temperature": 64,
        "title": "Cafeteria", 
        "zoneColor": "purple",
        "abcArray": ["a", "b", "c"],
        "array2d": [["a", "b"], ["x", "y"]],
        "_style": {
            "fillColor": "red"
        }
    }
}

De volgende code laat zien hoe u deze GeoJSON-functie handmatig in een app maakt.

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

//Add properties to the feature.
feature.addNumberProperty("id", 123);
feature.addStringProperty("entityType", "restaurant");
feature.addNumberProperty("revenue", 12345);
feature.addStringProperty("subTitle", "Building 40");
feature.addNumberProperty("temperature", 64);
feature.addStringProperty("title", "Cafeteria");
feature.addStringProperty("zoneColor", "purple");

JsonArray abcArray = new JsonArray();
abcArray.add("a");
abcArray.add("b");
abcArray.add("c");

feature.addProperty("abcArray", abcArray);

JsonArray array1 = new JsonArray();
array1.add("a");
array1.add("b");

JsonArray array2 = new JsonArray();
array1.add("x");
array1.add("y");

JsonArray array2d = new JsonArray();
array2d.add(array1);
array2d.add(array2);

feature.addProperty("array2d", array2d);

JsonObject style = new JsonObject();
style.addProperty("fillColor", "red");

feature.addProperty("_style", style);

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

//Add properties to the feature.
feature.addNumberProperty("id", 123)
feature.addStringProperty("entityType", "restaurant")
feature.addNumberProperty("revenue", 12345)
feature.addStringProperty("subTitle", "Building 40")
feature.addNumberProperty("temperature", 64)
feature.addStringProperty("title", "Cafeteria")
feature.addStringProperty("zoneColor", "purple")

val abcArray = JsonArray()
abcArray.add("a")
abcArray.add("b")
abcArray.add("c")

feature.addProperty("abcArray", abcArray)

val array1 = JsonArray()
array1.add("a")
array1.add("b")

val array2 = JsonArray()
array1.add("x")
array1.add("y")

val array2d = JsonArray()
array2d.add(array1)
array2d.add(array2)

feature.addProperty("array2d", array2d)

val style = JsonObject()
style.addProperty("fillColor", "red")

feature.addProperty("_style", style)

De volgende code laat zien hoe u de geserialiseereerde versie van het JSON-object deserialiseert naar een GeoJSON-functie in een app.

String featureString = "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[-122.13284,47.63699]},\"properties\":{\"id\":123,\"entityType\":\"restaurant\",\"revenue\":12345,\"subTitle\":\"Building 40\",\"temperature\":64,\"title\":\"Cafeteria\",\"zoneColor\":\"purple\",\"abcArray\":[\"a\",\"b\",\"c\"],\"array2d\":[[\"a\",\"b\"],[\"x\",\"y\"]],\"_style\":{\"fillColor\":\"red\"}}}";

Feature feature = Feature.fromJson(featureString);

val featureString = "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[-122.13284,47.63699]},\"properties\":{\"id\":123,\"entityType\":\"restaurant\",\"revenue\":12345,\"subTitle\":\"Building 40\",\"temperature\":64,\"title\":\"Cafeteria\",\"zoneColor\":\"purple\",\"abcArray\":[\"a\",\"b\",\"c\"],\"array2d\":[[\"a\",\"b\"],[\"x\",\"y\"]],\"_style\":{\"fillColor\":\"red\"}}}"

val feature = Feature.fromJson(featureString)

JSON-expressies

De Azure Kaarten Web SDK ondersteunt ook gegevensgestuurde stijlexpressie die worden weergegeven met behulp van een JSON-matrix. Dezelfde expressies kunnen opnieuw worden gemaakt met behulp van de native Expression klasse in de Android SDK. Deze JSON-expressies kunnen ook worden geconverteerd naar een tekenreeks met behulp van een webfunctie zoals en JSON.stringify worden doorgegeven aan de methode Expression.raw(String rawExpression) . Neem bijvoorbeeld de volgende JSON-expressie.

var exp = ['get','title'];
JSON.stringify(exp); // = "['get','title']"

De tekenreeksversie van de bovenstaande expressie is en kan als volgt "['get','title']" in de Android-SDK worden gelezen.

Expression exp = Expression.raw("['get','title']")

val exp = Expression.raw("['get','title']")

Met deze methode kunt u stijlexpressie eenvoudig hergebruiken tussen mobiele apps en web-apps die gebruikmaken van Azure Kaarten.

Deze video biedt een overzicht van gegevensgestuurde stijl in Azure Kaarten.

Gegevensexpressie

Gegevensexpressie biedt toegang tot de eigenschapsgegevens in een functie.

De volgende web-SDK-stijlexpressie wordt niet ondersteund in de Android SDK:

• index-of
• Segment

Voorbeelden

Eigenschappen van een functie kunnen rechtstreeks in een expressie worden gebruikt met behulp van een get expressie. In dit voorbeeld wordt de zoneColor waarde van de functie gebruikt om de kleur-eigenschap van een bellenlaag op te geven.

BubbleLayer layer = new BubbleLayer(source,
    //Get the zoneColor value.
    bubbleColor(get("zoneColor"))
);

val layer = BubbleLayer(source,
    //Get the zoneColor value.
    bubbleColor(get("zoneColor"))
)

Het bovenstaande voorbeeld werkt prima als alle puntfuncties de eigenschap zoneColor hebben. Als ze dat niet doen, valt de kleur waarschijnlijk terug op 'zwart'. Als u de terugvalkleur wilt wijzigen, gebruikt u switchCase een expressie in combinatie met de expressie om te controleren of de eigenschap has bestaat. Als de eigenschap niet bestaat, retournt u een terugvalkleur.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        //Use a conditional case expression.
        switchCase(
            //Check to see if feature has a "zoneColor" 
            has("zoneColor"), 

            //If it does, use it.
            get("zoneColor"), 

            //If it doesn't, default to blue.
            literal("blue")
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        //Use a conditional case expression.
        switchCase(
            //Check to see if feature has a "zoneColor" 
            has("zoneColor"), 

            //If it does, use it.
            get("zoneColor"), 

            //If it doesn't, default to blue.
            literal("blue")
        )
    )
)

Bellen- en symboollagen geven standaard de coördinaten van alle vormen in een gegevensbron weer. Dit gedrag kan de vertices van een veelhoek of een lijn markeren. De optie van de laag kan worden gebruikt om het geometrietype te beperken van de kenmerken die worden weergegeven met behulp van een filter geometryType expressie in een Booleaanse expressie. In het volgende voorbeeld wordt een bellenlaag beperkt, zodat alleen Point functies worden weergegeven.

BubbleLayer layer = new BubbleLayer(source,
    filter(eq(geometryType(), "Point"))
);

val layer = BubbleLayer(source,
    filter(eq(geometryType(), "Point"))
)

In het volgende voorbeeld kunnen Point zowel MultiPoint als -functies worden weergegeven.

BubbleLayer layer = new BubbleLayer(source,
    filter(any(eq(geometryType(), "Point"), eq(geometryType(), "MultiPoint")))
);

val layer = BubbleLayer(source,
    filter(any(eq(geometryType(), "Point"), eq(geometryType(), "MultiPoint")))
)

Op dezelfde manier wordt de omtrek van Veelhoeken weergegeven in lijnlagen. Als u dit gedrag in een lijnlaag wilt uitschakelen, voegt u een filter toe dat alleen functies en LineString MultiLineString toestaat.

Hier zijn enkele aanvullende voorbeelden van het gebruik van gegevensexpressie:

//Get item [2] from an array "properties.abcArray[1]" = "c"
at(2, get("abcArray"))

//Get item [0][1] from a 2D array "properties.array2d[0][1]" = "b"
at(1, at(0, get("array2d")))

//Check to see if a value is in an array "properties.abcArray.indexOf('a') !== -1" = true
in("a", get("abcArray"))

//Get the length of an array "properties.abcArray.length" = 3
length(get("abcArray"))

//Get the value of a subproperty "properties._style.fillColor" = "red"
get("fillColor", get("_style"))

//Check that "fillColor" exists as a subproperty of "_style".
has("fillColor", get("_style"))

Wiskundige expressies

Wiskundige expressies bieden wiskundige operators om gegevensgestuurde berekeningen uit te voeren binnen het expressiekader.

Booleaanse expressies

Booleaanse expressies bieden een set booleaanse operatorexpressies voor het evalueren van booleaanse vergelijkingen.

Bij het vergelijken van waarden wordt de vergelijking strikt getypeerd. Waarden van verschillende typen worden altijd als ongelijk beschouwd. Gevallen waarbij bekend is dat de typen tijdens de parsetijd verschillen, worden als ongeldig beschouwd en veroorzaken een parsefout.

Voorwaardelijke expressies

Voorwaardelijke expressies bieden logische bewerkingen die zijn zoals if-instructies.

Met de volgende expressies worden voorwaardelijke logische bewerkingen uitgevoerd op de invoergegevens. De expressie biedt switchCase bijvoorbeeld 'if/then/else'-logica terwijl de match expressie lijkt op een switch-instructie.

Schakel tussen case-expressies

Een switchCase expressie is een type voorwaardelijke expressie dat 'if/then/else'-logica biedt. Met dit type expressie wordt een lijst met Booleaanse voorwaarden doorlopen. Deze retourneert de uitvoerwaarde van de eerste Booleaanse voorwaarde die moet worden geëvalueerd als waar.

De volgende pseudocode definieert de structuur van de switchCase expressie.

switchCase(
    condition1: boolean expression, 
    output1: value,
    condition2: boolean expression, 
    output2: value,
    ...,
    fallback: value
)

Voorbeeld

In het volgende voorbeeld worden verschillende Booleaanse voorwaarden doorlopen totdat er een wordt gevonden die evalueert naar en vervolgens true die gekoppelde waarde retourneert. Als er geen Booleaanse voorwaarde wordt geëvalueerd als true , wordt een terugvalwaarde geretourneerd.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        switchCase(
            //Check to see if the first boolean expression is true, and if it is, return its assigned result.
            //If it has a zoneColor property, use its value as a color.
            has("zoneColor"), toColor(get("zoneColor")),

            //Check to see if the second boolean expression is true, and if it is, return its assigned result.
            //If it has a temperature property with a value greater than or equal to 100, make it red.
            all(has("temperature"), gte(get("temperature"), 100)), color(Color.RED),

            //Specify a default value to return. In this case green.
            color(Color.GREEN)
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        switchCase(
            //Check to see if the first boolean expression is true, and if it is, return its assigned result.
            //If it has a zoneColor property, use its value as a color.
            has("zoneColor"), toColor(get("zoneColor")),

            //Check to see if the second boolean expression is true, and if it is, return its assigned result.
            //If it has a temperature property with a value greater than or equal to 100, make it red.
            all(has("temperature"), gte(get("temperature"), 100)), color(Color.RED),

            //Specify a default value to return. In this case green.
            color(Color.GREEN)
        )
    )
)

Overeenkomstexpressie

Een match expressie is een type voorwaardelijke expressie dat switch-instructie biedt, zoals logica. De invoer kan elke expressie zijn, zoals get( "entityType") die een tekenreeks of een getal retourneert. Elke stop moet een label hebben dat één letterlijke waarde of een matrix met letterlijke waarden is, waarvan de waarden alle tekenreeksen of alle getallen moeten zijn. De invoer komt overeen als een van de waarden in de matrix overeenkomt. Elk stoplabel moet uniek zijn. Als het invoertype niet overeen komt met het type van de labels, is het resultaat de standaardterugvalwaarde.

De volgende pseudocode definieert de structuur van de match expressie.

match(Expression input, Expression defaultOutput, Expression.Stop... stops)

Voorbeelden

In het volgende voorbeeld wordt de entityType eigenschap van een puntfunctie in een bellenlaag gezocht naar een overeenkomst. Als er een overeenkomst wordt gevonden, wordt die opgegeven waarde geretourneerd of wordt de terugvalwaarde geretourneerd.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        match(
            //Get the input value to match.
            get("entityType"),

            //Specify a default value to return if no match is found.
            color(Color.BLACK),

            //List the values to match and the result to return for each match.

            //If value is "restaurant" return "red".
            stop("restaurant", color(Color.RED)),

            //If value is "park" return "green".
            stop("park", color(Color.GREEN))
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        match(
            //Get the input value to match.
            get("entityType"),

            //Specify a default value to return if no match is found.
            color(Color.BLACK),

            //List the values to match and the result to return for each match.

            //If value is "restaurant" return "red".
            stop("restaurant", color(Color.RED)),

            //If value is "park" return "green".
            stop("park", color(Color.GREEN))
        )
    )
)

In het volgende voorbeeld wordt een matrix gebruikt om een set labels weer te geven die allemaal dezelfde waarde moeten retourneren. Deze aanpak is veel efficiënter dan het afzonderlijk vermelden van elk label. Als de eigenschap in dit geval entityType 'restaurant' of 'grocery_store' is, wordt de kleur 'rood' geretourneerd.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        match(
            //Get the input value to match.
            get("entityType"),

            //Specify a default value to return if no match is found.
            color(Color.BLACK),

            //List the values to match and the result to return for each match.

            //If value is "restaurant" or "grocery_store" return "red".
            stop(Arrays.asList("restaurant", "grocery_store"), color(Color.RED)),

            //If value is "park" return "green".
            stop("park", color(Color.GREEN))
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        match(
            //Get the input value to match.
            get("entityType"),

            //Specify a default value to return if no match is found.
            color(Color.BLACK),

            //List the values to match and the result to return for each match.

            //If value is "restaurant" or "grocery_store" return "red".
            stop(arrayOf("restaurant", "grocery_store"), color(Color.RED)),

            //If value is "park" return "green".
            stop("park", color(Color.GREEN))
        )
    )
)

Samensluitingsexpressie

Met coalesce een expressie wordt een reeks expressies doorlopen totdat de eerste niet-null-waarde is verkregen en die waarde wordt geretourneerd.

De volgende pseudocode definieert de structuur van de coalesce expressie.

coalesce(Expression... input)

Voorbeeld

In het volgende voorbeeld wordt een coalesce expressie gebruikt om de optie van een textField symboollaag in te stellen. Als de eigenschap ontbreekt in de functie of is ingesteld op , zoekt de expressie naar de eigenschap. Als de eigenschap ontbreekt of , wordt deze terugvallen op een title null lege subTitle null tekenreeks.

SymbolLayer layer = new SymbolLayer(source,
    textField(
        coalesce(
            //Try getting the title property.
            get("title"),

            //If there is no title, try getting the subTitle. 
            get("subTitle"),

            //Default to an empty string.
            literal("")
        )
    )
);

val layer = SymbolLayer(source,
    textField(
        coalesce(
            //Try getting the title property.
            get("title"),

            //If there is no title, try getting the subTitle. 
            get("subTitle"),

            //Default to an empty string.
            literal("")
        )
    )
)

Type-expressies

Type-expressies bieden hulpprogramma's voor het testen en converteren van verschillende gegevenstypen, zoals tekenreeksen, getallen en Booleaanse waarden.

Kleurexpressie

Kleurexpressie maakt het gemakkelijker om kleurwaarden te maken en te bewerken.

Voorbeeld

In het volgende voorbeeld wordt een RGB-kleurwaarde gemaakt met een rode waarde van en groene en blauwe waarden die worden berekend door te vermenigvuldigen met de waarde 255 van de eigenschap 2.5 temperature . Als de temperatuur verandert, verandert de kleur in een andere kleurtint van rood.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        //Create a RGB color value.
        rgb(
            //Set red value to 255. Wrap with literal expression since using expressions for other values.
            literal(255f),    

            //Multiple the temperature by 2.5 and set the green value.
            product(literal(2.5f), get("temperature")), 

            //Multiple the temperature by 2.5 and set the blue value.
            product(literal(2.5f), get("temperature")) 
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        //Create a RGB color value.
        rgb(
            //Set red value to 255. Wrap with literal expression since using expressions for other values.
            literal(255f),    

            //Multiple the temperature by 2.5 and set the green value.
            product(literal(2.5f), get("temperature")), 

            //Multiple the temperature by 2.5 and set the blue value.
            product(literal(2.5f), get("temperature")) 
        )
    )
)

Als alle kleurparameters getallen zijn, hoeft u deze niet in te pakken met de literal expressie. Bijvoorbeeld:

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        //Create a RGB color value.
        rgb(
            255f,  //Set red value to 255.

            150f,  //Set green value to 150.

            0f     //Set blue value to 0.
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        //Create a RGB color value.
        rgb(
            255f,  //Set red value to 255.

            150f,  //Set green value to 150.

            0f     //Set blue value to 0.
        )
    )
)

color(parseColor("#ff00ff"))

Expressies van tekenreeksoperator

Expressies voor tekenreeksoperatoren voeren conversiebewerkingen uit op tekenreeksen, zoals het samenvoegen en converteren van de case.

Voorbeeld

In het volgende voorbeeld wordt de eigenschap van de puntfunctie ge converteert naar een tekenreeks en wordt '°F' aan het temperature einde ervan toegevoegd.

SymbolLayer layer = new SymbolLayer(source,
    textField(
        concat(Expression.toString(get("temperature")), literal("°F"))
    ),

    //Some additional style options.
    textOffset(new Float[] { 0f, -1.5f }),
    textSize(12f),
    textColor("white")
);

val layer = SymbolLayer(source,
    textField(
        concat(Expression.toString(get("temperature")), literal("°F"))
    ),

    //Some additional style options.
    textOffset(new Float[] { 0f, -1.5f }),
    textSize(12f),
    textColor("white")
)

Met de bovenstaande expressie wordt een speld op de kaart weergegeven met de tekst '64°F' erboven, zoals wordt weergegeven in de onderstaande afbeelding.

<a name="interpolate-and-step-expressions">Interpoleren en stapexpressie

Interpoleren en stapexpressie kunnen worden gebruikt om waarden te berekenen langs een geïnterpoleerde curve of stapfunctie. Deze expressies nemen een expressie op die een numerieke waarde als invoer retourneert, bijvoorbeeld get("temperature") . De invoerwaarde wordt geëvalueerd op basis van invoer- en uitvoerwaarden om de waarde te bepalen die het beste past bij de geïnterpoleerde curve of stapfunctie. De uitvoerwaarden worden 'stops' genoemd. De invoerwaarden voor elke stop moeten een getal zijn en in oplopende volgorde zijn. De uitvoerwaarden moeten een getal, een matrix met getallen of een kleur zijn.

Expressie interpoleren

Een expressie kan worden gebruikt om een continue, vloeiende set waarden te berekenen interpolate door te interpoleren tussen stopwaarden. Een interpolate expressie die kleurwaarden retourneert, produceert een kleurovergang waaruit resultaatwaarden worden geselecteerd. De interpolate expressie heeft de volgende indelingen:

//Stops consist of two expressions.
interpolate(Expression.Interpolator interpolation, Expression number, Expression... stops)

//Stop expression wraps two values.
interpolate(Expression.Interpolator interpolation, Expression number, Expression.Stop... stops)

Er zijn drie typen interpolatiemethoden die kunnen worden gebruikt in een interpolate expressie:

De stop expressie heeft de indeling stop(stop, value) .

Hier ziet u een voorbeeld van hoe deze verschillende typen interpolaties eruit zien.

Lineair	Exponentieel	Bezier-bezier

Voorbeeld

In het volgende voorbeeld wordt een expressie gebruikt om de eigenschap van een bellenlaag in te stellen op linear interpolate basis van de eigenschap van de bubbleColor temperature puntfunctie. Als de temperature waarde kleiner is dan 60, wordt 'blauw' geretourneerd. Als deze tussen 60 en minder dan 70 is, wordt geel geretourneerd. Als deze tussen 70 en minder dan 80 is, wordt 'oranje' ( #FFA500 ) geretourneerd. Als deze 80 of groter is, wordt 'rood' geretourneerd.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        interpolate(
            linear(),
            get("temperature"),
            stop(50, color(Color.BLUE)),
            stop(60, color(Color.YELLOW)),
            stop(70, color(parseColor("#FFA500"))),
            stop(80, color(Color.RED))
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        interpolate(
            linear(),
            get("temperature"),
            stop(50, color(Color.BLUE)),
            stop(60, color(Color.YELLOW)),
            stop(70, color(parseColor("#FFA500"))),
            stop(80, color(Color.RED))
        )
    )
)

In de volgende afbeelding wordt gedemonstreerd hoe de kleuren worden gekozen voor de bovenstaande expressie.

Stapexpressie

Een expressie kan worden gebruikt om discrete, getrapte resultaatwaarden te berekenen door een step piecewise-constant-functie te evalueren die is gedefinieerd door stops.

De interpolate expressie heeft de volgende indelingen:

step(Expression input, Expression defaultOutput, Expression... stops)

step(Expression input, Expression defaultOutput, Expression.Stop... stops)

step(Expression input, number defaultOutput, Expression... stops)

step(Expression input, number defaultOutput, Expression.Stop... stops)

step(number input, Expression defaultOutput, Expression... stops)

step(number input, Expression defaultOutput, Expression.Stop... stops)

step(number input, number defaultOutput, Expression... stops)

step(number input, number defaultOutput, Expression.Stop... stops)

Stapexpressie retourneert de uitvoerwaarde van de stop net vóór de invoerwaarde, of de eerste invoerwaarde als de invoer kleiner is dan de eerste stop.

Voorbeeld

In het volgende voorbeeld wordt een expressie gebruikt om de eigenschap van een bellenlaag in te stellen op step basis van de eigenschap van de bubbleColor temperature puntfunctie. Als de temperature waarde kleiner is dan 60, wordt 'blauw' geretourneerd. Als deze tussen 60 en minder dan 70 is, wordt 'geel' geretourneerd. Als deze tussen 70 en minder dan 80 is, wordt 'oranje' geretourneerd. Als deze 80 of groter is, wordt 'rood' geretourneerd.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        step(
            get("temperature"),
            color(Color.BLUE),
            stop(60, color(Color.YELLOW)),
            stop(70, color(parseColor("#FFA500"))),
            stop(80, color(Color.RED))
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        step(
            get("temperature"),
            color(Color.BLUE),
            stop(60, color(Color.YELLOW)),
            stop(70, color(parseColor("#FFA500"))),
            stop(80, color(Color.RED))
        )
    )
)

In de volgende afbeelding wordt gedemonstreerd hoe de kleuren worden gekozen voor de bovenstaande expressie.

Laagspecifieke expressies

Speciale expressies die alleen van toepassing zijn op specifieke lagen.

Heatmapdichtheidsexpressie

Een heatmapdichtheidsexpressie haalt de heatmapdichtheidswaarde op voor elke pixel in een heatmap-laag en wordt gedefinieerd als heatmapDensity . Deze waarde is een getal tussen 0 en 1 . Deze wordt gebruikt in combinatie met een or-expressie om de kleurovergang te definiëren die wordt interpolation step gebruikt om de heatmap te kleuren. Deze expressie kan alleen worden gebruikt in de heatmapColor optie van de heatmaplaag.

Voorbeeld

In dit voorbeeld wordt een interpolatie-expressie voor interpolatie gebruikt om een vloeiend kleurovergang te maken voor het weergeven van de heatmap.

HeatMapLayer layer = new HeatMapLayer(source,
    heatmapColor(
        interpolate(
            linear(),
            heatmapDensity(),
            stop(0, color(Color.TRANSPARENT)),
            stop(0.01, color(Color.MAGENTA)),
            stop(0.5, color(parseColor("#fb00fb"))),
            stop(1, color(parseColor("#00c3ff")))
        )
    )
);

val layer = HeatMapLayer(source,
    heatmapColor(
        interpolate(
            linear(),
            heatmapDensity(),
            stop(0, color(Color.TRANSPARENT)),
            stop(0.01, color(Color.MAGENTA)),
            stop(0.5, color(parseColor("#fb00fb"))),
            stop(1, color(parseColor("#00c3ff")))
        )
    )
)

Naast het gebruik van een vloeiende kleurovergang om een heatmap te kleuren, kunnen kleuren worden opgegeven binnen een reeks reeksen met behulp van een step expressie. Met behulp van een expressie voor het kleuren van de heatmap wordt de dichtheid visueel opgebrekt in reeksen die lijken op een kaart in de vorm van een contour of step radar.

HeatMapLayer layer = new HeatMapLayer(source,
    heatmapColor(
        step(
            heatmapDensity(),
            color(Color.TRANSPARENT),
            stop(0.01, color(parseColor("#000080"))),
            stop(0.25, color(parseColor("#000080"))),
            stop(0.5, color(Color.GREEN)),
            stop(0.5, color(Color.YELLOW)),
            stop(1, color(Color.RED))
        )
    )
);

val layer = HeatMapLayer(source,
    heatmapColor(
        step(
            heatmapDensity(),
            color(Color.TRANSPARENT),
            stop(0.01, color(parseColor("#000080"))),
            stop(0.25, color(parseColor("#000080"))),
            stop(0.5, color(Color.GREEN)),
            stop(0.5, color(Color.YELLOW)),
            stop(1, color(Color.RED))
        )
    )
)

Zie de documentatie Een heatmaplaag toevoegen voor meer informatie.

Expressie voor de voortgang van de regel

Een expressie voor de voortgang van de regel haalt de voortgang op langs een kleurovergangslijn in een lijnlaag en wordt gedefinieerd als lineProgress() . Deze waarde is een getal tussen 0 en 1. Deze wordt gebruikt in combinatie met een interpolation step or-expressie. Deze expressie kan alleen worden gebruikt met de strokeGradient optie van de lijnlaag.

Voorbeeld

In dit voorbeeld wordt de lineProgress() expressie gebruikt om een kleurovergang toe te passen op de lijnlijn.

LineLayer layer = new LineLayer(source,
    strokeGradient(
        interpolate(
            linear(),
            lineProgress(),
            stop(0, color(Color.BLUE)),
            stop(0.1, color(Color.argb(255, 65, 105, 225))), //Royal Blue
            stop(0.3, color(Color.CYAN)),
            stop(0.5, color(Color.argb(255,0, 255, 0))), //Lime
            stop(0.7, color(Color.YELLOW)),
            stop(1, color(Color.RED))
        )
    )
);

val layer = LineLayer(source,
    strokeGradient(
        interpolate(
            linear(),
            lineProgress(),
            stop(0, color(Color.BLUE)),
            stop(0.1, color(Color.argb(255, 65, 105, 225))), //Royal Blue
            stop(0.3, color(Color.CYAN)),
            stop(0.5, color(Color.argb(255,0, 255, 0))), //Lime
            stop(0.7, color(Color.YELLOW)),
            stop(1, color(Color.RED))
        )
    )
)

Livevoorbeeld bekijken

Expressie voor tekstveldopmaak

De format expressie kan worden gebruikt met de optie van de textField symboollaag om gemengde tekstopmaak te bieden. Deze expressie maakt gebruik van een of meer formatEntry expressies die een tekenreeks en set opgeven die aan het formatOptions tekstveld moeten worden toevoegen.

De volgende indelingsopties zijn beschikbaar:

Voorbeeld

In het volgende voorbeeld wordt het tekstveld opgemaakt door een vet lettertype toe te voegen en de tekengrootte van de eigenschap van de functie title omhoog te schalen. In dit voorbeeld wordt ook de subTitle eigenschap van de functie toegevoegd op een nieuwe lijn, met een omlaag geschaalde tekengrootte.

SymbolLayer layer = new SymbolLayer(source,
    textField(
        format(
            //Bold the title property and scale its font size up.
            formatEntry(
                get("title"),
                formatTextFont(new String[] { "StandardFont-Bold" }),
                formatFontScale(1.25)),

            //Add a new line without any formatting.
            formatEntry("\n"),

            //Scale the font size down of the subTitle property.
            formatEntry(
                get("subTitle"),
                formatFontScale(0.75))
        )
    )
);

val layer = SymbolLayer(source,
    textField(
        format(
            //Bold the title property and scale its font size up.
            formatEntry(
                get("title"),
                formatTextFont(arrayOf("StandardFont-Bold")),
                formatFontScale(1.25)),

            //Add a new line without any formatting.
            formatEntry("\n"),

            //Scale the font size down of the subTitle property.
            formatEntry(
                get("subTitle"),
                formatFontScale(0.75))
        )
    )
)

Met deze laag wordt de puntfunctie weergegeven, zoals wordt weergegeven in de onderstaande afbeelding:

Zoomexpressie

Een expressie wordt gebruikt om het huidige zoomniveau van de kaart op te halen tijdens het zoom renderen en wordt gedefinieerd als zoom() . Deze expressie retourneert een getal tussen het minimum- en maximumbereik van het zoomniveau van de kaart. De Azure Kaarten interactieve kaartbesturingselementen voor web en Android ondersteunen 25 zoomniveaus, genummerd van 0 tot en met 24. Met behulp zoom van de expressie kunnen stijlen dynamisch worden gewijzigd wanneer het zoomniveau van de kaart wordt gewijzigd. De zoom expressie mag alleen worden gebruikt met - en interpolate step -expressies.

Voorbeeld

Standaard hebben de radii van gegevenspunten die worden weergegeven in de heatmaplaag een vaste pixel radius voor alle zoomniveaus. Wanneer de kaart wordt ingezoomd, worden de gegevens samengevoegd en ziet de heatmaplaag er anders uit. Een expressie kan worden gebruikt om de radius voor elk zoomniveau te schalen, zodat elk gegevenspunt hetzelfde fysieke zoom gebied van de kaart beslaat. De heatmaplaag ziet er dan statischer en consistenter uit. Elk zoomniveau van de kaart heeft twee keer zoveel pixels verticaal en horizontaal als het vorige zoomniveau. Door de radius te schalen, zodat deze met elk zoomniveau wordt verdubbeld, wordt een heatmap gemaakt die consistent is op alle zoomniveaus. Dit kan worden bereikt met behulp van de expressie met een expressie, met de pixel radius ingesteld voor het minimale zoomniveau en een geschaalde radius voor het maximale zoomniveau dat wordt berekend zoals hieronder wordt zoom base 2 exponential interpolation 2 * Math.pow(2, minZoom - maxZoom) weergegeven.

HeatMapLayer layer = new HeatMapLayer(source,
    heatmapRadius(
        interpolate(
            exponential(2),
            zoom(),

            //For zoom level 1 set the radius to 2 pixels.
            stop(1, 2),

            //Between zoom level 1 and 19, exponentially scale the radius from 2 pixels to 2 * (maxZoom - minZoom)^2 pixels.
            stop(19, 2 * Math.pow(2, 19 - 1))
        )
    )
);

val layer = HeatMapLayer(source,
    heatmapRadius(
        interpolate(
            exponential(2),
            zoom(),

            //For zoom level 1 set the radius to 2 pixels.
            stop(1, 2),

            //Between zoom level 1 and 19, exponentially scale the radius from 2 pixels to 2 * (maxZoom - minZoom)^2 pixels.
            stop(19, 2 * Math.pow(2, 19 - 1))
        )
    )
)

Expressies voor variabelebinding

Expressies voor variabelebinding slaan de resultaten van een berekening op in een variabele. Zodat er meerdere keren naar de resultaten van de berekening kan worden verwezen in een expressie. Het is een nuttige optimalisatie voor expressies die veel berekeningen omvatten.

Voorbeeld

In dit voorbeeld wordt een expressie gebruikt die de omzet ten opzichte van de temperatuurverhouding berekent en vervolgens een expressie gebruikt om verschillende case Booleaanse bewerkingen op deze waarde te evalueren. De expressie wordt gebruikt om de omzet ten opzichte van de temperatuurverhouding let op te slaan, zodat deze slechts één keer hoeft te worden berekend. De var expressie verwijst zo vaak naar deze variabele als nodig is zonder dat deze opnieuw moet worden berekend.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(           
        let(
            //Divide the point features `revenue` property by the `temperature` property and store it in a variable called `ratio`.
            literal("ratio"), division(get("revenue"), get("temperature")),

            //Evaluate the child expression in which the stored variable will be used.
            switchCase(
                //Check to see if the ratio is less than 100, return 'red'.
                lt(var("ratio"), 100), color(Color.RED),

                //Check to see if the ratio is less than 200, return 'green'.
                lt(var("ratio"), 200), color(Color.GREEN),

                //Return `blue` for values greater or equal to 200.
                color(Color.BLUE)
            )
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(           
        let(
            //Divide the point features `revenue` property by the `temperature` property and store it in a variable called `ratio`.
            literal("ratio"), division(get("revenue"), get("temperature")),

            //Evaluate the child expression in which the stored variable will be used.
            switchCase(
                //Check to see if the ratio is less than 100, return 'red'.
                lt(var("ratio"), 100), color(Color.RED),

                //Check to see if the ratio is less than 200, return 'green'.
                lt(var("ratio"), 200), color(Color.GREEN),

                //Return `blue` for values greater or equal to 200.
                color(Color.BLUE)
            )
        )
    )
)

Volgende stappen

Meer informatie over de lagen die ondersteuning bieden voor expressies: