Lire en anglais

Partager via

Tutoriel : Créer des visualisations géospatiales

  • Article

S’applique à : ✅Microsoft Fabric✅Azure Data Explorer✅Azure Monitor✅Microsoft Sentinel

Ce tutoriel est destiné aux personnes qui souhaitent utiliser Langage de requête Kusto (KQL) pour la visualisation géospatiale. Le clustering géospatial est un moyen d’organiser et d’analyser les données en fonction de l’emplacement géographique. KQL offre plusieurs méthodes pour effectuer des clusters géospatiaux et des outils pour les visualisations géospatiales.

Ce didacticiel vous montre comment effectuer les opérations suivantes :

Prérequis

Pour exécuter les requêtes suivantes, vous avez besoin d’un environnement de requête avec accès aux exemples de données. Vous pouvez utiliser l'un des éléments suivants :

  • Un compte Microsoft ou une identité d’utilisateur Microsoft Entra pour vous connecter au cluster d’aide

Tracer des points sur une carte

Pour visualiser des points sur une carte, utilisez le projet pour sélectionner la colonne contenant la longitude, puis la colonne contenant la latitude. Ensuite, utilisez le rendu pour afficher vos résultats dans un nuage de points avec kind la valeur définie mapsur .

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

Capture d’écran d’exemples d’événements storm sur une carte.

Tracer plusieurs séries de points

Pour visualiser plusieurs séries de points, utilisez le projet pour sélectionner la longitude et la latitude, ainsi qu’une troisième colonne, qui définit la série.

Dans la requête suivante, la série est EventType. Les points sont colorés différemment en fonction de leur EventType, et lorsqu’ils sont sélectionnés, affichent le contenu de la EventType colonne.

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

Capture d’écran d’exemples d’événements storm sur une carte par type.

Vous pouvez également spécifier explicitement la xcolumn (longitude), ycolumn (Latitude) et series lors de l’exécution du render. Cette spécification est nécessaire lorsqu’il existe plus de colonnes dans le résultat que seulement les colonnes longitude, latitude et série.

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

Utiliser des valeurs GeoJSON pour tracer des points sur une carte

Une valeur GeoJSON dynamique peut changer ou être mise à jour et sont souvent utilisées pour les applications de mappage en temps réel. Les points de mappage utilisant des valeurs GeoJSON dynamiques permettent une plus grande flexibilité et un contrôle sur la représentation des données sur la carte qui peuvent ne pas être possibles avec des valeurs de latitude et de longitude simples.

La requête suivante utilise les geo_point_to_s2cell et les geo_s2cell_to_central_point pour mapper les événements storm dans un nuage de points.

Kusto 
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)

Capture d’écran d’exemples d’événements storm affichés à l’aide de geojson.

Représenter des points de données avec des bulles de taille variable

Visualisez la distribution des points de données en effectuant une agrégation dans chaque cluster, puis en tracéant le point central du cluster.

Par exemple, la requête suivante filtre tous les événements storm du type d’événement « Tornado ». Il regroupe ensuite les événements en clusters en fonction de leur longitude et de leur latitude, compte le nombre d’événements dans chaque cluster et projette le point central du cluster et affiche une carte pour visualiser le résultat. Les régions avec les plus tornades deviennent clairement détectées en fonction de leur grande taille de bulle.

Kusto 
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)

Capture d’écran de l’interface utilisateur web Azure Data Explorer montrant une carte géospatiale des tempêtes tornado.

Afficher des points dans une zone spécifique

Utilisez un polygone pour définir la région et la fonction geo_point_in_polygon pour filtrer les événements qui se produisent dans cette région.

La requête suivante définit un polygone représentant la région du sud de la Californie et filtre les événements de tempête dans cette région. Il regroupe ensuite les événements en clusters, compte le nombre d’événements dans chaque cluster, projette le point central du cluster et affiche une carte pour visualiser les clusters.

Kusto 
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)

Capture d’écran de l’interface utilisateur web Azure Data Explorer montrant une carte géospatiale des tempêtes du sud de la Californie.

Afficher les points à proximité d’une LineString

La requête suivante recherche les événements storm proches qui se produisent le long d’un LineString spécifié, qui représente un chemin défini. Dans ce cas, LineString est une route vers Key West. La fonction geo_distance_point_to_line() est utilisée pour filtrer les événements storm en fonction de leur proximité avec lineString défini. Si un événement se trouve à moins de 500 mètres de LineString, l’événement est affiché sur une carte.

Kusto 
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)

Capture d’écran du résultat de la requête KQL précédente pour calculer les événements le long d’une lineString.

Afficher les points à proximité dans un polygone

La requête suivante recherche les événements storm proches qui se produisent dans un polygone spécifié. Dans ce cas, le polygone est une route vers Key West. La fonction geo_distance_point_to_polygon() permet de filtrer les événements storm en fonction de leur proximité avec le polygone défini. Si un événement se trouve à moins de 500 mètres du polygone, l’événement est rendu sur une carte.

Kusto 
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)

Capture d’écran du résultat de la requête KQL précédente pour calculer les événements le long d’un polygone.

Rechercher des anomalies basées sur des données géospatiales

La requête suivante effectue une analyse des événements storm qui se produisent dans un état particulier. La requête utilise des cellules S2 et l’agrégation temporelle pour examiner les modèles de dommages. Le résultat est un graphique d’anomalies visuelles qui décrit toutes les irrégularités ou écarts dans la destruction provoquée par la tempête au fil du temps, offrant une perspective détaillée sur l’effet des tempêtes dans les limites d’état spécifiées.

Kusto 
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)

Capture d’écran du graphique d’anomalies rendu par la requête KQL précédente.

Contenu connexe