Expressões de estilo controladas por dados no SDK do iOS (versão prévia)

Artigo
03/27/2023

Observação

Desativação do SDK do iOS no Azure Mapas

O SDK Nativo do Azure Mapas para iOS já foi preterido e será desativado em 31/03/25. Para evitar interrupções de serviço, migre para o SDK da Web do Azure Mapas até 31/03/25. Para obter mais informações, confira O guia de migração do SDK do iOS no Azure Mapas.

As camadas usam predicados e expressões para determinar o que exibir e como formatá-las. Os predicados são representados pela mesma classe NSPredicate que filtra os resultados de Dados Principais ou itens em um Objective-C NSArray. Os predicados são baseados em expressões, representados pela classe NSExpression.

Este documento discute o subconjunto específico do predicado e a sintaxe de expressão com suporte neste SDK. Para obter uma introdução mais geral aos predicados e expressões, consulte o Guia de programação de predicado na documentação do desenvolvedor da Apple.

Usar predicados para filtrar dados de vetor

A maioria das classes de camada exibe objetos Feature que você pode mostrar ou ocultar com base nas propriedades do recurso. Use a opção filter para incluir apenas os recursos na camada de origem que atendem a uma condição que você definir.

Operadores

Os operadores de comparação a seguir são compatíveis:

`NSPredicateOperatorType`	Sintaxe da cadeia de caracteres de 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 }`

Para testar se um recurso tem ou não uma propriedade específica, compare o atributo como NULL ou NIL. Também há suporte para predicados criados usando o inicializador NSPredicate(value:). Não há suporte para os operadores de cadeia de caracteres e os operadores personalizados.

Os operadores de composto a seguir são compatíveis:

`NSCompoundPredicateType`	Sintaxe da cadeia de caracteres de formato
`NSAndPredicateType`	`predicate1 AND predicate2` `predicate1 && predicate2`
`NSOrPredicateType`	`predicate1 OR predicate2` `predicate1 \\|\\| predicate2`
`NSNotPredicateType`	`NOT predicate` `!predicate`

Há suporte para os seguintes operadores agregados:

`NSPredicateOperatorType`	Sintaxe da cadeia de caracteres de formato
`NSInPredicateOperatorType`	`key IN { 'iOS', 'macOS', 'tvOS', 'watchOS' }`
`NSContainsPredicateOperatorType`	`{ 'iOS', 'macOS', 'tvOS', 'watchOS' } CONTAINS key`

Você pode usar os operadores IN e CONTAINS para testar se um valor aparece em uma coleção, se uma cadeia de caracteres é uma subsequência de uma cadeia de caracteres maior ou se o recurso avaliado (SELF) está dentro de um determinado Feature.

Há suporte para as seguintes combinações de operadores de comparação e modificadores:

`NSComparisonPredicateModifier`	`NSPredicateOperatorType`	Sintaxe da cadeia de caracteres de formato
`NSAllPredicateModifier`	`NSNotEqualToPredicateOperatorType`	`ALL haystack != needle`
`NSAnyPredicateModifier`	`NSEqualToPredicateOperatorType`	`ANY haystack = needle` `SOME haystack = needle`

Há suporte para as seguintes opções de predicado de comparação para operadores de comparação e de agregação que são usados no predicado:

`NSComparisonPredicateOptions`	Sintaxe da cadeia de caracteres de formato
`NSCaseInsensitivePredicateOption`	`'QUEBEC' =[c] 'Quebec'`
`NSDiacriticInsensitivePredicateOption`	`'Québec' =[d] 'Quebec'`

Não há suporta para outras opções de predicado de comparação, l a saber (para sensibilidade de localidade) e n (para normalização). Uma comparação é sensível à localidade desde que seja insensível a maiúsculas e minúsculas ou marcas diacríticas. As opções de predicado de comparação não têm suporte a modificadores de comparação como ALL e ANY.

Operandos

Os operandos em predicados podem ser variáveis, caminhos de chave ou qualquer outra coisa que possa aparecer dentro de uma expressão.

A conversão automática de tipo não é realizada. Portanto, um recurso corresponde somente a um predicado se seu valor para a propriedade em questão for do mesmo tipo que o valor especificado no predicado. Use o operador CAST() para converter um caminho de chave ou variável em um tipo correspondente:

Para converter um valor em um número, use CAST(key, 'NSNumber').
Para converter um valor em uma cadeia de caracteres, use CAST(key, 'NSString').
Para converter um valor em uma cor, use CAST(key, 'UIColor').
Para converter um objeto UIColor em uma matriz, use CAST(noindex(color), 'NSArray').

Para mais informações sobre a sintaxe de cadeia de caracteres de formato de predicado, confira o capítulo "Sintaxe de cadeia de caracteres de formato de predicado" do Guia de programação de predicado na documentação de desenvolvedor da Apple.

Exemplos de operandos

Por padrão, as camadas de bolhas e símbolo renderizam as coordenadas de todas as geometrias em uma fonte de dados. Esse comportamento pode realçar os vértices de um polígono ou de uma linha. A opção filter da camada pode ser usada para limitar o tipo de geometria dos recursos que ele renderiza, usando NSExpression.geometryTypeAZMVariable dentro de um predicado. O exemplo a seguir limita uma camada de bolhas para que apenas os recursos Point sejam renderizados.

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

O exemplo a seguir permite que os recursos Point e Polygon sejam renderizados.

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

Usar expressões para configurar opções de camada

Uma expressão pode conter subexpressões de vários tipos. Cada um dos tipos de expressões com suporte é discutido abaixo.

Alguns exemplos desta seção do documento usam o recurso a seguir para demonstrar diferentes maneiras em que essas expressões podem ser usadas.

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

O código a seguir mostra como criar manualmente esse recurso GeoJSON em um aplicativo.

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

O código a seguir mostra como desserializar a versão em cadeia de caracteres do objeto JSON em um recurso GeoJSON em um aplicativo.

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)

Baseado em JSON

O SDK da Web para Azure Mapas também dá suporte a expressões de estilo controladas por dados que são representadas usando uma matriz JSON. Essas mesmas expressões podem ser recriadas usando a classe NSExpression nativa do SDK do iOS. Como alternativa, essas expressões baseadas em JSON podem ser compartilhadas para o aplicativo IOS (anexada à resposta, por exemplo) e transmitidas para o método NSExpression(azmJSONObject:). Por exemplo, considere a expressão JSON a seguir.

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

A versão swift da expressão acima é ["get", "title"] e pode ser lida no SDK do iOS, conforme mostrado a seguir.

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

O uso dessa abordagem pode facilitar a reutilização de expressões de estilo entre aplicativos móveis e Web que usam os Azure Mapas.

Este vídeo fornece uma visão geral da definição de estilo controlado por dados nos Azure Mapas.

Exibição da Internet das Coisas - estilo controlado por dados com o Azure Mapas

Valores de constante

Um valor constante pode ser de qualquer um dos tipos a seguir:

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

Exemplo de valores constantes

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

Caminhos de chave

Uma expressão de caminho de chave refere-se a uma propriedade do objeto Feature que está sendo avaliado para exibição. Por exemplo, se um dicionário Feature.properties de polígono contém a chave floorCount, o caminho de chave floorCount refere-se ao valor da propriedade floorCount ao avaliar aquele polígono em particular.

Alguns caracteres não podem ser usados diretamente como parte de um caminho de chave em uma cadeia de caracteres de formato. Por exemplo, se uma propriedade de recurso é nomeada ISO 3166-1:2006, uma cadeia de caracteres de formato de expressão de lowercase(ISO 3166-1:2006) ou uma cadeia de caracteres de formato de predicado de ISO 3166-1:2006 == 'US-OH' geraria uma exceção. Em vez disso, use um espaço reservado %K ou o inicializador NSExpression(forKeyPath:):

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

Funções

Das funções predefinidas pelo NSExpression(forFunction:arguments:) método, há suporte para o subconjunto a seguir nas opções de camada:

Parâmetro de inicializador	Sintaxe da cadeia de caracteres de 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')`

Não há suporte para as funções predefinidas a seguir:

Parâmetro de inicializador	Sintaxe da cadeia de caracteres de 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)`

Condicionais

Há suporte para condicionais por meio do método NSExpression(forAZMConditional:trueExpression:falseExpression:) e operador TERNARY() internos. Se você precisar expressar vários casos ("else-if"), poderá aninhar uma condicional em uma condicional ou usar a expressão de correspondência.

Exemplo de condicionais

O exemplo a seguir percorre diferentes predicados até encontrar um que seja avaliado como true e retorna sua expressão true. Se nenhum predicado for avaliado para true, a última falsa expressão é retornada.

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

Agregações

As expressões de agregação podem conter matrizes de expressões. Em alguns casos, é possível usar a matriz em si ao invés de encapsular a matriz em uma expressão agressão.

Variáveis

O SDK do iOS define as seguintes variáveis para uso com opções de camadas.

Identificador de recurso

A ID de um recurso. Essa variável corresponde à propriedade NSExpression.featureIdentifierAZMVariable.

Sintaxe da cadeia de caracteres de formato: $featureIdentifier

Propriedades de recursos

O objeto das propriedades de recurso. Essa variável corresponde à propriedade NSExpression.featurePropertiesAZMVariable.

Sintaxe da cadeia de caracteres de formato: $featureAttributes

Recurso acumulado

O valor de uma propriedade de cluster acumulada até o momento. Isso só pode ser usado na opção clusterProperties de uma fonte DataSource clusterizada. Essa variável corresponde à propriedade NSExpression.featureAccumulatedAZMVariable.

Sintaxe da cadeia de caracteres de formato: $featureAccumulated

Tipo de geometria

O tipo de geometria representado pelo recurso. O tipo de recurso é uma das seguintes cadeias de caracteres:

Point para recursos de ponto, correspondendo à classe Point.
MultiPoint para recursos de coleção de ponto, correspondendo à classe PointCollection.
LineString para recursos de linha poligonal, correspondendo à classe Polyline.
MultiLineString para recursos de vários linhas poligonais, correspondendo à classe MultiPolyline.
Polygon para recursos de polígono, correspondendo à classe Polygon.
MultiPolygon para recursos de vários polígonos, correspondendo à classe MultiPolygon.
GeometryCollection para recursos de coleção de geometria, correspondendo à classe GeometryCollection.

Essa variável corresponde à propriedade NSExpression.geometryTypeAZMVariable.

Sintaxe da cadeia de caracteres de formato: $geometryType

Exemplo de variáveis

Consulte Exemplos de operandos.

Zoom

O nível de zoom atual. Nas opções de estilo da camada, essa variável pode aparecer somente como o destino de uma interpolação de nível superior ou expressão de etapa. Essa variável corresponde à propriedade NSExpression.zoomLevelAZMVariable.

Sintaxe da cadeia de caracteres de formato: $zoomLevel

Exemplo de zoom

Por padrão, o raios de pontos de dados renderizados na camada do mapa de calor têm um raio de ponto fixo para todos os níveis de zoom. À medida que o mapa é ampliado, os dados são agregados e a camada do mapa de calor fica diferente. Uma expressão zoom pode ser usada para dimensionar o raio para cada nível de zoom, de modo que cada ponto de dados cubra a mesma área física do mapa. Faz com que a camada do mapa de calor pareça mais estática e consistente. Cada nível de zoom do mapa tem duas vezes mais pontos vertical e horizontalmente do que o nível de zoom anterior. A colocação em escala do raio, de modo que ele duplique a cada nível de zoom, cria um mapa de calor que parece consistente em todos os níveis de zoom. Para isso, use a expressão zoom com uma expressão base 2 exponential interpolation, com o conjunto de raio de ponto definido para o nível de zoom mínimo e um raio dimensionado para o nível máximo de zoom calculado como pow(2, maxZoom - minZoom) * radius, conforme mostrado abaixo.

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

Densidade do Mapa de calor

A estimativa de densidade do kernel de um ponto de tela em uma camada calor; em outras palavras, uma medida relativa de quantos pontos de dados estão reunidos em um pixel específico. Essa variável avalia como um número entre 0 e 1. Ele é usado em combinação com uma expressão interpolation ou step para definir o gradiente de cor usado para colorir o mapa de calor. Ela só pode ser usada na opção heatmapColor da camada do mapa de calor. Essa variável corresponde à propriedade NSExpression.heatmapDensityAZMVariable.

Sintaxe da cadeia de caracteres de formato: $heatmapDensity

Dica

A cor no índice 0, em uma expressão de interpolação ou a cor padrão de uma cor de etapa, define a cor da área em que não há nenhum dado. A cor no índice 0 pode ser usada para definir uma cor da tela de fundo. Muitos preferem definir esse valor como transparente ou semitransparente preto.

Exemplo de densidade do mapa de calor

Este exemplo usa uma expressão de interpolação de linha a fim de criar um gradiente de cor suave para renderizar o mapa de calor.

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

Além de usar um gradiente suave para colorir um mapa de calor, as cores podem ser especificadas dentro de um conjunto de intervalos usando uma expressão de etapa. Você também pode usar uma expressão de etapa para colorir o mapa de calor, dividindo a densidade visualmente em intervalos que se assemelham a um contorno ou a um mapa em estilo de 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
            ])
         )
      )
   ]
)

Para obter mais informações, confira o artigo Adicionar uma camada do mapa de calor.

Progresso da linha

Um número que indica a distância relativa ao longo de uma linha em um determinado ponto ao longo da linha. Essa variável é avaliada como 0 no início da linha e 1 no final da linha. Ela pode ser usada somente com a opção LineLayerOption.strokeGradient da camada de linhas. Isso corresponde à propriedade de NSExpression.lineProgressAZMVariable.

Sintaxe da cadeia de caracteres de formato: $lineProgress

Observação

A opção strokeGradient da camada de linhas requer a opção lineMetrics da fonte de dados a ser definida como true.

Exemplo de progresso de linhas

Este exemplo usa a expressão NSExpression.lineProgressAZMVariable para aplicar um gradiente de cor ao traço de uma linha.

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

Veja o exemplo ao vivo

Métodos específicos para AzureMaps

A seção a seguir mostra os métodos específicos para AzureMaps que se estendem para a classe NSExpression

Expressão de correspondência

Uma expressão de correspondência é um tipo de expressão condicional que fornece a instrução switch como lógica. A entrada pode ser qualquer expressão, como NSExpression(forKeyPath: "entityType"), que retorna uma cadeia de caracteres ou um número. As expressão correspondente são é um dicionário, que deve ter chaves como expressões que avaliam tanto para uma única cadeia de caracteres ou número ou para uma matriz de todas as cadeias de caracteres ou todos os números e valores como qualquer expressão. Se o tipo de expressão de entrada não corresponder ao tipo das chaves, o resultado é o valor de fallback padrão.

Exemplos de expressões de correspondência

O exemplo a seguir revisa a propriedade entityType de um recurso Point em uma camada de bolhas e procura uma correspondência. Se encontrar uma correspondência, esse valor especificado será retornado ou retornará o valor de 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)
            )
        )
    ]
)

O exemplo a seguir usa uma expressão que avalia para a matriz da cadeia de caracteres para especificar um conjunto de rótulos que devem retornar o mesmo valor. Essa abordagem é muito mais eficiente do que listar cada rótulo individualmente. Neste caso, se a propriedade entityType é "restaurant" ou "grocery_store", é retornada a cor vermelha.

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

Expressão de união

Uma expressão de união percorre um conjunto de expressões até que o primeiro valor não nulo seja obtido e retorne esse valor.

Exemplo de expressão de união

O exemplo a seguir usa uma expressão de união para definir a opção textField de uma camada de símbolo. Se a propriedade title estiver ausente do recurso ou definida como nil, a expressão procurar pela propriedade subTitle, se estiver ausente ou nil ela então retorna a uma cadeia de caracteres vazia.

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

Expressão de junção

Junção de várias cadeias de caracteres. Cada valor deve ser uma cadeia de caracteres ou um número.

Exemplo de expressão de junção

O exemplo a seguir une a propriedade temperature do recurso de ponto 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)
    ]
)

A expressão acima renderiza um marcador no mapa com o texto "64°F" sobreposto em cima dele, como mostra a imagem a seguir.

Exemplo de expressão de junção

Expressões de interpolação e etapas

As expressões de interpolação e etapas podem ser usadas para calcular valores ao longo de uma curva interpolada ou função de etapas. Essas expressões assumem uma expressão que retorna um numero como entrada, por exemplo NSExpression(forKeyPath: "temperature"). O valor de entrada é avaliado em relação aos pares de valores de entrada e saída, para determinar o valor que melhor se adapta à função de curva ou etapa interpolada. Os valores de saída são chamados de "paradas". Os valores de entrada para cada parada precisam ser um número e estar em ordem crescente. Os valores de saída precisam ser um número, uma matriz de números ou uma cor.

Expressão de interpolação

Uma expressão de interpolação pode ser usada para calcular um conjunto de valores suave e contínuo, interpolando entre os valores de parada.

Há três tipos de métodos de interpolação que podem ser usados em uma expressão de interpolação:

Nome	Descrição	Parâmetros
`ExpressionInterpolationMode.linear`	Interpola linearmente entre o par de paradas.	`nil`
`ExpressionInterpolationMode.exponential`	Interpola exponencialmente entre as paradas. Uma base é especificada e controla a taxa na qual a saída é aumentada. Valores mais altos fazem com que a saída aumente mais em direção ao alto fim do intervalo. Um valor base próximo a 1 produz uma saída que é aumentada de maneira mais linear.	Uma expressão que é avaliada como um número, especificando a base da interpolação exponencial.
`ExpressionInterpolationMode.cubicBezier`	Interpola por meio de uma curva de Bézier cúbica definida pelos pontos de controle fornecidos.	Uma matriz ou expressão de agregação que contém quatro expressões, cada uma avaliando um número. Os quatro números são pontos de controle para a curva Bézier cúbica.

Aqui está um exemplo de como são estes diferentes tipos de interpolações.

Linear	Exponencial	Bézier cúbica

Exemplo de expressão de interpolação

O exemplo a seguir usa uma expressão de interpolação para definir a propriedade bubbleColor de uma camada de bolhas com base na propriedade temperature do recurso de ponto. Se o valor de temperature for menor que 60, a cor azul é retornada. Se ele estiver entre 60 e for menor que 70, amarelo é retornado. Se ele estiver entre 70 e for menor que 80, laranja é retornado. Se for 80 ou superior, vermelho é retornado.

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

A imagem a seguir demonstra como as cores são escolhidas para a expressão acima.

Exemplo de expressão de interpolação

Expressão de etapa

Uma expressão de etapa pode ser usada para calcular valores de resultado discretos de nível, avaliando uma função piecewise-constant definida por paradas.

As expressões de etapa retornarão o valor de saída da parada logo antes do valor de entrada ou o valor De se a entrada for inferior à primeira parada.

Exemplo de expressão de etapa

O exemplo a seguir usa uma expressão de etapa para definir a propriedade bubbleColor de uma camada de bolhas com base na propriedade temperature do recurso de ponto. Se o valor de temperature for menor que 60, azul é retornado. Se ele estiver entre 60 e for menor que 70, amarelo é retornado. Se ele estiver entre 70 e for menor que 80, laranja é retornado. Se for 80 ou superior, vermelho é retornado.

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

A imagem a seguir demonstra como as cores são escolhidas para a expressão acima.

Exemplo de expressão de etapa

Informações adicionais

Saiba mais sobre as camadas que dão suporte às expressões:

Compartilhar via

Expressões de estilo controladas por dados no SDK do iOS (versão prévia)

Usar predicados para filtrar dados de vetor

Operadores

Operandos

Exemplos de operandos

Usar expressões para configurar opções de camada

Baseado em JSON

Valores de constante

Exemplo de valores constantes

Caminhos de chave

Funções

Condicionais

Exemplo de condicionais

Agregações

Variáveis

Identificador de recurso

Propriedades de recursos

Recurso acumulado

Tipo de geometria

Exemplo de variáveis

Zoom

Exemplo de zoom

Densidade do Mapa de calor

Exemplo de densidade do mapa de calor

Progresso da linha

Exemplo de progresso de linhas

Métodos específicos para AzureMaps

Expressão de correspondência

Exemplos de expressões de correspondência

Expressão de união

Exemplo de expressão de união

Expressão de junção

Exemplo de expressão de junção

Expressões de interpolação e etapas

Expressão de interpolação

Exemplo de expressão de interpolação

Expressão de etapa

Exemplo de expressão de etapa

Informações adicionais

Comentários

Recursos adicionais