Tutorial: analisar dados da viagem usando o Snap to Roads no notebook do Microsoft Fabric

Snap to Roads é um serviço do Azure Mapas que processa um conjunto de pontos GPS coletados ao longo de uma rota e os prende às estradas mais prováveis que o veículo viajou. Esse recurso é útil para determinar o caminho exato seguido por um veículo, mesmo quando os dados GPS coletados estão ligeiramente desativados.

Este tutorial explica como usar a API Snap to Roads do Azure Mapas com o Microsoft Fabric para analisar dados de GPS da movimentação de ativos, mesmo quando os dados são imprecisos ou incompletos devido à perda de sinal. Ele orienta você a fazer chamadas para a API Snap to Roads do Azure Mapas de um bloco de anotações do Microsoft Fabric para ajustar os pontos GPS para a estrada mais próxima, preencher pontos ausentes usando pontos de dados interpolados e aprimorá-los com atributos adicionais, como nomes de estrada e limites de velocidade.

Neste tutorial, você irá:

Pré-requisitos

• Uma Conta do Azure Mapas
• Uma chave de assinatura
• Uma conta do Microsoft Fabric
• Compreensão básica do Microsoft Fabric.

Criar um bloco de anotações do Microsoft Fabric e um lakehouse

Siga estas etapas para criar um notebook do Microsoft Fabric:

1. Vá para o Meu workspace e selecione Novo item.

   

2. Quando a tela Novo item aparecer, role para baixo e selecione Notebook.

   

3. Na tela Explorer do notebook, selecione a seta Lakehouses>.

   

4. Selecione o botão Adicionar.

   

5. Na caixa de diálogo Adicionar lakehouse, selecione Novo Lakehouse e, em seguida, o botão Adicionar.

6. Na caixa de diálogo New lakehouse, insira um nome "Azure_Maps_Data" e selecione o botão Criar.

Adicionar um arquivo de dados ao lakehouse

Snap to Roads usa dados de ponto GPS (lat, lon) e retorna uma lista de objetos que formam uma rota quebrada para as estradas em um mapa. Um arquivo de dados que contém os dados de GPS necessários pode ser adicionado como um arquivo ao lakehouse e referenciado pelo código python em seu notebook.

Baixar o arquivo de dados

Baixe os dados de exemplo (mockData_20240919.csv) do GitHub para seu dispositivo de armazenamento local para carregar no lakehouse na próxima seção. Esse arquivo contém uma matriz de coordenadas GPS que o serviço Snap to Roads modifica conforme necessário para garantir que cada coordenada aponte para uma estrada válida.

1. Abra o mockData_20240919.csv de arquivo no GitHub.

2. Selecione o botão Baixar arquivo RAW no canto superior direito da tela e salve o arquivo localmente.

   

Carregar arquivo de dados no lakehouse

As etapas a seguir explicam como adicionar uma fonte de dados ao lakehouse.

1. Na pasta Arquivos na lakehouse, selecione Carregar > Carregar arquivos.

   

2. Abra a caixa de diálogo abrir o arquivo selecionando o ícone pasta. Selecione o arquivo mockData_20240919.csv baixado na seção anterior e, em seguida, o botão Abrir. Depois que a caixa de diálogo abrir o arquivo for fechada e o nome de arquivo correto aparecer no controle Carregar arquivos, selecione o botão Carregar para carregar o arquivo no lakehouse.

   

Adicionar código ao notebook

Você precisa adicionar e executar quatro células de código em seu notebook para executar o cenário Snap to Roads. As seções a seguir orientam você sobre isso.

Instalar Pacotes

Primeiro, você precisa carregar os pacotes necessários:

!pip install geopandas
!pip install geojson

Insira as instruções de instalação pip na primeira célula do bloco de anotações e execute as instruções selecionando a seta de execução.

Carregar dados

Em seguida, carregue os dados de exemplo que você carregou anteriormente em seu lakehouse.

1. Focalize o ponteiro logo abaixo da célula usada para instalar os pacotes. As opções aparecem para adicionar código ou markdown. Selecione Código para adicionar outra célula de código ao bloco de anotações.

   

2. Depois que a nova célula for criada, adicione o código a seguir.

   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. Execute o código selecionando a seta de execução. Isso carrega seus dados de exemplo.

Aprimorar com o Snap to Roads

O código nesta célula do notebook lê dados GPS brutos do arquivo de dados no lakehouse e os passa para a API Snap to Road do Azure Mapas. Com a interpolação habilitada, a API adiciona pontos entre locais GPS para concluir o caminho da rota ao longo da estrada. Ele também fornece atributos como nomes de estrada e limites de velocidade quando disponíveis.

1. Focalize o ponteiro logo abaixo da célula usada para instalar os pacotes na etapa anterior. As opções aparecem para adicionar código ou markdown. Selecione Código para adicionar outra célula de código ao bloco de anotações.

2. Depois que a nova célula for criada, adicione o código a seguir. Adicione sua chave de assinatura.

   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. Execute o código selecionando a seta de execução.

