Esercitazione: Creare visualizzazioni geospaziali

Si applica a: ✅Microsoft Fabric✅Azure Esplora dati✅ Azure Monitor✅Microsoft Sentinel

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.

Questa esercitazione illustra come:

Prerequisiti

Per eseguire le query seguenti, è necessario un ambiente di query con accesso ai dati di esempio. È possibile usare uno dei seguenti elementi:

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.

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

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 vengono colorati in modo diverso in base al relativo EventTypee, quando selezionato, visualizzano il contenuto della EventType colonna.

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

È 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.

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

Usare i valori GeoJSON per tracciare i punti in 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 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.

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)

Rappresentare 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, i filtri di query seguenti per 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 aree con i tornado più vengono rilevate chiaramente in base alle dimensioni elevate delle bolle.

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)

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.

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)

Visualizzare 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 relativa prossimità all'oggetto LineString definito. Se un evento si trova entro 500 metri da LineString, il rendering dell'evento viene eseguito su una mappa.

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)

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 relativa prossimità al poligono definito. Se un evento è compreso tra 500 metri del poligono, il rendering dell'evento viene eseguito su una mappa.

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)

Trovare anomalie basate su dati geospaziali

La query seguente esegue un'analisi degli eventi storm che si verificano all'interno di un determinato stato. La query usa le celle S2 e l'aggregazione temporale per analizzare i modelli di danno. Il risultato è un grafico di anomalie visive che illustra 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.

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)

Contenuto correlato

• Vedere un caso d'uso per il clustering geospaziale: Analisi dei dati per i veicoli di test automobilistici
• Informazioni sull'architettura di Azure per l'elaborazione e l'analisi geospaziali dei dati
• Ottenere una comprensione completa delle Esplora dati di Azure leggendo il white paper