Tutorial: Analisar dados de viagem usando o Snap to Roads no notebook Microsoft Fabric

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

Este tutorial explica como usar a API do Azure Maps Snap to Roads com o Microsoft Fabric para analisar dados GPS de ativos em movimento, mesmo quando os dados estão imprecisos ou incompletos devido à perda de sinal. Ele orienta você ao fazer chamadas para a API do Azure Maps Snap to Roads a partir de um notebook do Microsoft Fabric para ajustar os pontos GPS à estrada mais próxima, preencher pontos ausentes usando pontos de dados interpolados e aprimorá-los com atributos adicionais, como nomes de estradas e limites de velocidade.

Neste tutorial, vai:

Pré-requisitos

• Uma conta do Azure Maps
• Uma chave de subscrição
• Uma conta do Microsoft Fabric
• Compreensão básica do Microsoft Fabric.

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

Siga estas etapas para criar um bloco de anotações do Microsoft Fabric:

1. Vá para Meu espaço de trabalho e selecione Novo item.

   

2. Quando o ecrã Novo item for apresentado, desloque-se para baixo e selecione Bloco de Notas.

   

3. Na tela do Explorador do bloco de anotações

   

4. Selecione o botão Adicionar.

   

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

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

Adicionar um arquivo de dados à casa do lago

O Snap to Roads usa dados de pontos GPS (lat, lon) e retorna uma lista de objetos que formam uma rota ajustada às estradas em um mapa. Um arquivo de dados contendo os dados GPS necessários pode ser adicionado como um arquivo para a casa do lago e referenciado pelo código python em seu notebook.

Descarregar ficheiro de dados

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

1. Abra o arquivo mockData_20240919.csv no GitHub.

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

   

Carregue o arquivo de dados no lakehouse

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

1. Na pasta Arquivos no lakehouse, selecione Carregar > arquivos de upload.

   

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

   

Adicionar código ao bloco de notas

Você precisa adicionar e executar quatro células de código em seu bloco de anotações para executar o cenário Ajustar a estradas . As seções a seguir orientam você através disso.

Instalar pacotes

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

!pip install geopandas
!pip install geojson

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

Carregar dados

Em seguida, carregue os dados de amostra que você carregou anteriormente em sua casa do lago.

1. Passe 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 seu bloco de notas.

   

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.

Melhore com o Snap to Roads

O código nesta célula do bloco de notas lê dados GPS brutos do ficheiro de dados no lakehouse e passa-os para a API do Azure Maps Snap to Road. Com a interpolação ativada, a API adiciona pontos entre localizações GPS para completar o caminho da rota ao longo da estrada. Ele também fornece atributos como nomes de estradas e limites de velocidade, quando disponíveis.

1. Passe 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 seu bloco de notas.

2. Depois que a nova célula for criada, adicione o código a seguir. Certifique-se de que adiciona a sua chave de subscrição.

   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 ficheiro com dados melhorados

O código a seguir pega a saída criada na célula de código anterior e cria um novo arquivo CSV na casa do lago chamado SnapRoadResponses.csv. Este novo arquivo de dados contém coordenadas GPS atualizadas que estão alinhadas com a estrada apropriada, também inclui nomes de ruas e limites de velocidade, quando disponíveis. SnapRoadResponses.csv serão importados para uma casa de eventos e usados para criar um mapa visual mais adiante neste tutorial.

1. Passe o ponteiro logo abaixo da célula usada para Aprimorar com Ajustar às estradas 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 seu bloco de notas.

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 economiza SnapRoadResponses.csv com coordenadas GPS atualizadas para a casa do lago.

Copiar caminho do arquivo

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

Criar eventhouse e vincular a dados no lakehouse

Crie uma casa de eventos para gerenciar os dados de telemetria de 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álises em tempo real, adicione dados de streaming. Uma vez que os dados são carregados, você pode consultar seus dados usando Kusto Query Language em um conjunto de consultas KQL.

1. Vá para Meu espaço de trabalho 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 casa do lago que você criou anteriormente à sua nova casa de eventos.

4. Selecione a elipse ao lado de sua nova casa de eventos e, em seguida , Obter dados > OneLake no menu pop-up.

   

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

   

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

   

7. Selecione Seguinte.

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

   

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

   

A casa de eventos deve agora ser criada e conter os dados 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 Azure Maps Visual, podem ser usados para representação visual e análise.

Adicionar origem de dados

1. Vá para Meu espaço de trabalho e selecione Novo item.

2. Quando a tela Novo item for exibida, pesquise ou role para baixo e selecione Painel em tempo real.

3. Na tela Novo Painel em Tempo Real, digite 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, em seguida, selecione Hub de dados OneLake.

   

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

   

7. Introduza um Nome de apresentação e, em seguida, 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 mapa visual.

Adicionar consulta e mapa visual

1. Selecione Adicionar bloco.

   

2. Insira GPSData a 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 visual.

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

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

5. Atualize o cartão de informações do mapa selecionando um valor na lista suspensa da coluna 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 o limite de velocidade em quilômetros por hora para esse local.

Próximos passos

Para saber mais sobre os blocos de anotações do Microsoft Fabric:

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