Espressioni di stile basate sui dati in iOS SDK (anteprima)

I livelli usano predicati ed espressioni per determinare cosa visualizzare e come formattarlo. I predicati sono rappresentati dalla stessa NSPredicate classe che filtra i risultati da Core Data o elementi in objective-C NSArray . I predicati sono basati su espressioni, rappresentate dalla NSExpression classe .

Questo documento illustra il subset specifico del predicato e della sintassi dell'espressione supportati da questo SDK. Per un'introduzione più generale ai predicati e alle espressioni, vedere la Guida alla programmazione predicato nella documentazione per sviluppatori Apple.

Uso dei predicati per filtrare i dati vettoriali

La maggior parte delle classi di livello visualizza Feature gli oggetti che è possibile visualizzare o nascondere in base alle proprietà della funzionalità. Usare l'opzione filter per includere solo le funzionalità nel livello di origine che soddisfano una condizione definita dall'utente.

Operatori

Sono supportati gli operatori di confronto seguenti:

NSPredicateOperatorType	Sintassi della stringa di formato
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 }

Per verificare se una funzionalità ha o manca una proprietà specifica, confrontare l'attributo con NULL o NIL. Sono supportati anche i predicati creati usando l'inizializzatore NSPredicate(value:) . Gli operatori stringa e gli operatori personalizzati non sono supportati.

Sono supportati gli operatori composti seguenti:

NSCompoundPredicateType	Sintassi della stringa di formato
NSAndPredicateType	predicate1 AND predicate2 predicate1 && predicate2
NSOrPredicateType	predicate1 OR predicate2 predicate1 \|\| predicate2
NSNotPredicateType	NOT predicate !predicate

Sono supportati gli operatori di aggregazione seguenti:

NSPredicateOperatorType	Sintassi della stringa di formato
NSInPredicateOperatorType	key IN { 'iOS', 'macOS', 'tvOS', 'watchOS' }
NSContainsPredicateOperatorType	{ 'iOS', 'macOS', 'tvOS', 'watchOS' } CONTAINS key

È possibile usare gli IN operatori e CONTAINS per verificare se un valore viene visualizzato in una raccolta, se una stringa è una sottostringa di una stringa più grande o se la funzionalità valutata (SELF) si trova all'interno di un determinato Featureoggetto .

Sono supportate le combinazioni seguenti di operatori di confronto e modificatori:

NSComparisonPredicateModifier	NSPredicateOperatorType	Sintassi della stringa di formato
NSAllPredicateModifier	NSNotEqualToPredicateOperatorType	ALL haystack != needle
NSAnyPredicateModifier	NSEqualToPredicateOperatorType	ANY haystack = needle SOME haystack = needle

Le opzioni del predicato di confronto seguenti sono supportate per gli operatori di confronto e aggregazione usati nel predicato:

NSComparisonPredicateOptions	Sintassi della stringa di formato
NSCaseInsensitivePredicateOption	'QUEBEC' =[c] 'Quebec'
NSDiacriticInsensitivePredicateOption	'Québec' =[d] 'Quebec'

Altre opzioni del predicato di confronto non sono supportate, ovvero l (per la riservatezza delle impostazioni locali) e n (per la normalizzazione). Un confronto è sensibile alle impostazioni locali purché non si tratti di maiuscole e minuscole o senza diacritici. Le opzioni del predicato di confronto non sono supportate con modificatori di confronto come ALL e ANY.

Operandi

Gli operandi nei predicati possono essere variabili, percorsi chiave o quasi qualsiasi altro elemento che può essere visualizzato all'interno di un'espressione.

Il cast automatico dei tipi non viene eseguito. Pertanto, una funzionalità corrisponde a un predicato solo se il relativo valore per la proprietà in questione è dello stesso tipo del valore specificato nel predicato. Usare l'operatore CAST() per convertire un percorso chiave o una variabile in un tipo corrispondente:

