Compartilhar via

Tutorial: Criar visualizações geoespaciais

  • Artigo

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

Este tutorial é para aqueles que desejam usar a KQL (Linguagem de Consulta Kusto) para visualização geoespacial. O agrupamento geoespacial é uma maneira de organizar e analisar dados com base na localização geográfica. O KQL oferece vários métodos para realizar clustering geoespacial e ferramentas para visualizações geoespaciais.

Neste tutorial, você aprenderá como:

Pré-requisitos

Para executar as consultas a seguir, você precisa de um ambiente de consulta com acesso aos dados de exemplo. Você pode usar um dos itens a seguir:

  • Uma conta da Microsoft ou identidade de usuário do Microsoft Entra para entrar no cluster de ajuda

Pontos de plotagem em um mapa

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

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

Captura de tela de exemplos de eventos de tempestade em um mapa.

Plotar várias séries de pontos

Para visualizar várias séries de pontos, use project para selecionar a longitude e a latitude junto 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 seu EventType, e quando selecionados exibem o EventType conteúdo da coluna.

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

Captura de tela de exemplos de eventos de tempestade em um mapa por tipo.

Você também pode especificar explicitamente o xcolumn (Longitude), ycolumn (Latitude) e series , ao executar o render. Essa 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 que podem não ser possíveis com valores simples de latitude e longitude.

A consulta a seguir usa o geo_point_to_s2cell e o 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)

Captura de tela de exemplos de eventos de tempestade exibidos usando geojson.

Representar pontos de dados com bolhas de tamanho variável

Visualize a distribuição de 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, ele 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 são claramente detectadas com base em 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)

Captura de tela da interface do usuário da Web do Azure Data Explorer mostrando um mapa geoespacial de tempestades de tornado.

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

Captura de tela da interface do usuário da Web do Azure Data Explorer mostrando um mapa geoespacial das tempestades do sul da Califórnia.

Mostrar pontos próximos em uma LineString

A consulta a seguir localiza eventos de tempestade próximos que ocorrem ao longo de uma LineString especificada, que representa um caminho definido. Nesse 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 dentro 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)

Captura de tela do resultado da consulta KQL anterior para calcular eventos ao longo de uma LineString.

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. Nesse 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 em sua proximidade com o polígono definido. Se um evento estiver a 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)

Captura de tela do resultado da consulta KQL anterior para calcular eventos ao longo de um polígono.

Encontre anomalias com base em dados geoespaciais

A consulta a seguir executa uma análise de eventos de tempestade que ocorrem em um estado específico. 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 perspectiva detalhada sobre o efeito das tempestades dentro dos limites do estado especificados.

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)

Captura de tela do gráfico de anomalias renderizado pela consulta KQL anterior.

Conteúdo relacionado