Criar arquivo com dados aprimorados

O código a seguir usa a saída criada na célula de código anterior e cria um novo arquivo CSV no lakehouse chamado SnapRoadResponses.csv. Este novo arquivo de dados contém coordenadas GPS atualizadas alinhadas com a estrada apropriada, ele também inclui nomes de rua e limites de velocidade quando disponível. SnapRoadResponses.csv serão importados para uma casa de eventos e usados para criar um visual de mapa posteriormente neste tutorial.

1. Focalize o ponteiro logo abaixo da célula usada para Aprimorar com o Snap to Roads na etapa anterior. As opções aparecem para adicionar código ou markdown. Selecione Código para adicionar outra célula de código ao bloco de anotações.

2. Depois que a nova célula for criada, adicione o código a seguir.

   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. Execute o código selecionando a seta de execução. Isso salva SnapRoadResponses.csv com coordenadas GPS atualizadas para o lakehouse.

Copiar caminho do arquivo

O caminho do ABFS para SnapRoadResponses.csv é necessário posteriormente neste tutorial quando você cria a casa de eventos. Para obter o caminho do ABFS para esse arquivo, selecione a elipse (...) ao lado do arquivo e, no menu pop-up, selecione Copiar Caminho do ABFS. Depois de copiado, salve-o para mais tarde.

Criar uma casa de eventos e vincular a dados no lakehouse

Crie uma casa de eventos para gerenciar os dados de telemetria para sua frota ou ativos móveis. Um banco de dados KQL é criado automaticamente por padrão. Neste tutorial, você importará os dados ajustados da casa do lago para o banco de dados KQL. Para análise em tempo real, adicione dados de streaming. Depois que os dados forem carregados, você poderá consultar seus dados usando a Linguagem de Consulta Kusto em um conjunto de consultas KQL.

1. Vá para o Meu workspace e selecione Novo item.

2. Quando a tela Novo item for exibida, role para baixo e selecione Eventhouse.

3. Na tela New Eventhouse, insira um nome para sua nova casa de eventos, como SnapToRoadDemo.

   Em seguida, vincule a lakehouse que você criou anteriormente à sua nova casa de eventos.

4. Selecione as reticências ao lado da nova casa de eventos e, em seguida Obter dados > do OneLake no menu pop-up.

   

5. Selecione Nova tabela, nomeie-a GPSData e selecione Avançar.

   

6. Insira o caminho do ABFS para o arquivo de dados lakehouse (SnapRoadResponses.csv) no controle de arquivo OneLake que você salvou anteriormente e selecione o sinal de adição (+) para adicioná-lo à lista.

   

7. Selecione Avançar.

8. Depois de verificar os dados na tela Inspecionar dados, selecione Concluir.

   

9. Selecione Fechar para fechar a página Resumo.

   

O eventhouse agora deve ser criado e conter os dados de GPS.

Criar painel em tempo real

Um Painel em Tempo Real pode ser criado para se conectar ao seu conjunto de dados na casa de eventos. A entrada neste tutorial são dados estáticos, não um fluxo em tempo real, mas os blocos no painel, como o Visual do Azure Mapas, podem ser usados para representação visual e análise.

Adicionar fonte de dados

1. Vá para o Meu workspace e selecione Novo item.

2. Quando a tela Novo item aparecer, pesquise ou role para baixo e selecione Painel em Tempo Real.

3. Na tela Novo Painel em Tempo Real, insira o nome SnapToRoadDashboard e selecione Criar.

4. Na nova tela Painel em tempo real, selecione Nova fonte de dados.

5. Selecione o botão Adicionar e selecione o hub de dados do OneLake.

   

6. Selecione sua fonte de dados e, em seguida, Conectar.

   

7. Insira um nome de exibição e selecione Adicionar.

   

8. Feche o painel Fontes de dados.

Agora que você adicionou a fonte de dados para seu painel em tempo real, você pode adicionar uma consulta e um visual de mapa.

Adicionar visual de consulta e mapa

1. Selecione Adicionar bloco.

   

2. Insira GPSData na consulta e selecione Executar. Depois de verificar se a consulta funciona, selecione Adicionar visual.

   

3. No painel Formatação visual, selecione Mapa na lista suspensa tipo de visual.

4. Em seguida, defina seus valores na seção Dados:

   Configuração de dados	valor
   Definir por local	Latitude e longitude
   Coluna de latitude	latitude (real)
   Coluna de longitude	longitude (real)

5. Atualize o cartão de informações do mapa selecionando um valor na lista suspensa coluna de Rótulo. Selecione SpeedLimitInKilometersPerHour.

6. Selecione Aplicar alterações.

O visual do mapa é exibido. Você pode selecionar qualquer ponto no mapa para obter as coordenadas e limite de velocidade em quilômetros por hora para esse local.

Próximas etapas

Para saber mais sobre notebooks do Microsoft Fabric:

Este tutorial criou um painel para análise de rota pós-viagem. Para obter um guia passo a passo sobre como criar painéis em tempo real no Microsoft Fabric: