Tutorial: Criar visualizações geoespaciais

Aplica-se a: ✅Microsoft Fabric✅Azure Data Explorer✅Azure Monitor✅Microsoft Sentinel

Este tutorial é para aqueles que querem usar Kusto Query Language (KQL) para visualização geoespacial. O agrupamento geoespacial é uma forma de organizar e analisar dados com base na localização geográfica. O KQL oferece vários métodos para realizar agrupamentos geoespaciais e ferramentas para visualizações geoespaciais.

Neste tutorial, você aprenderá a:

Pré-requisitos

Para executar as consultas a seguir, você precisa de um ambiente de consulta com acesso aos dados de exemplo. Você pode usar uma das seguintes opções:

Traçar pontos num mapa

Para visualizar pontos em um mapa, use o projeto para selecionar a coluna que contém a longitude e, em seguida, a coluna que contém a latitude. Em seguida, use renderizar para ver seus resultados em um gráfico de dispersão com kind definido como map.

StormEvents
| take 100
| project BeginLon, BeginLat
| render scatterchart with (kind = map)

Plotar várias séries de pontos

Para visualizar várias séries de pontos, use o projeto para selecionar a longitude e a latitude, juntamente com uma terceira coluna, que define a série.

Na consulta a seguir, a série é EventType. Os pontos são coloridos de forma diferente de acordo com o seu EventType e, quando selecionados, exibem o conteúdo da coluna EventType.

StormEvents
| take 100
| project BeginLon, BeginLat, EventType
| render scatterchart with (kind = map)

Você também pode especificar explicitamente o xcolumn (Longitude), ycolumn (Latitude) e series ao executar o render. Esta especificação é necessária quando há mais colunas no resultado do que apenas as colunas de longitude, latitude e série.

StormEvents
| take 100
| render scatterchart with (kind = map, xcolumn = BeginLon, ycolumns = BeginLat, series = EventType)

Usar valores GeoJSON para plotar pontos em um mapa

Um valor GeoJSON dinâmico pode ser alterado ou atualizado e geralmente é usado para aplicativos de mapeamento em tempo real. O mapeamento de pontos usando valores GeoJSON dinâmicos permite mais flexibilidade e controle sobre a representação dos dados no mapa, o que pode não ser possível com valores simples de latitude e longitude.

A consulta a seguir usa os geo_point_to_s2cell e geo_s2cell_to_central_point para mapear eventos de tempestade em um gráfico de dispersão.

StormEvents
| project BeginLon, BeginLat
| summarize by hash=geo_point_to_s2cell(BeginLon, BeginLat, 5)
| project point = geo_s2cell_to_central_point(hash)
| project lng = toreal(point.coordinates[0]), lat = toreal(point.coordinates[1])
| render scatterchart with (kind = map)

Representar pontos de dados com bolhas de tamanho variável

Visualize a distribuição dos pontos de dados executando uma agregação em cada cluster e, em seguida, plotando o ponto central do cluster.

Por exemplo, a consulta a seguir filtra todos os eventos de tempestade do tipo de evento "Tornado". Em seguida, agrupa os eventos em clusters com base em sua longitude e latitude, conta o número de eventos em cada cluster e projeta o ponto central do cluster e renderiza um mapa para visualizar o resultado. As regiões com mais tornados tornam-se claramente detetadas com base no seu grande tamanho de bolha.

StormEvents
| where EventType == "Tornado"
| project BeginLon, BeginLat
| where isnotnull(BeginLat) and isnotnull(BeginLon)
| summarize count_summary=count() by hash = geo_point_to_s2cell(BeginLon, BeginLat, 4)
| project geo_s2cell_to_central_point(hash), count_summary
| extend Events = "count"
| render piechart with (kind = map)

Exibir pontos dentro de uma área específica

Use um polígono para definir a região e a função geo_point_in_polygon para filtrar eventos que ocorrem nessa região.

A consulta a seguir define um polígono que representa a região sul da Califórnia e filtra eventos de tempestade nessa região. Em seguida, agrupa os eventos em clusters, conta o número de eventos em cada cluster, projeta o ponto central do cluster e renderiza um mapa para visualizar os clusters.

let southern_california = dynamic({
    "type": "Polygon",
    "coordinates": [[[-119.5, 34.5], [-115.5, 34.5], [-115.5, 32.5], [-119.5, 32.5], [-119.5, 34.5]]
    ]});
StormEvents
| where geo_point_in_polygon(BeginLon, BeginLat, southern_california)
| project BeginLon, BeginLat
| summarize count_summary = count() by hash = geo_point_to_s2cell(BeginLon, BeginLat, 8)
| project geo_s2cell_to_central_point(hash), count_summary
| extend Events = "count"
| render piechart with (kind = map)

Mostrar pontos próximos em um LineString

A consulta a seguir localiza eventos de tempestade próximos que ocorrem ao longo de um LineString especificado, que representa um caminho definido. Neste caso, o LineString é uma estrada para Key West. A função geo_distance_point_to_line() é usada para filtrar os eventos de tempestade com base em sua proximidade com o LineString definido. Se um evento estiver a menos de 500 metros de LineString, o evento será renderizado em um mapa.

let roadToKeyWest = dynamic({
"type":"linestring",
"coordinates":[
          [
            -81.79595947265625,
            24.56461038017685
          ],
          [
            -81.595458984375,
            24.627044746156027
          ],
          [
            -81.52130126953125,
            24.666986385216273
          ],
          [
            -81.35650634765625,
            24.66449040712424
          ],
          [
            -81.32354736328125,
            24.647017162630366
          ],
          [
            -80.8099365234375,
            24.821639356846607
          ],
          [
            -80.62042236328125,
            24.93127614538456
          ],
          [
            -80.37872314453125,
            25.175116531621764
          ],
          [
            -80.42266845703124,
            25.19251511519153
          ],
          [
            -80.4803466796875,
            25.46063471847754
          ]
        ]});
StormEvents
| where isnotempty(BeginLat) and isnotempty(BeginLon)
| project BeginLon, BeginLat, EventType
| where geo_distance_point_to_line(BeginLon, BeginLat, roadToKeyWest) < 500
| render scatterchart with (kind=map)

Mostrar pontos próximos em um polígono

A consulta a seguir localiza eventos de tempestade próximos que ocorrem dentro de um polígono especificado. Neste caso, o polígono é uma estrada para Key West. A função geo_distance_point_to_polygon() é usada para filtrar os eventos de tempestade com base na sua proximidade com o polígono definido. Se um evento estiver a menos de 500 metros do polígono, o evento será renderizado em um mapa.

let roadToKeyWest = dynamic({
"type":"polygon",
"coordinates":[
          [
            [
              -80.08209228515625,
              25.39117928167583
            ],
            [
              -80.4913330078125,
              25.517657429994035
            ],
            [
              -80.57922363281249,
              25.477992320574817
            ],
            [
              -82.188720703125,
              24.632038149596895
            ],
            [
              -82.1942138671875,
              24.53712939907993
            ],
            [
              -82.13104248046875,
              24.412140070651528
            ],
            [
              -81.81243896484375,
              24.43714786161562
            ],
            [
              -80.58746337890625,
              24.794214972389486
            ],
            [
              -80.08209228515625,
              25.39117928167583
            ]
          ]
        ]});
StormEvents
| where isnotempty(BeginLat) and isnotempty(BeginLon)
| project BeginLon, BeginLat, EventType
| where geo_distance_point_to_polygon(BeginLon, BeginLat, roadToKeyWest) < 500
| render scatterchart with (kind=map)

Encontrar anomalias com base em dados geoespaciais

A consulta a seguir executa uma análise de eventos de tempestade que ocorrem dentro de um determinado estado. A consulta usa células S2 e agregação temporal para investigar padrões de danos. O resultado é um gráfico visual de anomalias que retrata quaisquer irregularidades ou desvios na destruição induzida por tempestades ao longo do tempo, oferecendo uma perspetiva detalhada sobre o efeito das tempestades dentro dos limites especificados do estado.

let stateOfInterest = "Texas";
let statePolygon = materialize(
    US_States
    | extend name = tostring(features.properties.NAME)
    | where name == stateOfInterest
    | project geometry=features.geometry);
let stateCoveringS2cells = statePolygon
    | project s2Cells = geo_polygon_to_s2cells(geometry, 9);
StormEvents
| extend s2Cell = geo_point_to_s2cell(BeginLon, BeginLat, 9)
| where s2Cell in (stateCoveringS2cells)
| where geo_point_in_polygon(BeginLon, BeginLat, toscalar(statePolygon))
| make-series damage = avg(DamageProperty + DamageCrops) default = double(0.0) on StartTime step 7d
| extend anomalies=series_decompose_anomalies(damage)
| render anomalychart with (anomalycolumns=anomalies)

Conteúdo relacionado

• Veja um caso de uso para agrupamento geoespacial: Análise de dados para frotas de teste automotivo
• Saiba mais sobre a arquitetura do Azure para processamento e análise de dados geoespaciais
• Obtenha uma compreensão abrangente do Azure Data Explorer lendo o white paper