Cet article vous guidera dans la création d'une application de demande de trajet à l'aide de l'API TomTom Maps. Cette application permettra aux utilisateurs de saisir plusieurs lieux de prise en charge et de dépose, de calculer l'itinéraire optimal et de l'afficher sur une carte. Nous couvrirons tout, de l'obtention de la clé API au rendu de l'itinéraire optimisé sur une carte.

Étape 1 : Configuration de l'API TomTom
Avant de plonger dans le code, vous devrez vous inscrire sur le portail des développeurs TomTom et obtenir une clé API. Cette clé vous permettra d'accéder aux services TomTom tels que le routage, le géocodage et les cartes.

Étape 2 : Implémentation de la fonctionnalité de demande de trajet
Le cœur de l'application consiste à collecter des adresses, à les convertir en coordonnées et à calculer l'itinéraire optimal. Voici comment procéder :

def ride_request(request):
    if request.method == 'POST':
        form = RideForm(request.POST)
        if form.is_valid():
            ride = form.save(commit=False)
            # Get coordinates for the pickup and drop locations
            pickup_coords = get_coordinates(ride.pickup_address)
            pickup_coords_1 = get_coordinates(ride.pickup_address_1)
            pickup_coords_2 = get_coordinates(ride.pickup_address_2)
            drop_coords = get_coordinates(ride.drop_address)

            # Ensure all coordinates are available
            if all([pickup_coords, pickup_coords_1, pickup_coords_2, drop_coords]):
                # Set the coordinates
                ride.pickup_latitude, ride.pickup_longitude = pickup_coords
                ride.pickup_latitude_1, ride.pickup_longitude_1 = pickup_coords_1
                ride.pickup_latitude_2, ride.pickup_longitude_2 = pickup_coords_2
                ride.drop_latitude, ride.drop_longitude = drop_coords

                # Save the ride and redirect to the success page
                try:
                    ride.save()
                    return redirect('success_page', pickup_lon=ride.pickup_longitude, pickup_lat=ride.pickup_latitude,
                                    pickup_lon_1=ride.pickup_longitude_1, pickup_lat_1=ride.pickup_latitude_1,
                                    pickup_lon_2=ride.pickup_longitude_2, pickup_lat_2=ride.pickup_lat_2,
                                    drop_lon=ride.drop_longitude, drop_lat=ride.drop_latitude)
                except IntegrityError as e:
                    messages.error(request, f'IntegrityError: {str(e)}')
            else:
                messages.error(request, 'Error getting coordinates. Please try again.')
    else:
        form = RideForm()

    return render(request, 'maps/ride_request.html', {'form': form})

Dans cet extrait, l'application accepte les entrées de l'utilisateur pour plusieurs adresses, convertit ces adresses en coordonnées à l'aide de la fonction get_coordonnées et enregistre les données pour une utilisation ultérieure.

def get_coordinates(address):
    """
    Get coordinates (latitude, longitude) for a given address using TomTom Geocoding API.
    """
    api_key = 'YOUR_TOMTOM_API_KEY'
    base_url = 'https://api.tomtom.com/search/2/geocode/{address}.json'

    # Prepare the URL with the address and API key
    url = base_url.format(address=address)
    params = {'key': api_key}

    # Make the request to TomTom Geocoding API
    response = requests.get(url, params=params)
    data = response.json()

    # Check if the request was successful
    if response.status_code == 200 and data.get('results'):
        # Extract coordinates from the response
        result = data['results'][0]
        if 'position' in result:
            coordinates = result['position']
            return coordinates.get('lat'), coordinates.get('lon')
        else:
            print(
                f"Error getting coordinates for {address}: 'position' key not found in the response.")
            return None
    else:
        # Handle errors or return a default value
        print(
            f"Error getting coordinates for {address}: {data.get('message')}")
        return None

Étape 3 : Calcul de l'itinéraire optimisé
Une fois que vous avez les coordonnées, l’étape suivante consiste à calculer l’itinéraire optimisé. L'API Waypoint Optimization de TomTom aide à déterminer le chemin le plus efficace entre plusieurs points.

def get_optimized_route(*pickup_coords, drop_coords):
    api_key = 'YOUR_TOMTOM_API_KEY'

    # Prepare the payload for the API
    payload = {
        'waypoints': [{'point': {'latitude': lat, 'longitude': lon}} for lon, lat in pickup_coords],
        'options': {'travelMode': 'car'},
    }

    # Add the drop location to the waypoints
    payload['waypoints'].append({'point': {'latitude': drop_coords[1], 'longitude': drop_coords[0]}})

    # API request
    response = requests.post(f'https://api.tomtom.com/routing/waypointoptimization/1',
                             params={'key': api_key},
                             json=payload)

    if response.status_code == 200:
        data = response.json()
        if 'optimizedOrder' in data:
            # Extract the optimized route
            return [get_route_geometry(pickup_coords[i], pickup_coords[j]) 
                    for i, j in zip(data['optimizedOrder'], data['optimizedOrder'][1:])]
    return None

Cette fonction envoie une requête à l'API TomTom, reçoit l'ordre optimisé des waypoints, puis calcule la géométrie de l'itinéraire.

Étape 4 : Rendu de la carte et de l'itinéraire
Enfin, après avoir obtenu les données d'itinéraire optimisées, il est temps d'afficher la carte sur votre success_page.html.

{% load static %}



    
    
    
    
    
    
    


    

        

    
    
    

Ce code HTML initialise la carte TomTom, place des marqueurs sur les points de prise en charge et de dépose et trace l'itinéraire entre eux.

Résultat : formulaire de demande de trajet et carte de réussite

Remarque : le code fourni ci-dessus est un exemple simplifié pour démontrer les fonctionnalités de base de demande de course et de calcul d'itinéraires à l'aide de l'API de TomTom. La mise en œuvre réelle peut différer et inclure des fonctionnalités supplémentaires ou des variantes basées sur des exigences spécifiques. Pour des informations plus détaillées et une utilisation avancée, veuillez vous référer à la documentation officielle du développeur TomTom.