Datengesteuerte Formatvorlagenausdrücke im iOS SDK (Vorschau)

Artikel
04/06/2023

Hinweis

Einstellung des Azure Maps iOS SDK

Das Azure Maps Native SDK für iOS ist jetzt veraltet und wird am 31.3.25 eingestellt. Um Dienstunterbrechungen zu vermeiden, migrieren Sie bis zum 31.3.25 zum Azure Maps Web SDK. Weitere Informationen finden Sie unter Anleitung zur Migration des Azure Maps iOS SDK.

Ebenen verwenden Prädikate und Ausdrücke, um zu bestimmen, welche Elemente angezeigt und wie sie formatiert werden sollen. Prädikate werden durch die gleiche Klasse vom Typ NSPredicate dargestellt, die Ergebnisse aus Kerndaten oder Elementen in einem NSArray in Objective-C filtert. Prädikate basieren auf Ausdrücken, die durch die Klasse NSExpression dargestellt werden.

In diesem Dokument wird die spezifische Teilmenge der Prädikat- und Ausdruckssyntax erläutert, die von diesem SDK unterstützt wird. Eine allgemeinere Einführung in Prädikate und Ausdrücke finden Sie in der Apple-Entwicklerdokumentation im Handbuch für die Prädikatprogrammierung.

Verwenden von Prädikaten zum Filtern von Vektordaten

Von den meisten Ebenenklassen werden Objekte vom Typ Feature angezeigt, die Sie basierend auf den Eigenschaften des Features ein- oder ausblenden können. Verwenden Sie die Option filter, um nur die Features in die Quellebene einzuschließen, die eine von Ihnen definierte Bedingung erfüllen.

Operatoren

Folgende Vergleichsoperatoren werden unterstützt:

`NSPredicateOperatorType`	Syntax der Formatzeichenfolge
`NSEqualToPredicateOperatorType`	`key = value` `key == value`
`NSGreaterThanOrEqualToPredicateOperatorType`	`key >= value` `key => value`
`NSLessThanOrEqualToPredicateOperatorType`	`key <= value` `key =< value`
`NSGreaterThanPredicateOperatorType`	`key > value`
`NSLessThanPredicateOperatorType`	`key < value`
`NSNotEqualToPredicateOperatorType`	`key != value` `key <> value`
`NSBetweenPredicateOperatorType`	`key BETWEEN { 32, 212 }`

Um zu testen, ob ein Feature über eine bestimmte Eigenschaft verfügt, können Sie das Attribut mit NULL oder NIL vergleichen. Mit dem Initialisierer NSPredicate(value:) erstellte Prädikate werden ebenfalls unterstützt. Zeichenfolgenoperatoren und benutzerdefinierte Operatoren werden nicht unterstützt.

Folgende Verbundoperatoren werden unterstützt:

`NSCompoundPredicateType`	Syntax der Formatzeichenfolge
`NSAndPredicateType`	`predicate1 AND predicate2` `predicate1 && predicate2`
`NSOrPredicateType`	`predicate1 OR predicate2` `predicate1 \\|\\| predicate2`
`NSNotPredicateType`	`NOT predicate` `!predicate`

Folgende Aggregatoperatoren werden unterstützt:

`NSPredicateOperatorType`	Syntax der Formatzeichenfolge
`NSInPredicateOperatorType`	`key IN { 'iOS', 'macOS', 'tvOS', 'watchOS' }`
`NSContainsPredicateOperatorType`	`{ 'iOS', 'macOS', 'tvOS', 'watchOS' } CONTAINS key`

Sie können die Operatoren IN und CONTAINS verwenden, um zu testen, ob ein Wert in einer Auflistung enthalten ist, ob eine Zeichenfolge eine Teilzeichenfolge einer größeren Zeichenfolge ist oder ob sich das ausgewertete Feature (SELF) in einem bestimmten Feature befindet.

Folgende Kombinationen von Vergleichsoperatoren und Modifizierern werden unterstützt:

`NSComparisonPredicateModifier`	`NSPredicateOperatorType`	Syntax der Formatzeichenfolge
`NSAllPredicateModifier`	`NSNotEqualToPredicateOperatorType`	`ALL haystack != needle`
`NSAnyPredicateModifier`	`NSEqualToPredicateOperatorType`	`ANY haystack = needle` `SOME haystack = needle`

Für Vergleichs- und Aggregatoperatoren, die im Prädikat verwendet werden, werden folgende Vergleichsprädikatoptionen unterstützt:

`NSComparisonPredicateOptions`	Syntax der Formatzeichenfolge
`NSCaseInsensitivePredicateOption`	`'QUEBEC' =[c] 'Quebec'`
`NSDiacriticInsensitivePredicateOption`	`'Québec' =[d] 'Quebec'`

Andere Vergleichsprädikatoptionen (l für die Beachtung des Gebietsschemas und n für die Normalisierung) werden nicht unterstützt. Bei einem Vergleich wird das Gebietsschema beachtet, solange die Groß-/Kleinschreibung und diakritische Zeichen nicht beachtet werden. Vergleichsprädikatoptionen werden bei Vergleichsmodifizierern wie ALL und ANY nicht unterstützt.

Operanden

Operanden in Prädikaten können Variablen, Schlüsselpfade und nahezu alles andere sein, was in einem Ausdruck vorkommen kann.

Es wird keine automatische Typumwandlung ausgeführt. Daher entspricht ein Feature nur dann einem Prädikat, wenn der Wert für die betreffende Eigenschaft vom gleichen Typ ist wie der im Prädikat angegebene Wert. Verwenden Sie den Operator CAST(), um einen Schlüsselpfad oder eine Variable in einen entsprechenden Typ zu konvertieren:

Verwenden Sie CAST(key, 'NSNumber'), um einen Wert in eine Zahl umzuwandeln.
Verwenden Sie CAST(key, 'NSString'), um einen Wert in eine Zeichenfolge umzuwandeln.
Verwenden Sie CAST(key, 'UIColor'), um einen Wert in eine Farbe umzuwandeln.
Verwenden Sie CAST(noindex(color), 'NSArray'), um ein Objekt vom Typ UIColor in ein Array umzuwandeln.

Weitere Informationen zur Syntax von Prädikatformatzeichenfolgen finden Sie in der Apple-Entwicklerdokumentation im Kapitel „Syntax von Prädikatformatzeichenfolgen“ des Handbuchs für die Prädikatprogrammierung.

Beispiele für Operanden

Blasen- und Symbolebenen rendern standardmäßig die Koordinaten aller Geometrien in einer Datenquelle. Dieses Verhalten kann die Scheitelpunkte eines Polygons oder einer Linie hervorheben. Die Option filter der Ebene kann verwendet werden, um den Geometrietyp der gerenderten Features durch die Verwendung von NSExpression.geometryTypeAZMVariable innerhalb eines Prädikats zu beschränken. Im folgenden Beispiel wird eine Blasenebene so beschränkt, dass nur Point-Features gerendert werden.

let layer = BubbleLayer(source: source, options: [
    .filter(
        from: NSPredicate(format: "%@ == \"Point\"", NSExpression.geometryTypeAZMVariable)
    )
])

Im folgenden Beispiel können sowohl Point- als auch Polygon-Features gerendert werden.

let layer = BubbleLayer(source: source, options: [
    .filter(
        from: NSCompoundPredicate(orPredicateWithSubpredicates: [
            NSPredicate(format: "%@ == \"Point\"", NSExpression.geometryTypeAZMVariable),
            NSPredicate(format: "%@ == \"Polygon\"", NSExpression.geometryTypeAZMVariable)
        ])
    )
])

Verwenden von Ausdrücken zum Konfigurieren von Ebenenoptionen

Ein Ausdruck kann verschiedenartige Teilausdrücke enthalten. Im Anschluss werden die unterstützten Arten von Ausdrücken erläutert.

In einigen Beispielen in diesem Abschnitt des Dokuments wird das folgende Feature verwendet, um die verschiedenen Verwendungsmöglichkeiten dieser Ausdrücke zu zeigen:

{
    "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"
        }
    }
}

Der folgende Code veranschaulicht, wie dieses GeoJSON-Feature in einer App manuell erstellt wird.

// Create a point feature.
let feature = Feature(Point(CLLocationCoordinate2D(latitude: 45, longitude: -100)))

// Add properties to the feature.
feature.addProperty("id", value:  123)
feature.addProperty("entityType", value: "restaurant")
feature.addProperty("revenue", value:  12345)
feature.addProperty("subTitle", value: "Building 40")
feature.addProperty("temperature", value:  64)
feature.addProperty("title", value: "Cafeteria")
feature.addProperty("zoneColor", value: "purple")
feature.addProperty("abcArray", value: ["a", "b", "c"])
feature.addProperty("array2d", value: [["a", "b"], ["x", "y"]])
feature.addProperty("_style", value: ["fillColor": "red"])

Der folgende Code zeigt, wie die in eine Zeichenfolge umgewandelte Version des JSON-Objekts in ein GeoJSON-Feature in einer App deserialisiert wird.

let 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\"}}}"

let feature = Feature.fromJson(featureString)

JSON-basiert

Das Azure Maps Web SDK unterstützt auch datengesteuerte Formatvorlagenausdrücke, die mit einem JSON-Array dargestellt werden. Die gleichen Ausdrücke können mithilfe der nativen Klasse NSExpression im iOS SDK neu erstellt werden. Alternativ können diese JSON-basierten Ausdrücke für die iOS-App freigegeben (beispielsweise durch Anfügen an die Antwort) und an die Methode NSExpression(azmJSONObject:) übergeben werden. Nehmen Sie als Beispiel folgenden JSON-Ausdruck.

var exp = ['get','title'];

Die Swift-Version des obigen Ausdrucks wäre ["get", "title"]. Sie kann wie folgt in das iOS SDK gelesen werden:

let jsonResponse = ["get", "title"]
let exp = NSExpression(azmJSONObject: jsonResponse)

Diese Vorgehensweise kann die Wiederverwendung von Formatvorlagenausdrücken zwischen mobilen Apps und Web-Apps erleichtern, die Azure Maps nutzen.

Dieses Video bietet eine Übersicht über die datengesteuerte Formatierung in Azure Maps.

Internet of Things Show: Datengesteuertes Formatieren mit Azure Maps

Konstante Werte

Ein konstanter Wert kann einen der folgenden Typen aufweisen:

UIColor
String
NSNumber.boolValue
NSNumber.doubleValue
[Float]
[String]
NSValue.cgVectorValue
NSValue.uiEdgeInsetsValue

Beispiel für konstante Werte

NSExpression(forConstantValue: UIColor.red)
NSExpression(forConstantValue: "constant")
NSExpression(forConstantValue: true)
NSExpression(forConstantValue: 20)
NSExpression(forConstantValue: [20, 21, 22])
NSExpression(forConstantValue: ["constant1", "constant2"])
NSExpression(forConstantValue: NSValue(cgVector: CGVector(dx: 2, dy: -4)))
NSExpression(forConstantValue: NSValue(uiEdgeInsets: UIEdgeInsets(top: 8, left: 0, bottom: 8, right: 0)))

Schlüsselpfade

Ein Schlüsselpfadausdruck bezieht sich auf eine Eigenschaft des Objekts Feature, für das eine Anzeigeauswertung durchgeführt wird. Ein Beispiel: Wenn das Wörterbuch Feature.properties eines Polygons den Schlüssel floorCount enthält, verweist der Schlüsselpfad floorCount auf den Wert der Eigenschaft floorCount, wenn dieses bestimmte Polygon ausgewertet wird.

Einige Zeichen können nicht direkt als Teil eines Schlüsselpfads in einer Formatzeichenfolge verwendet werden. Wenn die Eigenschaft eines Features beispielsweise ISO 3166-1:2006 heißt, führt die Ausdrucksformatzeichenfolge lowercase(ISO 3166-1:2006) bzw. die Prädikatformatzeichenfolge ISO 3166-1:2006 == 'US-OH' zu einer Ausnahme. Verwenden Sie stattdessen einen Platzhalter (%K) oder den Initialisierer NSExpression(forKeyPath:):

NSPredicate(format: "%K == 'US-OH'", "ISO 3166-1:2006")
NSExpression(
   forFunction: "lowercase:",
   arguments: [NSExpression(forKeyPath: "ISO 3166-1:2006")]
)

Functions

Von den vordefinierten Funktionen der Methode NSExpression(forFunction:arguments:) wird die folgende Teilmenge in Ebenenoptionen unterstützt:

Initialisiererparameter	Syntax der Formatzeichenfolge
`average:`	`average({1, 2, 2, 3, 4, 7, 9})`
`sum:`	`sum({1, 2, 2, 3, 4, 7, 9})`
`count:`	`count({1, 2, 2, 3, 4, 7, 9})`
`min:`	`min({1, 2, 2, 3, 4, 7, 9})`
`max:`	`max({1, 2, 2, 3, 4, 7, 9})`
`add:to:`	`1 + 2`
`from:subtract:`	`2 - 1`
`multiply:by:`	`1 * 2`
`divide:by:`	`1 / 2`
`modulus:by:`	`modulus:by:(1, 2)`
`sqrt:`	`sqrt(2)`
`log:`	`log(10)`
`ln:`	`ln(2)`
`raise:toPower:`	`2 ** 2`
`exp:`	`exp(0)`
`ceiling:`	`ceiling(0.99999)`
`abs:`	`abs(-1)`
`trunc:`	`trunc(6378.1370)`
`floor:`	`floor(-0.99999)`
`uppercase:`	`uppercase('Elysian Fields')`
`lowercase:`	`lowercase('DOWNTOWN')`
`noindex:`	`noindex(0 + 2 + c)`
`length:`	`length('Wapakoneta')`
`castObject:toType:`	`CAST(ele, 'NSString')` `CAST(ele, 'NSNumber')`

Folgende vordefinierte Funktionen werden nicht unterstützt:

Initialisiererparameter	Syntax der Formatzeichenfolge
`median:`	`median({1, 2, 2, 3, 4, 7, 9})`
`mode:`	`mode({1, 2, 2, 3, 4, 7, 9})`
`stddev:`	`stddev({1, 2, 2, 3, 4, 7, 9})`
`random`	`random()`
`randomn:`	`randomn(10)`
`now`	`now()`
`bitwiseAnd:with:`	`bitwiseAnd:with:(5, 3)`
`bitwiseOr:with:`	`bitwiseOr:with:(5, 3)`
`bitwiseXor:with:`	`bitwiseXor:with:(5, 3)`
`leftshift:by:`	`leftshift:by:(23, 1)`
`rightshift:by:`	`rightshift:by:(23, 1)`
`onesComplement:`	`onesComplement(255)`
`distanceToLocation:fromLocation:`	`distanceToLocation:fromLocation:(there, here)`

Bedingungen

Bedingungen werden über die integrierte Methode NSExpression(forAZMConditional:trueExpression:falseExpression:) und den Operator TERNARY() unterstützt. Wenn Sie mehrere Fälle ausdrücken möchten („else-if“), können Sie entweder geschachtelte Bedingungen oder den Match-Ausdruck verwenden.

Beispiel für Bedingungen

Im folgenden Beispiel werden verschiedene Prädikate durchlaufen, bis eines gefunden wird, deren Auswertung true ergibt. Anschließend wird der als „true“ ausgewertete Ausdruck zurückgegeben. Wenn kein Prädikat zu true ausgewertet wird, wird der letzte falsche Ausdruck zurückgegeben.

let layer = BubbleLayer(
    source: source,
    options: [
        .bubbleColor(
            from: NSExpression(
                // Check to see whether a feature has a zoneColor property
                forAZMConditional: NSPredicate(format: "zoneColor != NIL"),
                // If it has a zoneColor property, use its value as a color.
                trueExpression: NSExpression(forKeyPath: "zoneColor"),
                // if not, do another check
                falseExpression: NSExpression(
                    // Check to see whether it has a temperature property with a value greater than or equal to 100.
                    forConditional: NSPredicate(format: "temperature != nil && temperature >= 100"),
                    // If it has, use red color.
                    trueExpression: NSExpression(forConstantValue: UIColor.red),
                    // If not, use green color.
                    falseExpression: NSExpression(forConstantValue: UIColor.green)
                )
            )
        )
    ]
)

Aggregate

Aggregatausdrücke können Arrays von Ausdrücken enthalten. In einigen Fällen kann das Array selbst verwendet werden, ohne es mit einem Aggregatausdruck zu umschließen.

Variablen

Das iOS SDK definiert die folgenden Variablen für die Verwendung mit Ebenenoptionen.

Featurebezeichner

Die ID eines Features. Diese Variable entspricht der Eigenschaft NSExpression.featureIdentifierAZMVariable.

Syntax der Formatzeichenfolge:$featureIdentifier

Funktionseigenschaften

Das Eigenschaftenobjekt eines Features. Diese Variable entspricht der Eigenschaft NSExpression.featurePropertiesAZMVariable.

Syntax der Formatzeichenfolge:$featureAttributes

Akkumuliertes Feature

Der Wert einer bis zu diesem Punkt akkumulierten Clustereigenschaft. Dieser kann nur in der Option clusterProperties einer gruppierten DataSource-Quelle verwendet werden. Diese Variable entspricht der Eigenschaft NSExpression.featureAccumulatedAZMVariable.

Syntax der Formatzeichenfolge:$featureAccumulated

Geometrietyp

Der durch das Feature dargestellte Geometrietyp. Der Typ eines Features ist eine der folgenden Zeichenfolgen:

Point für Punktfeatures (entspricht der Klasse Point).
MultiPoint für Punktsammlungsfeatures (entspricht der Klasse PointCollection).
LineString für Polylinienfeatures (entspricht der Klasse Polyline).
MultiLineString für mehrere Polylinienfeatures (entspricht der Klasse MultiPolyline).
Polygon für Polygonfeatures (entspricht der Klasse Polygon).
MultiPolygon für mehrere Polygonfeatures (entspricht der Klasse MultiPolygon).
GeometryCollection für Geometriesammlungsfeatures (entspricht der Klasse GeometryCollection).

Diese Variable entspricht der Eigenschaft NSExpression.geometryTypeAZMVariable.

Syntax der Formatzeichenfolge:$geometryType

Variablenbeispiel

