Share via

Esercitazione: Creare visualizzazioni geospaziali

  • Articolo

Questa esercitazione è destinata a coloro che vogliono usare Linguaggio di query Kusto (KQL) per la visualizzazione geospaziale. Il clustering geospaziale è un modo per organizzare e analizzare i dati in base alla posizione geografica. KQL offre più metodi per l'esecuzione di clustering geospaziale e strumenti per le visualizzazioni geospaziali.

In questa esercitazione si apprenderà come:

Tracciare punti su una mappa

Per visualizzare i punti su una mappa, usare il progetto per selezionare la colonna contenente la longitudine e quindi la colonna contenente la latitudine. Usare quindi il rendering per visualizzare i risultati in un grafico a dispersione con kind impostato su map.

Eseguire la query

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

Screenshot degli eventi storm di esempio su una mappa.

Tracciare più serie di punti

Per visualizzare più serie di punti, usare il progetto per selezionare la longitudine e la latitudine insieme a una terza colonna, che definisce la serie.

Nella query seguente la serie è EventType. I punti sono colorati in modo diverso in base al relativo EventTypee, quando selezionato, visualizzano il contenuto della EventType colonna.

Eseguire la query

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

Screenshot degli eventi storm di esempio in una mappa per tipo.

È anche possibile specificare xcolumn in modo esplicito (Longitudine), ycolumn (Latitudine) e series quando si esegue .render Questa specifica è necessaria quando sono presenti più colonne nel risultato rispetto alle colonne longitudine, latitudine e serie.

Eseguire la query

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

Usare i valori GeoJSON per tracciare i punti su una mappa

Un valore GeoJSON dinamico può cambiare o essere aggiornato e viene spesso usato per le applicazioni di mapping in tempo reale. Il mapping dei punti che usano valori GeoJSON dinamici consente una maggiore flessibilità e controllo sulla rappresentazione dei dati sulla mappa che potrebbero non essere possibili con valori di latitudine e longitudine semplici.

La query seguente usa il geo_point_to_s2cell e geo_s2cell_to_central_point per eseguire il mapping degli eventi storm in un grafico a dispersione.

Eseguire la query

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)

Screenshot degli eventi storm di esempio visualizzati con geojson.

Rappresentare i punti dati con bolle di dimensioni variabili

Visualizzare la distribuzione dei punti dati eseguendo un'aggregazione in ogni cluster e quindi tracciando il punto centrale del cluster.

Ad esempio, la query seguente filtra tutti gli eventi storm del tipo di evento "Tornado". Raggruppa quindi gli eventi in cluster in base alla longitudine e alla latitudine, conta il numero di eventi in ogni cluster e proietta il punto centrale del cluster ed esegue il rendering di una mappa per visualizzare il risultato. Le regioni con il maggior numero di tornado diventano chiaramente rilevate in base alle loro grandi dimensioni della bolla.

Eseguire la query

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)

Screenshot dell'interfaccia utente Web di Azure Esplora dati che mostra una mappa geospaziale di tempeste tornado.

Visualizzare i punti all'interno di un'area specifica

Usare un poligono per definire l'area e la funzione geo_point_in_polygon per filtrare gli eventi che si verificano all'interno di tale area.

La query seguente definisce un poligono che rappresenta l'area della California meridionale e filtra gli eventi di tempesta all'interno di questa area. Raggruppa quindi gli eventi in cluster, conta il numero di eventi in ogni cluster, proietta il punto centrale del cluster ed esegue il rendering di una mappa per visualizzare i cluster.

Eseguire la query

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)

Screenshot dell'interfaccia utente Web di Azure Esplora dati che mostra una mappa geospaziale delle tempeste della California meridionale.

Mostra i punti vicini in un oggetto LineString

La query seguente trova gli eventi storm nelle vicinanze che si verificano lungo un oggetto LineString specificato, che rappresenta un percorso definito. In questo caso, LineString è una strada verso Key West. La funzione geo_distance_point_to_line() viene usata per filtrare gli eventi storm in base alla loro prossimità all'oggetto LineString definito. Se un evento è compreso tra 500 metri da LineString, il rendering dell'evento viene eseguito su una mappa.

Eseguire la query

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)

Screenshot del risultato della query KQL precedente per calcolare gli eventi lungo un oggetto LineString.

Mostra i punti vicini in un poligono

La query seguente trova gli eventi storm nelle vicinanze che si verificano all'interno di un poligono specificato. In questo caso, il poligono è una strada verso Key West. La funzione geo_distance_point_to_polygon() viene usata per filtrare gli eventi storm in base alla loro prossimità al poligono definito. Se un evento è compreso tra 500 metri del poligono, il rendering dell'evento viene eseguito su una mappa.

Eseguire la query

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)

Screenshot del risultato della query KQL precedente per calcolare gli eventi lungo un poligono.

Trovare anomalie basate su dati geospaziali

La query seguente esegue un'analisi degli eventi storm che si verificano all'interno di uno stato specifico. La query usa celle S2 e aggregazione temporale per analizzare i modelli di danno. Il risultato è un grafico di anomalie visivo che rappresenta eventuali irregolarità o deviazioni nella distruzione indotta dalle tempeste nel tempo, offrendo una prospettiva dettagliata sull'effetto delle tempeste all'interno dei limiti di stato specificati.

Eseguire la query

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)

Screenshot del grafico anomalie di cui è stato eseguito il rendering dalla query KQL precedente.

Contenuti correlati