Självstudie: Analysera resedata med Snap to Roads i Microsoft Fabric Notebook

Snap to Roads är en Azure Maps-tjänst som bearbetar en uppsättning GPS-punkter som samlats in längs en väg och fäster dem på de mest sannolika vägarna som fordonet färdades på. Den här funktionen är användbar för att fastställa den exakta sökvägen följt av ett fordon, även när DE GPS-data som samlas in är avstängt något.

Den här självstudien beskriver hur du använder Azure Maps Snap to Roads API med Microsoft Fabric för att analysera GPS-data från att flytta tillgångar, även om data är felaktiga eller ofullständiga på grund av signalförlust. Den vägleder dig genom att göra anrop till Azure Maps Snap to Roads-API:et från en Microsoft Fabric-notebook-fil för att fästa GPS-punkterna på närmaste väg, fylla saknade punkter med hjälp av interpolerade datapunkter och förbättra dem med ytterligare attribut som vägnamn och hastighetsbegränsningar.

I den här självstudien kommer vi att:

Förutsättningar

• Ett Azure Maps-konto
• En prenumerationsnyckel
• Ett Microsoft Fabric-konto
• Grundläggande förståelse för Microsoft Fabric.

Skapa en Microsoft Fabric-anteckningsbok och lakehouse

Följ dessa steg för att skapa en Microsoft Fabric-notebook-fil:

1. Gå till min arbetsyta och välj Nytt objekt.

   

2. När skärmen Nytt objekt visas rullar du nedåt och väljer Notebook.

   

3. På skärmen Notebook Explorer väljer du pilen .

   

4. Välj knappen Lägg till.

   

5. I dialogrutan Lägg till lakehouse väljer du New Lakehouse och sedan knappen Lägg till.

6. I dialogrutan New lakehouse anger du namnet "Azure_Maps_Data" och väljer sedan knappen Skapa.

Lägga till en datafil i lakehouse

Snap to Roads tar GPS-punktdata (lat, lon) och returnerar en lista över objekt som utgör en väg som är fäst på vägarna på en karta. En datafil som innehåller nödvändiga GPS-data kan läggas till som en fil i lakehouse och refereras av python-koden i din notebook-fil.

Ladda ned datafil

Ladda ned exempeldata (mockData_20240919.csv) från GitHub till din lokala lagringsenhet för att ladda upp till Lakehouse i nästa avsnitt. Den här filen innehåller en matris med GPS-koordinater som Snap to Roads-tjänsten ändrar efter behov för att säkerställa att varje koordinat pekar på en giltig väg.

1. Öppna filen mockData_20240919.csv i GitHub.

2. Välj knappen Ladda ned råfil i det övre högra hörnet på skärmen och spara filen lokalt.

   

Ladda upp datafil till lakehouse

Följande steg förklarar hur du lägger till en datakälla i lakehouse.

1. I mappen Filer i lakehouse väljer du Ladda upp > filer.

   

2. Öppna dialogrutan genom att välja mappikonen. Välj den mockData_20240919.csv fil som du laddade ned i föregående avsnitt och sedan knappen Öppna. När dialogrutan Öppna filen stängs och rätt filnamn visas i kontrollen Ladda upp filer väljer du knappen Ladda upp för att ladda upp filen till lakehouse.

   

Lägga till kod i notebook-filen

Du måste lägga till och köra fyra kodceller i notebook-filen för att utföra scenariot Fäst på vägar . Följande avsnitt beskriver detta.

Installera paket

Du måste först läsa in de paket som krävs:

!pip install geopandas
!pip install geojson

Ange pip-installationsinstruktionerna i den första cellen i anteckningsboken och kör sedan instruktionerna genom att välja körningspilen.

Läsa in data

Läs sedan in exempeldata som du tidigare laddade upp till ditt lakehouse.

1. Hovra pekaren precis under cellen som används för att installera paketen. Alternativ visas för att lägga till kod eller markdown. Välj Kod för att lägga till ytterligare en kodcell i anteckningsboken.

   

2. När den nya cellen har skapats lägger du till följande kod.

   import geopandas as gpd
   import pandas as pd
   
   lakehouseFilePath = "/lakehouse/default/Files/"
   
   mockdata_df = gpd.read_file(lakehouseFilePath + "mockData_20240919.csv")
   mockdata_df = gpd.GeoDataFrame(
       mockdata_df, geometry=gpd.points_from_xy(mockdata_df.longitude, mockdata_df.latitude), crs="EPSG:4326"
   )
   
   mockdata_df.head()
   
   mockdata_df.tripID.unique()
   