Siehe Beispiele für Operanden.

Zoom

Die aktuelle Zoomebene. In den Formatvorlagenoptionen der Ebene wird diese Variable ggf. nur als Ziel eines Interpolations- oder Step-Ausdrucks der obersten Ebene angezeigt. Diese Variable entspricht der Eigenschaft NSExpression.zoomLevelAZMVariable.

Syntax der Formatzeichenfolge:$zoomLevel

Zoombeispiel

Standardmäßig ist für die auf der Wärmebildebene gerenderten Daten ein fester Punktradius für alle Zoomebenen definiert. Wenn die Karte gezoomt wird, werden die Daten aggregiert und die Wärmebildebene verändert sich. Zum Skalieren des Radius für jede Zoomebene kann ein zoom-Ausdruck verwendet werden, sodass jeder Datenpunkt den gleichen physischen Bereich der Karte abdeckt. Dadurch wirkt die Wärmebildebene statischer und konsistenter. Jede Zoomebene der Karte hat vertikal und horizontal doppelt so viele Punkte wie die vorherige Zoomebene. Wenn der Radius so skaliert wird, dass er sich mit jeder Zoomebene verdoppelt, wird ein Wärmebild erstellt, das auf allen Zoomebenen einheitlich aussieht. Hierfür kann der Ausdruck zoom mit einem Ausdruck vom Typ base 2 exponential interpolation verwendet werden, wobei der Punktradius für die minimale Zoomebene und ein skalierter Radius für die maximale Zoomebene mit der Berechnung pow(2, maxZoom - minZoom) * radius festgelegt ist, wie im Anschluss gezeigt.

