Dela via

Självstudie: Skapa geospatiala visualiseringar

Gäller för: ✅Microsoft Fabric✅Azure Data Explorer✅Azure Monitor✅Microsoft Sentinel

Den här självstudien är avsedd för dem som vill använda Kusto Query Language (KQL) för geospatial visualisering. Geospatial klustring är ett sätt att organisera och analysera data baserat på geografisk plats. KQL erbjuder flera metoder för att utföra geospatiala kluster och verktyg för geospatiala visualiseringar.

I den här självstudien får du lära dig att:

Förutsättningar

Om du vill köra följande frågor behöver du en frågemiljö med åtkomst till exempeldata. Du kan använda något av följande:

  • Ett Microsoft-konto eller en Microsoft Entra-användaridentitet för att logga in på hjälpkluster
  • Ett Microsoft-konto eller Entra-användaridentitet
  • En Fabric-arbetsyta med Microsoft Fabric-aktiverad kapacitet

Rita punkter på en karta

Om du vill visualisera punkter på en karta använder du projektet för att välja kolumnen som innehåller longitud och sedan kolumnen som innehåller latitud. Använd sedan rendera för att se dina resultat i ett punktdiagram med kind inställt på map.

Kör frågan

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

Skärmbild av stormhändelser på en karta.

Rita flera poängserier

Om du vill visualisera flera poängserier använder du projektet för att välja longitud och latitud tillsammans med en tredje kolumn, som definierar serien.

I följande fråga är EventTypeserien . Punkterna färgas på olika sätt beroende på deras EventType, och när de väljs visas innehållet i EventType kolumnen.

Kör frågan

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

Skärmbild av storm-exempelhändelser på en karta efter typ.

Du kan också uttryckligen ange xcolumn (Longitud), ycolumn (Latitud) och series när du utför render. Den här specifikationen är nödvändig när det finns fler kolumner i resultatet än bara kolumnerna longitud, latitud och serie.

Kör frågan

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

Använd GeoJSON-värden för att rita punkter på en karta

Ett dynamiskt GeoJSON-värde kan ändras eller uppdateras och används ofta för program för realtidsmappning. Mappningspunkter med dynamiska GeoJSON-värden ger mer flexibilitet och kontroll över representationen av data på kartan som kanske inte är möjliga med enkla latitud- och longitudvärden.

Följande fråga använder geo_point_to_s2cell och geo_s2cell_to_central_point för att mappa stormhändelser i ett punktdiagram.

Kör frågan

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)

Skärmbild av stormhändelser som visas med geojson.

Representera datapunkter med bubblor i variabel storlek

Visualisera fördelningen av datapunkter genom att utföra en aggregering i varje kluster och sedan rita den centrala punkten i klustret.

Följande fråga filtrerar till exempel för alla stormhändelser av händelsetypen "Tornado". Sedan grupperas händelserna i kluster baserat på deras longitud och latitud, räknar antalet händelser i varje kluster och projicerar klustrets centrala punkt och återger en karta för att visualisera resultatet. De regioner som har flest tornados blir tydligt upptäckta baserat på deras stora bubbelstorlek.

Kör frågan

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)

Skärmbild av Webbgränssnittet för Azure Data Explorer som visar en geospatial karta över tornadostormar.

Visningspunkter inom ett visst område

Använd en polygon för att definiera regionen och funktionen geo_point_in_polygon för att filtrera efter händelser som inträffar i den regionen.

Följande fråga definierar en polygon som representerar regionen södra Kalifornien och filter för stormhändelser i den här regionen. Den grupperar sedan händelserna i kluster, räknar antalet händelser i varje kluster, projicerar klustrets centrala punkt och återger en karta för att visualisera klustren.

Kör frågan

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)

Skärmbild av webbgränssnittet i Azure Data Explorer som visar en geospatial karta över stormar i södra Kalifornien.

Visa närliggande punkter på en LineString

Följande fråga hittar närliggande stormhändelser som inträffar längs en angiven LineString, som representerar en definierad sökväg. I det här fallet är LineString en väg till Key West. Funktionen geo_distance_point_to_line() används för att filtrera stormhändelserna baserat på deras närhet till den definierade LineString. Om en händelse ligger inom 500 meter från LineString återges händelsen på en karta.

Kör frågan

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)

Skärmbild av resultatet av den tidigare KQL-frågan för att beräkna händelser längs en LineString.

Visa närliggande punkter i en polygon

Följande fråga hittar närliggande stormhändelser som inträffar inom en angiven polygon. I det här fallet är polygonen en väg till Key West. Funktionen geo_distance_point_to_polygon() används för att filtrera stormhändelserna baserat på deras närhet till den definierade polygonen. Om en händelse ligger inom 500 meter från polygonen återges händelsen på en karta.

Kör frågan

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)

Skärmbild av resultatet av den tidigare KQL-frågan för att beräkna händelser längs en polygon.

Hitta avvikelser baserat på geospatiala data

Följande fråga utför en analys av stormhändelser som inträffar inom ett visst tillstånd. Frågan använder S2-celler och temporal aggregering för att undersöka skademönster. Resultatet är ett visuellt avvikelsediagram som visar eventuella oegentligheter eller avvikelser i storminducerad förstörelse över tid, vilket ger ett detaljerat perspektiv på effekten av stormar inom de angivna tillståndsgränserna.

Kör frågan

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)

Skärmbild av avvikelsediagrammet som återges av den tidigare KQL-frågan.

Relaterat innehåll