3. Kör koden genom att välja körningspilen. Detta läser in dina exempeldata.

Förbättra med Snap to Roads

Koden i den här notebook-cellen läser rådata från datafilen i Lakehouse och skickar dem till Azure Maps Snap to Road API. När interpoleringen är aktiverad lägger API:et till punkter mellan GPS-platser för att slutföra vägvägen längs vägen. Den innehåller även attribut som vägnamn och hastighetsbegränsningar när det är tillgängligt.

1. Hovra pekaren precis under cellen som användes för att installera paketen i föregående steg. Alternativ visas för att lägga till kod eller markdown. Välj Kod för att lägga till ytterligare en kodcell i anteckningsboken.

2. När den nya cellen har skapats lägger du till följande kod. Se till att du lägger till din prenumerationsnyckel.

   import requests
   import json
   
   az_maps_subkey = ""
   az_maps_snaproads_url = "https://atlas.microsoft.com/route/snapToRoads?api-version=2025-01-01&subscription-key=" + az_maps_subkey
   
   # Function to process snap to road for each given trip
   def process_route(df, outputFilePath):
       # List to store successful responses
       successful_responses = []
   
       # Function to send a chunk of features
       def send_chunk_snaproads(chunk):
           geojson_data = chunk.to_json()
           # Convert the JSON string to a Python dictionary
           geojson_dict = json.loads(geojson_data)
   
           # Add the new fields at the end of the dictionary
           geojson_dict['includeSpeedLimit'] = True
           geojson_dict['interpolate'] = True
           geojson_dict['travelMode'] = "driving"
   
           # Convert the dictionary back to a JSON string
           updated_geojson_data = json.dumps(geojson_dict)
   
           response = requests.post(
           az_maps_snaproads_url, 
           headers={'Content-Type': 'application/json'}, 
           data=updated_geojson_data
           )
   
           if response.status_code == 200:
               print('Chunk request was successful...')
               successful_responses.append(response.json())
           else:
               print(f'Failed to send request. Status code: {response.status_code}')
               print('Response body:', response.text)
   
       # Loop over the GeoDataFrame in chunks of 100
       chunk_size = 100
       for start in range(0, len(df), chunk_size):
           end = start + chunk_size
           chunk = df.iloc[start:end]
           send_chunk_snaproads(chunk)
   
       # Extract features with geometry from successful responses
       features_with_geometry = []
       for response in successful_responses:
           if 'features' in response:
               for feature in response['features']:
                   if 'geometry' in feature:
                       longitude = feature['geometry']['coordinates'][0]
                       latitude = feature['geometry']['coordinates'][1]
                       feature['properties']['latitude'] = latitude
                       feature['properties']['longitude'] = longitude
                       features_with_geometry.append(feature)
   
       # Convert the list of features with geometry to a GeoDataFrame
       if features_with_geometry:
           responses_gdf = gpd.GeoDataFrame.from_features(features_with_geometry)
   
           # Write successful responses to a cvs file
           #responses_gdf.to_file(outputFilePath, driver='GeoJSON')
           responses_gdf.to_csv(outputFilePath, encoding='utf-8', index=False)
   
           print(f'Successful responses written to {outputFilePath}')
       else:
           print('No valid features with geometry found in the responses.')
   

3. Kör koden genom att välja körningspilen.

Skapa en fil med förbättrade data

Följande kod tar utdata som skapades i den tidigare kodcellen och skapar en ny CSV-fil i lakehouse med namnet SnapRoadResponses.csv. Den här nya datafilen innehåller uppdaterade GPS-koordinater som är anpassade till lämplig väg, den innehåller även gatunamn och hastighetsbegränsningar när de är tillgängliga. SnapRoadResponses.csv importeras till ett händelsehus och används för att skapa ett visuellt kartobjekt senare i den här självstudien.

1. Hovra pekaren precis under cellen som används för att förbättra med Fäst på vägar i föregående steg. Alternativ visas för att lägga till kod eller markdown. Välj Kod för att lägga till ytterligare en kodcell i anteckningsboken.

2. När den nya cellen har skapats lägger du till följande kod.

   lakehouseFilePath = "/lakehouse/default/Files/"
   #execute snap to road
   outputFilePath = lakehouseFilePath + "SnapRoadResponses" + ".csv"
   df = mockdata_df.sort_values(by='timeStamp').reset_index(drop=True)
   process_route(df, outputFilePath)
   