• Per eseguire il cast di un valore a un numero, usare CAST(key, 'NSNumber').
• Per eseguire il cast di un valore in una stringa, usare CAST(key, 'NSString').
• Per eseguire il cast di un valore a un colore, usare CAST(key, 'UIColor').
• Per eseguire il cast di un UIColor oggetto in una matrice, usare CAST(noindex(color), 'NSArray').

Per altre informazioni sulla sintassi della stringa di formato predicato, vedere il capitolo "Predicate Format String Syntax" (Sintassi della stringa di formato predicato) della Guida alla programmazione predicato nella documentazione per sviluppatori Apple.

Esempi di operandi

Per impostazione predefinita, i livelli bolle e simboli eseguono il rendering delle coordinate di tutte le geometrie in un'origine dati. Questo comportamento può evidenziare i vertici di un poligono o di una linea. L'opzione filter del livello può essere usata per limitare il tipo di geometria delle funzionalità di cui esegue il rendering, usando NSExpression.geometryTypeAZMVariable all'interno di un predicato. Nell'esempio seguente viene limitato un livello a bolle in modo che venga eseguito il rendering solo Point delle funzionalità.

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

L'esempio seguente consente il rendering di entrambe Point le funzionalità e Polygon .

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

Uso delle espressioni per configurare le opzioni del livello

Un'espressione può contenere sottoespressioni di vari tipi. Ognuno dei tipi supportati di espressioni è illustrato di seguito.

Alcuni esempi in questa sezione del documento usano la funzionalità seguente per illustrare i diversi modi in cui è possibile usare queste espressioni.

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

Il codice seguente illustra come creare manualmente questa funzionalità GeoJSON in un'app.

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

Il codice seguente illustra come deserializzare la versione stringata dell'oggetto JSON in una funzionalità GeoJSON in un'app.

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)

Basato su JSON

L'SDK Web di Mappe di Azure supporta anche espressioni di stile basate sui dati rappresentate usando una matrice JSON. Queste stesse espressioni possono essere ricreate usando la classe nativa NSExpression in iOS SDK. In alternativa, queste espressioni basate su JSON possono essere condivise con l'app ios (collegata alla risposta, ad esempio) e passate al NSExpression(azmJSONObject:) metodo . Ad esempio, accettare l'espressione JSON seguente.

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

La versione rapida dell'espressione precedente sarà ["get", "title"] e può essere letta in iOS SDK come indicato di seguito.

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

L'uso di questo approccio consente di riutilizzare facilmente espressioni di stile tra app per dispositivi mobili e Web che usano Mappe di Azure.

Questo video offre una panoramica dello stile basato sui dati in Mappe di Azure.

Internet of Things Show - Applicazione di stili basati sui dati con Mappe di Azure

Valori costanti

Un valore costante può essere di uno dei tipi seguenti:

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

Esempio di valori costanti

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

Percorsi chiave

Un'espressione di percorso chiave fa riferimento a una proprietà dell'oggetto valutato per la Feature visualizzazione. Ad esempio, se il dizionario di Feature.properties un poligono contiene la floorCount chiave, il percorso floorCount della chiave fa riferimento al valore della proprietà durante la floorCount valutazione di tale poligono specifico.

Alcuni caratteri potrebbero non essere usati direttamente come parte di un percorso di chiave in una stringa di formato. Ad esempio, se la proprietà di una funzionalità è denominata ISO 3166-1:2006, una stringa di formato di espressione di o una stringa di lowercase(ISO 3166-1:2006) formato predicato di ISO 3166-1:2006 == 'US-OH' genererà un'eccezione. Usare invece un %K segnaposto o l'inizializzatore NSExpression(forKeyPath:) :

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

Funzioni

Delle funzioni predefinite dal NSExpression(forFunction:arguments:) metodo, il sottoinsieme seguente è supportato nelle opzioni di livello:

Parametro dell'inizializzatore	Sintassi della stringa di formato
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')

Le funzioni predefinite seguenti non sono supportate:

Parametro dell'inizializzatore	Sintassi della stringa di formato
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)

Condizionali

Le istruzioni condizionali sono supportate tramite il metodo e TERNARY() l'operatore predefinitiNSExpression(forAZMConditional:trueExpression:falseExpression:). Se è necessario esprimere più casi ("else-if"), è possibile annidare un'istruzione condizionale all'interno di un'espressione condizionale o usare l'espressione di corrispondenza.

Esempio di condizionale

Nell'esempio seguente viene eseguito un passaggio attraverso predicati diversi fino a quando non ne trova uno che restituisce truee quindi restituisce l'espressione true. Se nessun predicato restituisce true, viene restituita l'ultima espressione false.

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

Aggregazioni

Le espressioni di aggregazione possono contenere matrici di espressioni. In alcuni casi, è possibile usare la matrice stessa anziché eseguire il wrapping della matrice in un'espressione di aggregazione.

Variabili

Th iOS SDK definisce le variabili seguenti da usare con le opzioni di livello.

Identificatore di funzionalità

ID di una funzionalità. Questa variabile corrisponde alla NSExpression.featureIdentifierAZMVariable proprietà .

Sintassi della stringa di formato: $featureIdentifier

Proprietà delle funzionalità

Oggetto proprietà di una funzionalità. Questa variabile corrisponde alla NSExpression.featurePropertiesAZMVariable proprietà .

Sintassi della stringa di formato: $featureAttributes

Funzionalità accumulata

Valore di una proprietà del cluster accumulata finora. Questa opzione può essere usata solo nell'opzione di un'origine clusterProperties cluster DataSource . Questa variabile corrisponde alla NSExpression.featureAccumulatedAZMVariable proprietà .

Sintassi della stringa di formato: $featureAccumulated

Tipo geometry

Tipo di geometria rappresentato dalla funzionalità. Il tipo di una funzionalità è una delle stringhe seguenti:

• Point per le caratteristiche del punto, corrispondenti alla Point classe .
• MultiPoint per le caratteristiche della raccolta di punti, corrispondente alla PointCollection classe .
• LineString per le caratteristiche polilinee, corrispondenti alla Polyline classe .
• MultiLineString per più caratteristiche polilinee, corrispondenti alla MultiPolyline classe .
• Polygon per le caratteristiche poligono, corrispondenti alla Polygon classe .
• MultiPolygon per più caratteristiche poligoni, corrispondenti alla MultiPolygon classe .
• GeometryCollection per le caratteristiche della raccolta geometry, corrispondenti alla GeometryCollection classe .

Questa variabile corrisponde alla NSExpression.geometryTypeAZMVariable proprietà .

Sintassi della stringa di formato: $geometryType

Esempio di variabili

Vedere Esempi di operandi.

Zoom

Livello di zoom corrente. Nelle opzioni di stile del livello, questa variabile può essere visualizzata solo come destinazione di un'espressione di interpolazione o passaggio di primo livello. Questa variabile corrisponde alla NSExpression.zoomLevelAZMVariable proprietà .

Sintassi della stringa di formato: $zoomLevel

Esempio di zoom

Per impostazione predefinita, i raggi dei punti dati di cui viene eseguito il rendering nel livello mappa termica hanno un raggio a virgola fissa per tutti i livelli di zoom. Con lo zoom della mappa, i dati vengono aggregati insieme e il livello mappa termica ha un aspetto diverso. Un'espressione zoom può essere usata per ridimensionare il raggio per ogni livello di zoom in modo che ogni punto dati copre la stessa area fisica della mappa. Rende il livello mappa termica più statico e coerente. Ogni livello di zoom della mappa ha il doppio di punti verticalmente e orizzontalmente del livello di zoom precedente. Il ridimensionamento del raggio, in modo che raddoppii con ogni livello di zoom, crei una mappa termica che abbia un aspetto coerente su tutti i livelli di zoom. Può essere eseguita usando l'espressione con un'espressione zoom base 2 exponential interpolation , con il raggio del punto impostato per il livello di zoom minimo e un raggio scalato per il livello di zoom massimo calcolato come pow(2, maxZoom - minZoom) * radius illustrato di seguito.

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

Densità di HeatMap

Stima della densità del kernel di un punto dello schermo in un livello mappa termica; in altre parole, una misura relativa del numero di punti dati affollati intorno a un particolare pixel. Questa variabile restituisce un numero compreso tra 0 e 1. Viene usato in combinazione con un'espressione interpolation o step per definire la sfumatura di colore usata per colorare la mappa termica. Può essere usato solo nell'opzione heatmapColor del livello mappa termica. Questa variabile corrisponde alla NSExpression.heatmapDensityAZMVariable proprietà .

Sintassi della stringa di formato: $heatmapDensity

Esempio di densità di HeatMap

In questo esempio viene utilizzata un'espressione di interpolazione liner per creare una sfumatura di colore uniforme per il rendering della mappa termica.

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

Oltre a usare una sfumatura liscia per colorare una mappa termica, i colori possono essere specificati all'interno di un set di intervalli usando un'espressione di passaggio. L'uso di un'espressione di passaggio per colorare visivamente la mappa termica suddivide visivamente la densità in intervalli simili a una mappa dello stile di contorno o radar.

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

Per altre informazioni, vedere l'articolo Aggiungere un livello mappa termica.

Avanzamento riga

Numero che indica la distanza relativa lungo una linea in un determinato punto lungo la linea. Questa variabile restituisce 0 all'inizio della riga e 1 alla fine della riga. Può essere usato solo con l'opzione LineLayerOption.strokeGradient del livello linea. Corrisponde alla NSExpression.lineProgressAZMVariable proprietà .

Sintassi della stringa di formato: $lineProgress

Esempio di avanzamento riga

In questo esempio viene utilizzata l'espressione NSExpression.lineProgressAZMVariable per applicare una sfumatura di colore al tratto di una linea.

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

Vedere l'esempio live

Metodi specifici di Azure Mappe

La sezione seguente illustra i metodi specifici di Azure Mappe che estendono la NSExpression classe

Espressione di corrispondenza

Un'espressione di corrispondenza è un tipo di espressione condizionale che fornisce un'istruzione switch come la logica. L'input può essere qualsiasi espressione, NSExpression(forKeyPath: "entityType") ad esempio che restituisce una stringa o un numero. L'espressione corrispondente è un dizionario, che deve avere chiavi come espressioni che restituiscono una singola stringa o un numero o una matrice di tutte le stringhe o di tutti i numeri e valori come qualsiasi espressione. Se il tipo di espressione di input non corrisponde al tipo di chiavi, il risultato è il valore di fallback predefinito.

Esempi di espressioni di corrispondenza

L'esempio seguente esamina la entityType proprietà di una Point funzionalità in un livello a bolle e cerca una corrispondenza. Se trova una corrispondenza, il valore specificato viene restituito o restituisce il valore di fallback.

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

Nell'esempio seguente viene utilizzata un'espressione che valuta la matrice di stringhe per specificare un set di etichette che deve restituire lo stesso valore. Questo approccio è molto più efficiente rispetto all'inserimento di ogni etichetta singolarmente. In questo caso, se la entityType proprietà è "restaurant" o "grocery_store", viene restituito il colore rosso.

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

Espressione Coalesce

Un'espressione coalesce passa attraverso un set di espressioni fino a quando non viene ottenuto il primo valore non Null e restituisce tale valore.

Esempio di espressione Coalesce

Nell'esempio seguente viene utilizzata un'espressione coalesce per impostare l'opzione textField di un livello simbolo. Se la title proprietà non è presente nella funzionalità o impostata su nil, l'espressione cerca la subTitle proprietà , se manca o nil, restituisce una stringa vuota.

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: "")
            ])
        )
    ]
)

Espressione join

Unisce più stringhe. Ogni valore deve essere una stringa o un numero.

Esempio di espressione join

Nell'esempio seguente viene aggiunta la temperature proprietà della funzionalità punto e "°F".

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

L'espressione precedente esegue il rendering di un segnaposto sulla mappa con il testo "64°F" sovrapposto sopra di esso, come illustrato nell'immagine seguente.

Interpolazione ed espressioni di passaggio

È possibile usare espressioni di interpolazione e passaggio per calcolare i valori lungo una curva interpolata o una funzione passo. Queste espressioni accettano un'espressione che restituisce un numero come input, ad esempio NSExpression(forKeyPath: "temperature"). Il valore di input viene valutato in base a coppie di valori di input e output, per determinare il valore più adatto alla curva interpolata o alla funzione di passaggio. I valori di output sono denominati "stop". I valori di input per ogni arresto devono essere un numero e essere in ordine crescente. I valori di output devono essere un numero, una matrice di numeri o un colore.

Espressione di interpolazione

Un'espressione di interpolazione può essere usata per calcolare un set continuo e uniforme di valori interpolando tra i valori di arresto.

Esistono tre tipi di metodi di interpolazione che possono essere usati in un'espressione di interpolazione:

Nome	Descrizione	Parametri
ExpressionInterpolationMode.linear	Esegue l'interpolazione lineare tra la coppia di arresti.	nil
ExpressionInterpolationMode.exponential	Esegue l'interpolazione esponenziale tra gli arresti. Viene specificata una base e controlla la frequenza con cui aumenta l'output. I valori più elevati rendono l'output più elevato verso l'estremità superiore dell'intervallo. Un valore di base vicino a 1 produce un output che aumenta in modo più lineare.	Espressione che restituisce un numero, specificando la base dell'interpolazione esponenziale.
ExpressionInterpolationMode.cubicBezier	Esegue l'interpolazione usando una curva di Bézier cubica definita dai punti di controllo specificati.	Matrice o espressione di aggregazione contenente quattro espressioni, ognuna valutata in un numero. I quattro numeri sono punti di controllo per la curva cubica di Bézier.

Ecco un esempio dell'aspetto di questi diversi tipi di interpolazioni.

Lineare	Esponenziale	Bézier cubico

Esempio di espressione di interpolazione

Nell'esempio seguente viene utilizzata un'espressione di interpolazione lineare per impostare la bubbleColor proprietà di un livello a bolle in base alla temperature proprietà della funzionalità punto. Se il temperature valore è minore di 60, viene restituito il colore blu. Se è compreso tra 60 e meno di 70, viene restituito il giallo. Se è compreso tra 70 e meno di 80, viene restituito l'arancione. Se è maggiore o uguale a 80, viene restituito il rosso.

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

L'immagine seguente illustra come vengono scelti i colori per l'espressione precedente.

Espressione del passaggio

Un'espressione di passaggio può essere usata per calcolare valori di risultato discreti e con rientri valutando una funzione costante a fasi definita da stop.

Le espressioni di passaggio restituiscono il valore di output dell'arresto subito prima del valore di input o il valore da se l'input è minore del primo arresto.

Esempio di espressione passo

Nell'esempio seguente viene utilizzata un'espressione di passaggio per impostare la bubbleColor proprietà di un livello a bolle in base alla temperature proprietà della funzionalità punto. Se il temperature valore è minore di 60, viene restituito il blu. Se è compreso tra 60 e meno di 70, viene restituito il giallo. Se è compreso tra 70 e meno di 80, viene restituito l'arancione. Se è maggiore o uguale a 80, viene restituito il rosso.

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

L'immagine seguente illustra come vengono scelti i colori per l'espressione precedente.

Informazioni aggiuntive

Altre informazioni sui livelli che supportano le espressioni:

• Aggiungere un livello per i simboli
• Aggiungere un livello per le bolle
• Aggiungere un livello per le linee
• Aggiungere un livello per i poligoni