let layer = HeatMapLayer(
   source: source,
   options: [
      .heatmapRadius(
         from: NSExpression(
            forAZMInterpolating: .zoomLevelAZMVariable,
            curveType: .exponential,
            parameters: NSExpression(forConstantValue: 2),
            stops: NSExpression(forConstantValue: [
               // For zoom level 1 set the radius to 2 points.
               1: 2,

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

Wärmebilddichte

Die Kerneldichteschätzung eines Bildschirmpunkts auf einer Wärmebildebene. Anders ausgedrückt: Ein relatives Maß dafür, wie viele Datenpunkte ein bestimmtes Pixel umgeben. Diese Variable ergibt eine Zahl zwischen 0 und 1. Er wird zusammen mit einem interpolation- oder step-Ausdruck verwendet, um den Farbverlauf zu definieren, der zum Einfügen der Farben in das Wärmebild genutzt wird. Kann nur in der Option heatmapColor der Wärmebildebene verwendet werden. Diese Variable entspricht der Eigenschaft NSExpression.heatmapDensityAZMVariable.

Syntax der Formatzeichenfolge:$heatmapDensity

Tipp

Die Farbe bei Index „0“ in einem interpolation-Ausdruck bzw. die Standardfarbe einer Schrittfarbe definiert die Farbe in einem Bereich ohne Daten. Die Farbe bei Index 0 kann verwendet werden, um eine Hintergrundfarbe zu definieren. Viele Benutzer legen hierfür einen transparenten Wert oder ein halbtransparentes Schwarz fest.

Beispiel für Wärmebilddichte

In diesem Beispiel wird ein Ausdruck mit linearer Interpolation verwendet, um einen nahtlosen Farbverlauf zum Rendern des Wärmebilds zu erstellen.

let layer = HeatMapLayer(
   source: source,
   options: [
      .heatmapColor(
         from: NSExpression(
            forAZMInterpolating: .heatmapDensityAZMVariable,
            curveType: .linear,
            parameters: nil,
            stops: NSExpression(forConstantValue: [
               0: UIColor.magenta.withAlphaComponent(0),
               0.01: UIColor.magenta,
               0.5: UIColor(red: 251 / 255, green: 0, blue: 251 / 255, alpha: 1),
               1: UIColor(red: 0, green: 195 / 255, blue: 1, alpha: 1)
            ])
         )
      )
   ]
)

Neben der Verwendung eines nahtlosen Farbverlaufs, um ein Wärmebild mit Farben zu versehen, können Farben mithilfe eines Step-Ausdrucks auch innerhalb einer Gruppe von Bereichen angegeben werden. Durch die Verwendung eines Step-Ausdrucks für die farbige Darstellung des Wärmebilds wird die Dichte visuell in Bereiche gegliedert, die einer Kontur- oder Radarkarte ähneln.

let layer = HeatMapLayer(
   source: source,
   options: [
      .heatmapColor(
         from: NSExpression(
            forAZMStepping: .heatmapDensityAZMVariable,
            from: NSExpression(forConstantValue: UIColor.clear),
            stops: NSExpression(forConstantValue: [
               0.01: UIColor(red: 0, green: 0, blue: 128 / 255, alpha: 1),
               0.25: UIColor.cyan,
               0.5: UIColor.green,
               0.75: UIColor.yellow,
               1: UIColor.red
            ])
         )
      )
   ]
)

Weitere Informationen finden Sie im Artikel Hinzufügen einer Wärmebildebene.

Linienfortschritt

Eine Zahl, die den relativen Abstand an einem bestimmten Punkt entlang einer Linie angibt. Diese Variable ergibt am Anfang der Linie 0 und am Ende der Linie 1. Kann nur mit der Option LineLayerOption.strokeGradient der Linienebene verwendet werden. Entspricht der Eigenschaft NSExpression.lineProgressAZMVariable.

Syntax der Formatzeichenfolge:$lineProgress

Hinweis

Für die strokeGradient-Option der Linienebene muss die lineMetrics-Option der Datenquelle auf true festgelegt sein.

Beispiel für Linienfortschritt

In diesem Beispiel wird der NSExpression.lineProgressAZMVariable-Ausdruck verwendet, um einen Farbverlauf auf den Strich einer Linie anzuwenden.

let layer = LineLayer(
   source: source,
   options: [
      .strokeGradient(
         from: NSExpression(
            forAZMInterpolating: NSExpression.lineProgressAZMVariable,
            curveType: .linear,
            parameters: nil,
            stops: NSExpression(forConstantValue: [
               0: UIColor.blue,
               0.1: UIColor(red: 0.25, green: 0.41, blue: 1, alpha: 1), // Royal Blue
               0.3: UIColor.cyan,
               0.5: UIColor(red: 0, green: 1, blue: 0, alpha: 1), // Lime
               0.7: UIColor.yellow,
               1: UIColor.red
            ])
         )
      )
   ]
)

Livebeispiel

Azure Maps-spezifische Methoden

Der folgende Abschnitt enthält spezifische Informationen zu Azure Maps-Methoden, die die Klasse NSExpressionerweitern:

Match-Ausdruck

Ein Match-Ausdruck ist eine Art von bedingtem Ausdruck, der eine Logik wie bei einer switch-Anweisung ermöglicht. Die Eingabe kann ein beliebiger Ausdruck sein, z. B. NSExpression(forKeyPath: "entityType"), bei dem eine Zeichenfolge oder eine Zahl zurückgegeben wird. Beim abgeglichenen Ausdruck handelt es sich um ein Wörterbuch, das Schlüssel als Ausdrücke enthalten sollte, die entweder zu einer einzelnen Zeichenfolge oder Zahl oder zu einem Array aller Zeichenfolgen oder aller Zahlen und Werte als beliebige Ausdrücke ausgewertet werden. Falls der Eingabeausdruckstyp nicht dem Typ der Schlüssel entspricht, ist das Ergebnis der standardmäßige Fallbackwert.

Beispiele für Match-Ausdrücke

Im folgenden Beispiel wird die Eigenschaft entityType eines Features vom Typ Point auf einer Blasenebene untersucht und nach einer Übereinstimmung gesucht. Wenn eine Übereinstimmung gefunden wird, wird dieser angegebene Wert zurückgegeben. Andernfalls wird der Fallbackwert zurückgegeben.

let layer = BubbleLayer(
    source: source,
    options: [
        .bubbleColor(
            from: NSExpression(
                // Get the input value to match.
                forAZMMatchingKey: NSExpression(forKeyPath: "entityType"),
                // List the keys to match and the value to return for each match.
                in: [
                    // If value is "restaurant" return red color.
                    NSExpression(forConstantValue: "restaurant"): NSExpression(forConstantValue: UIColor.red),
                    // If value is "park" return green color.
                    NSExpression(forConstantValue: "park"): NSExpression(forConstantValue: UIColor.green)
                ],
                // Specify a default value to return if no match is found.
                default: NSExpression(forConstantValue: UIColor.black)
            )
        )
    ]
)

Im folgenden Beispiel wird ein Ausdruck verwendet, der zu einem Zeichenfolgenarray ausgewertet wird, um eine Gruppe von Bezeichnungen anzugeben, von denen jeweils der gleiche Wert zurückgeben werden soll. Dieser Ansatz ist viel effizienter als das einzelne Auflisten aller Bezeichnungen. In diesem Fall gilt: Wenn die Eigenschaft entityType den Wert "restaurant" oder "grocery_store" hat, wird eine rote Farbe zurückgegeben.

let layer = BubbleLayer(
    source: source,
    options: [
        .bubbleColor(
            from: NSExpression(
                // Get the input value to match.
                forAZMMatchingKey: NSExpression(forKeyPath: "entityType"),
                // List the keys to match and the value to return for each match.
                in: [
                    // If value is "restaurant" or "grocery_store" return red color.
                    NSExpression(forConstantValue: ["restaurant", "grocery_store"]): NSExpression(forConstantValue: UIColor.red),
                    // If value is "park" return green color.
                    NSExpression(forConstantValue: "park"): NSExpression(forConstantValue: UIColor.green)
                ],
                // Specify a default value to return if no match is found.
                default: NSExpression(forConstantValue: UIColor.black)
            )
        )
    ]
)

COALESCE-Ausdruck

Bei einem Coalesce-Ausdruck wird eine Reihe von Ausdrücken durchlaufen, bis der erste Wert erkannt wird, der nicht NULL ist. Dieser Wert wird dann zurückgegeben.

Beispiel für einen Coalesce-Ausdruck

Im folgenden Beispiel wird ein Coalesce-Ausdruck verwendet, um die Option textField einer Symbolebene festzulegen. Wenn die Eigenschaft title im Feature fehlt oder auf nil festgelegt ist, sucht der Ausdruck nach der Eigenschaft subTitle. Falls diese fehlt oder auf nil festgelegt ist, wird eine leere Zeichenfolge zurückgegeben.

let layer = SymbolLayer(
    source: source,
    options: [
        .textField(
            from: NSExpression(forAZMFunctionCoalesce: [
                // Try getting the title property.
                NSExpression(forKeyPath: "title"),

                // If there is no title, try getting the subTitle.
                NSExpression(forKeyPath: "subTitle"),

                // Default to an empty string.
                NSExpression(forConstantValue: "")
            ])
        )
    ]
)

Joinausdruck

Verknüpft mehrere Zeichenfolgen miteinander. Jeder Wert muss eine Zeichenfolge oder eine Zahl sein.

Beispiel für einen Joinausdruck

Im folgenden Beispiel werden die Eigenschaft temperature des Punktfeatures und "°F" miteinander verknüpft:

let layer = SymbolLayer(
    source: source,
    options: [
        .textField(
            from: NSExpression(forAZMFunctionJoin: [
                NSExpression(forKeyPath: "temperature"),
                NSExpression(forConstantValue: "°F")
            ])
        ),

        // Some additional style options.
        .textOffset(CGVector(dx: 0, dy: -1.5)),
        .textSize(12),
        .textColor(.white)
    ]
)

Der obige Ausdruck rendert eine Stecknadel auf der Karte mit dem Text "64°F" darüber, wie in der folgenden Abbildung gezeigt.

Beispiel für einen Joinausdruck

Interpolations- und Step-Ausdrücke

Interpolations- und Step-Ausdrücke können verwendet werden, um Werte entlang einer interpolierten Kurve oder für eine Schrittfunktion zu berechnen. Von diesen Ausdrücken wird ein Ausdruck akzeptiert, der eine Zahl als Eingabe zurückgibt (beispielsweise NSExpression(forKeyPath: "temperature")). Der Eingabewert wird anhand von Paaren mit Ein- und Ausgabewerten ausgewertet, um den Wert zu ermitteln, der am besten zur interpolierten Kurve oder Schrittfunktion passt. Die Ausgabewerte werden als „Stopps“ bezeichnet. Bei den Eingabewerten für jeden „Stopp“ muss es sich um Zahlen in aufsteigender Reihenfolge handeln. Die Ausgabewerte müssen eine Zahl, ein Array mit Farben oder eine Farbe sein.

Interpolationsausdruck

Ein Interpolationsausdruck kann verwendet werden, um eine fortlaufende, nahtlose Gruppe mit Werten zu berechnen, indem zwischen Stoppwerten interpoliert wird.

Es gibt drei Arten von Interpolationsmethoden, die in einem Interpolationsausdruck verwendet werden können:

Name	BESCHREIBUNG	Parameter
`ExpressionInterpolationMode.linear`	Lineare Interpolation zwischen dem „Stopp“-Paar.	`nil`
`ExpressionInterpolationMode.exponential`	Exponentielle Interpolation zwischen den „Stopps“. Eine Basis wird angegeben und steuert die Rate, mit der sich die Ausgabe erhöht. Bei höheren Werten nimmt die Ausgabe zum oberen Bereich hin stärker zu. Ein Basiswert nahe 1 führt zu einer Ausgabe mit einer eher linearen Zunahme.	Ein Ausdruck, der eine Zahl ergibt und die Basis der exponentiellen Interpolation angibt.
`ExpressionInterpolationMode.cubicBezier`	Interpolation per kubischer Bézierkurve, die über die angegebenen Steuerungspunkte definiert wird.	Ein Array- oder Aggregatausdruck mit vier Ausdrücken, die jeweils eine Zahl ergeben. Die vier Zahlen sind Kontrollpunkte für die kubische Bézier-Kurve.

Hier ein Beispiel dafür, wie diese verschiedenen Interpolationen aussehen.

Linear	Exponentiell	Kubische Bézierkurve

Beispiel eines Interpolationsausdrucks

Im folgenden Beispiel wird ein linearer Interpolationsausdruck verwendet, um die Eigenschaft bubbleColor einer Blasenebene basierend auf der Eigenschaft temperature des Punktfeatures festzulegen. Wenn der Wert temperature kleiner als 60 ist, wird Blau zurückgegeben. Liegt der Wert zwischen 60 und 69, wird Gelb zurückgegeben. Liegt der Wert zwischen 70 und 79, wird Orange zurückgegeben. Liegt er bei 80 oder darüber, wird Rot zurückgegeben.

let layer = BubbleLayer(
    source: source,
    options: [
        .bubbleColor(
            from: NSExpression(
                forAZMInterpolating: NSExpression(forKeyPath: "temperature"),
                curveType: .linear,
                parameters: nil,
                stops: NSExpression(forConstantValue: [
                    50: UIColor.blue,
                    60: UIColor.yellow,
                    70: UIColor.orange,
                    80: UIColor.red
                ])
            )
        )
    ]
)

In der folgenden Abbildung wird veranschaulicht, wie die Farben für den obigen Ausdruck ausgewählt werden.

Beispiel für Interpolate-Ausdruck

Step-Ausdruck

Ein Step-Ausdruck kann verwendet werden, um diskrete Schrittergebniswerte zu berechnen, indem eine über Stopps definierte Treppenfunktion (Piecewise-Constant Function) genutzt wird.

Bei Step-Ausdrücken wird der Ausgabewert des Stopps direkt vor dem Eingabewert zurückgegeben (oder der Ausgangswert, wenn die Eingabe kleiner als der erste Stoppwert ist).

Beispiel für einen Step-Ausdruck

Im folgenden Beispiel wird ein Step-Ausdruck verwendet, um die Eigenschaft bubbleColor einer Blasenebene basierend auf der Eigenschaft temperature des Punktfeatures festzulegen. Wenn der Wert temperature kleiner als 60 ist, wird Blau zurückgegeben. Liegt der Wert zwischen 60 und 69, wird Gelb zurückgegeben. Liegt der Wert zwischen 70 und 79, wird Orange zurückgegeben. Liegt er bei 80 oder darüber, wird Rot zurückgegeben.

let layer = BubbleLayer(
    source: source,
    options: [
        .bubbleColor(
            from: NSExpression(
                forAZMStepping: NSExpression(forKeyPath: "temperature"),
                from: NSExpression(forConstantValue: UIColor.blue),
                stops: NSExpression(forConstantValue: [
                    50: UIColor.blue,
                    60: UIColor.yellow,
                    70: UIColor.orange,
                    80: UIColor.red
                ])
            )
        )
    ]
)

In der folgenden Abbildung wird veranschaulicht, wie die Farben für den obigen Ausdruck ausgewählt werden.

Beispiel für einen Step-Ausdruck

Weitere Informationen

Weitere Informationen zu den Ebenen, die Ausdrücke unterstützen:

Freigeben über

Datengesteuerte Formatvorlagenausdrücke im iOS SDK (Vorschau)

Verwenden von Prädikaten zum Filtern von Vektordaten

Operatoren

Operanden

Beispiele für Operanden

Verwenden von Ausdrücken zum Konfigurieren von Ebenenoptionen

JSON-basiert

Konstante Werte

Beispiel für konstante Werte

Schlüsselpfade

Functions

Bedingungen

Beispiel für Bedingungen

Aggregate

Variablen

Featurebezeichner

Funktionseigenschaften

Akkumuliertes Feature

Geometrietyp

Variablenbeispiel

Zoom

Zoombeispiel

Wärmebilddichte

Beispiel für Wärmebilddichte

Linienfortschritt

Beispiel für Linienfortschritt

Azure Maps-spezifische Methoden

Match-Ausdruck

Beispiele für Match-Ausdrücke

COALESCE-Ausdruck

Beispiel für einen Coalesce-Ausdruck

Joinausdruck

Beispiel für einen Joinausdruck

Interpolations- und Step-Ausdrücke

Interpolationsausdruck

Beispiel eines Interpolationsausdrucks

Step-Ausdruck

Beispiel für einen Step-Ausdruck

Weitere Informationen

Feedback

Zusätzliche Ressourcen