3. Kör koden genom att välja körningspilen. Detta sparar SnapRoadResponses.csv med uppdaterade GPS-koordinater till sjöhuset.

Kopiera filsökväg

ABFS-sökvägen till SnapRoadResponses.csv krävs senare i den här självstudien när du skapar händelsehuset. Om du vill hämta ABFS-sökvägen till den här filen väljer du ellipsen (...) bredvid filen och väljer sedan Kopiera ABFS-sökväg från popup-menyn. När du har kopierat den sparar du den till senare.

Skapa eventhouse och länka till data i lakehouse

Skapa ett händelsehus för att hantera telemetridata för din flotta eller flytta tillgångar. En KQL-databas skapas automatiskt som standard. I den här självstudien importerar du snappade data från lakehuset till KQL-databasen. För realtidsanalys lägger du till strömmande data. När data har laddats upp kan du fråga dina data med hjälp av Kusto-frågespråk i en KQL-frågeuppsättning.

1. Gå till min arbetsyta och välj Nytt objekt.

2. När skärmen Nytt objekt visas rullar du nedåt och väljer Eventhouse.

3. På skärmen Nytt Eventhouse anger du ett namn för ditt nya händelsehus, till exempel SnapToRoadDemo.

   Länka sedan lakehouse som du skapade tidigare till ditt nya eventhouse.

4. Välj ellipsen bredvid ditt nya eventhouse och sedan Hämta data > OneLake från popup-menyn.

   

5. Välj Ny tabell, ge den namnet GPSData och välj sedan Nästa.

   

6. Ange ABFS-sökvägen till Lakehouse-datafilen (SnapRoadResponses.csv) i OneLake-filkontrollen som du sparade tidigare och välj sedan plustecknet (+) för att lägga till den i listan.

   

7. Välj Nästa.

8. När du har verifierat data på skärmen Inspektera data väljer du Slutför.

   

9. Välj Stäng för att stänga sammanfattningssidan .

   

Händelsehuset ska nu skapas och innehålla GPS-data.

Skapa realtidsinstrumentpanel

Du kan skapa en realtidsinstrumentpanel för att ansluta till din datauppsättning i händelsehuset. Indata i den här självstudien är statiska data, inte en realtidsström, men panelerna på instrumentpanelen, till exempel Azure Maps Visual, kan användas för visuell representation och analys.

Lägg till datakälla

1. Gå till min arbetsyta och välj Nytt objekt.

2. När skärmen Nytt objekt visas söker du efter eller rullar nedåt och väljer Instrumentpanel i realtid.

3. På skärmen Ny realtidsinstrumentpanel anger du namnet SnapToRoadDashboard och väljer sedan Skapa.

4. På den nya instrumentpanelen i realtid väljer du Ny datakälla.

5. Välj knappen Lägg till och välj sedan OneLake-datahubben.

   

6. Välj din datakälla och sedan Anslut.

   

7. Ange ett visningsnamn och välj sedan Lägg till.

   

8. Stäng panelen Datakällor .

Nu när du har lagt till datakällan för instrumentpanelen i realtid kan du lägga till en fråga och mappa visuella objekt.

Lägga till visuella frågor och mappa visuella objekt

1. Välj Lägg till panel.

   

2. Ange GPSData i frågan och välj sedan Kör. När du har verifierat att frågan fungerar väljer du Lägg till visuellt objekt.

   

3. I panelen Visuell formatering väljer du Mappa i listrutan Visuell typ .

4. Ange sedan dina värden i avsnittet Data :

   Datainställning	värde
   Definiera efter plats	Latitud och longitud
   Latitudkolumn	latitud (verklig)
   Longitudkolumn	longitud (verklig)

5. Uppdatera kartinformationskortet genom att välja ett värde i listrutan Etikettkolumn. Välj SpeedLimitInKilometersPerHour.

6. Välj Tillämpa ändringar

Det visuella kartobjektet visas. Du kan välja valfri punkt på kartan för att hämta koordinaterna och hastighetsgränsen i kilometer per timme för den platsen.

Nästa steg

Mer information om Microsoft Fabric-notebook-filer:

I den här självstudien skapades en instrumentpanel för analys efter färdvägen. En steg-för-steg-guide för att skapa instrumentpaneler i realtid i Microsoft Fabric: